allagents 1.4.11 → 1.6.0

package/dist/index.js

@@ -7465,9 +7465,26 @@ __export(exports_constants, {
 function getHomeDir() {
   return process.env.HOME || process.env.USERPROFILE || "~";
 }
-function generateWorkspaceRules(repositories) {
+function generateWorkspaceRules(repositories, skills = []) {
   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(`
+`);
+    skillsBlock = `
+## Workspace Skills
+When a task matches a skill description, fetch the full instructions from its location.
+
+<available_skills>
+${skillEntries}
+</available_skills>
+`;
+  }
   return `
 <!-- WORKSPACE-RULES:START -->
 ## Workspace Repositories
@@ -7477,7 +7494,7 @@ ${repoList}
 ## Rule: Use Repository Paths
 TRIGGER: File operations (read, search, modify)
 ACTION: Use the repository paths listed above, not assumptions
-<!-- WORKSPACE-RULES:END -->
+${skillsBlock}<!-- WORKSPACE-RULES:END -->
 `;
 }
 var CONFIG_DIR = ".allagents", SYNC_STATE_FILE = "sync-state.json", WORKSPACE_CONFIG_FILE = "workspace.yaml", WORKSPACE_CONFIG_PATH, AGENT_FILES;
@@ -11488,7 +11505,8 @@ var init_workspace_config = __esm(() => {
     name: exports_external.string().optional(),
     source: exports_external.string().optional(),
     repo: exports_external.string().optional(),
-    description: exports_external.string().optional()
+    description: exports_external.string().optional(),
+    skills: exports_external.union([exports_external.boolean(), exports_external.array(exports_external.string())]).optional()
   });
   WorkspaceFileSchema = exports_external.union([
     exports_external.string(),
@@ -25482,8 +25500,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) {
-  const rulesContent = generateWorkspaceRules(repositories);
+async function ensureWorkspaceRules(filePath, repositories, skills = []) {
+  const rulesContent = generateWorkspaceRules(repositories, skills);
   const startMarker = "<!-- WORKSPACE-RULES:START -->";
   const endMarker = "<!-- WORKSPACE-RULES:END -->";
   if (!existsSync4(filePath)) {
@@ -25916,7 +25934,7 @@ function resolveFileSourcePath(source, defaultSourcePath, githubCache) {
   return null;
 }
 async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {}) {
-  const { dryRun = false, githubCache, repositories = [] } = options2;
+  const { dryRun = false, githubCache, repositories = [], skills = [] } = options2;
   const results = [];
   const stringPatterns = [];
   const objectEntries = [];
@@ -26069,7 +26087,7 @@ async function copyWorkspaceFiles(sourcePath, workspacePath, files, options2 = {
     for (const agentFile of copiedAgentFiles) {
       const targetPath = join7(workspacePath, agentFile);
       try {
-        await ensureWorkspaceRules(targetPath, repositories);
+        await ensureWorkspaceRules(targetPath, repositories, skills);
       } catch (error) {
         results.push({
           source: "WORKSPACE-RULES",
@@ -27013,7 +27031,7 @@ function parseMarketplaceSource(source) {
     name
   };
 }
-async function addMarketplace(source, customName, branch, force, scopeOptions) {
+async function addMarketplace(source, customName, branch, _force, scopeOptions) {
   const parsed = parseMarketplaceSource(source);
   if (!parsed) {
     return {
@@ -27050,9 +27068,7 @@ async function addMarketplace(source, customName, branch, force, scopeOptions) {
     return parsed.location;
   })();
   const existingBySource = findBySourceLocation(registry, sourceLocation);
-  if (existingBySource && !force) {
-    return { success: true, marketplace: existingBySource, alreadyRegistered: true };
-  }
+  let alreadyRegistered = !!existingBySource;
   let marketplacePath;
   if (parsed.type === "github" || parsed.type === "git") {
     marketplacePath = join10(getMarketplacesDir(), name);
@@ -27104,24 +27120,15 @@ async function addMarketplace(source, customName, branch, force, scopeOptions) {
     if (manifestResult.success && manifestResult.data.name) {
       const manifestName = manifestResult.data.name;
       if (manifestName !== name) {
-        const existing = registry.marketplaces[manifestName];
-        if (existing && !force) {
-          return {
-            success: true,
-            marketplace: existing,
-            alreadyRegistered: true
-          };
+        if (registry.marketplaces[manifestName]) {
+          alreadyRegistered = true;
         }
         name = manifestName;
       }
     }
   }
-  const wasAlreadyRegistered = !!registry.marketplaces[name];
-  if (wasAlreadyRegistered && !force) {
-    return {
-      success: false,
-      error: `Marketplace '${name}' already exists. Use 'update' to refresh it.`
-    };
+  if (registry.marketplaces[name]) {
+    alreadyRegistered = true;
   }
   let entryLocation;
   if (parsed.type === "github") {
@@ -27144,7 +27151,7 @@ async function addMarketplace(source, customName, branch, force, scopeOptions) {
   return {
     success: true,
     marketplace: entry,
-    ...wasAlreadyRegistered && force && { replaced: true }
+    ...alreadyRegistered && { replaced: true }
   };
 }
 async function removeMarketplace(name, options2 = {}) {
@@ -27584,7 +27591,7 @@ async function autoRegisterMarketplace(source) {
         return { success: false, error: result.error || "Unknown error" };
       }
       const name = result.marketplace?.name ?? parts[1];
-      if (!result.alreadyRegistered) {
+      if (!result.replaced) {
         console.log(`Auto-registered GitHub marketplace: ${source}`);
       }
       registeredSourceCache.set(source, name);
@@ -28358,10 +28365,100 @@ var init_workspace_modify = __esm(() => {
   DEFAULT_PROJECT_CLIENTS = ["universal"];
 });
 
+// src/core/repo-skills.ts
+import { existsSync as existsSync9, lstatSync } 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";
+async function discoverRepoSkills(repoPath, options2) {
+  if (options2.disabled)
+    return [];
+  const skillDirs = new Set;
+  if (options2.skillPaths) {
+    for (const p of options2.skillPaths) {
+      skillDirs.add(p);
+    }
+  } else if (options2.clients) {
+    for (const client of options2.clients) {
+      const mapping = CLIENT_MAPPINGS[client];
+      if (mapping?.skillsPath) {
+        skillDirs.add(mapping.skillsPath);
+      }
+    }
+  }
+  const results = [];
+  const seen = new Set;
+  for (const skillDir of skillDirs) {
+    const absDir = join12(repoPath, skillDir);
+    if (!existsSync9(absDir))
+      continue;
+    let entries;
+    try {
+      entries = await readdir4(absDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const entryPath = join12(absDir, entry.name);
+      try {
+        const stat2 = lstatSync(entryPath);
+        if (stat2.isSymbolicLink())
+          continue;
+      } catch {
+        continue;
+      }
+      const skillMdPath = join12(entryPath, "SKILL.md");
+      if (!existsSync9(skillMdPath))
+        continue;
+      const relPath = relative3(repoPath, skillMdPath);
+      if (seen.has(relPath))
+        continue;
+      try {
+        const content = await readFile8(skillMdPath, "utf-8");
+        const metadata = parseSkillMetadata(content);
+        if (!metadata)
+          continue;
+        seen.add(relPath);
+        results.push({
+          name: metadata.name,
+          description: metadata.description,
+          relativePath: relPath
+        });
+      } catch {}
+    }
+  }
+  return results;
+}
+async function discoverWorkspaceSkills(workspacePath, repositories, clientNames) {
+  const allSkills = [];
+  for (const repo of repositories) {
+    if (repo.skills === false)
+      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({
+        repoPath: repo.path,
+        name: skill.name,
+        description: skill.description,
+        location
+      });
+    }
+  }
+  return allSkills;
+}
+var init_repo_skills = __esm(() => {
+  init_skill();
+  init_client_mapping();
+});
+
 // src/core/workspace-repo.ts
-import { readFile as readFile8, writeFile as writeFile5 } from "node:fs/promises";
-import { existsSync as existsSync9 } from "node:fs";
-import { join as join12 } from "node:path";
+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";
 async function detectRemote(repoPath) {
   try {
     const env2 = { ...process.env };
@@ -28403,10 +28500,10 @@ function normalizePath(p) {
 }
 async function addRepository(path, options2 = {}, workspacePath = process.cwd()) {
   const normalizedPath = normalizePath(path);
-  const configPath = join12(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
   await ensureWorkspace(workspacePath);
   try {
-    const content = await readFile8(configPath, "utf-8");
+    const content = await readFile9(configPath, "utf-8");
     const config = load(content);
     if (config.repositories.some((r) => normalizePath(r.path) === normalizedPath)) {
       return { success: false, error: `Repository already exists: ${normalizedPath}` };
@@ -28426,8 +28523,8 @@ async function addRepository(path, options2 = {}, workspacePath = process.cwd())
   }
 }
 async function removeRepository(path, workspacePath = process.cwd()) {
-  const configPath = join12(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync9(configPath)) {
+  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync10(configPath)) {
     return {
       success: false,
       error: `${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
@@ -28435,7 +28532,7 @@ async function removeRepository(path, workspacePath = process.cwd()) {
     };
   }
   try {
-    const content = await readFile8(configPath, "utf-8");
+    const content = await readFile9(configPath, "utf-8");
     const config = load(content);
     const normalizedPath = normalizePath(path);
     const index = config.repositories.findIndex((r) => normalizePath(r.path) === normalizedPath);
@@ -28450,34 +28547,40 @@ async function removeRepository(path, workspacePath = process.cwd()) {
   }
 }
 async function listRepositories(workspacePath = process.cwd()) {
-  const configPath = join12(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync9(configPath))
+  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync10(configPath))
     return [];
   try {
-    const content = await readFile8(configPath, "utf-8");
+    const content = await readFile9(configPath, "utf-8");
     const config = load(content);
     return config.repositories ?? [];
   } catch {
     return [];
   }
 }
+function resolveClientNames(clients) {
+  return (clients ?? []).map((c) => typeof c === "string" ? c : c.name);
+}
 async function updateAgentFiles(workspacePath = process.cwd()) {
-  const configPath = join12(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync9(configPath))
+  const configPath = join13(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync10(configPath))
     return;
-  const content = await readFile8(configPath, "utf-8");
+  const content = await readFile9(configPath, "utf-8");
   const config = load(content);
   if (config.repositories.length === 0)
     return;
+  const clientNames = resolveClientNames(config.clients);
+  const allSkills = await discoverWorkspaceSkills(workspacePath, config.repositories, clientNames);
   const agentFiles = new Set;
   for (const client of config.clients ?? []) {
-    const mapping = CLIENT_MAPPINGS[client];
+    const clientName = typeof client === "string" ? client : client.name;
+    const mapping = CLIENT_MAPPINGS[clientName];
     if (mapping?.agentFile)
       agentFiles.add(mapping.agentFile);
   }
   agentFiles.add("AGENTS.md");
   for (const agentFile of agentFiles) {
-    await ensureWorkspaceRules(join12(workspacePath, agentFile), config.repositories);
+    await ensureWorkspaceRules(join13(workspacePath, agentFile), config.repositories, allSkills);
   }
 }
 var init_workspace_repo = __esm(() => {
@@ -28486,6 +28589,7 @@ var init_workspace_repo = __esm(() => {
   init_workspace_modify();
   init_transform();
   init_client_mapping();
+  init_repo_skills();
 });
 
 // src/utils/hash.ts
@@ -28651,20 +28755,48 @@ 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";
+async function ensureConfigGitignore(workspacePath) {
+  const gitignorePath = join14(workspacePath, CONFIG_DIR, ".gitignore");
+  let existing = "";
+  if (existsSync11(gitignorePath)) {
+    existing = await readFile10(gitignorePath, "utf-8");
+  }
+  const missing = GITIGNORE_ENTRIES.filter((entry) => !existing.split(`
+`).includes(entry));
+  if (missing.length === 0)
+    return;
+  const content = existing ? `${existing.trimEnd()}
+${missing.join(`
+`)}
+` : `${missing.join(`
+`)}
+`;
+  await writeFile6(gitignorePath, content, "utf-8");
+}
+var GITIGNORE_ENTRIES;
+var init_config_gitignore = __esm(() => {
+  init_constants();
+  GITIGNORE_ENTRIES = [SYNC_STATE_FILE];
+});
+
 // src/core/sync-state.ts
-import { readFile as readFile9, writeFile as writeFile6, mkdir as mkdir7 } from "node:fs/promises";
-import { existsSync as existsSync10 } from "node:fs";
-import { join as join13, dirname as dirname6 } from "node:path";
+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";
 function getSyncStatePath(workspacePath) {
-  return join13(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
+  return join15(workspacePath, CONFIG_DIR, SYNC_STATE_FILE);
 }
 async function loadSyncState(workspacePath) {
   const statePath = getSyncStatePath(workspacePath);
-  if (!existsSync10(statePath)) {
+  if (!existsSync12(statePath)) {
     return null;
   }
   try {
-    const content = await readFile9(statePath, "utf-8");
+    const content = await readFile11(statePath, "utf-8");
     const parsed = JSON.parse(content);
     const result = SyncStateSchema.safeParse(parsed);
     if (!result.success) {
@@ -28688,7 +28820,8 @@ async function saveSyncState(workspacePath, data) {
     ...normalizedData.vscodeWorkspaceRepos && { vscodeWorkspaceRepos: normalizedData.vscodeWorkspaceRepos }
   };
   await mkdir7(dirname6(statePath), { recursive: true });
-  await writeFile6(statePath, JSON.stringify(state, null, 2), "utf-8");
+  await ensureConfigGitignore(workspacePath);
+  await writeFile7(statePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function getPreviouslySyncedFiles(state, client) {
   if (!state) {
@@ -28710,15 +28843,16 @@ function getPreviouslySyncedNativePlugins(state, client) {
 var init_sync_state2 = __esm(() => {
   init_constants();
   init_sync_state();
+  init_config_gitignore();
 });
 
 // src/core/vscode-workspace.ts
 import { createHash as createHash2 } from "node:crypto";
-import { resolve as resolve8, basename as basename5, isAbsolute as isAbsolute3, relative as relative3 } from "node:path";
+import { resolve as resolve9, basename as basename5, isAbsolute as isAbsolute3, relative as relative4 } from "node:path";
 function buildPathPlaceholderMap(repositories, workspacePath) {
   const map2 = new Map;
   for (const repo of repositories) {
-    const absolutePath = resolve8(workspacePath, repo.path);
+    const absolutePath = resolve9(workspacePath, repo.path);
     map2.set(repo.path, absolutePath);
   }
   return map2;
@@ -28753,9 +28887,9 @@ function generateVscodeWorkspace(input) {
   const folders = [];
   const seenPaths = new Set;
   folders.push({ path: "." });
-  seenPaths.add(resolve8(workspacePath, "."));
+  seenPaths.add(resolve9(workspacePath, "."));
   for (const repo of repositories) {
-    const absolutePath = resolve8(workspacePath, repo.path).replace(/\\/g, "/");
+    const absolutePath = resolve9(workspacePath, repo.path).replace(/\\/g, "/");
     const entry = { path: absolutePath };
     if (repo.name)
       entry.name = repo.name;
@@ -28765,7 +28899,7 @@ function generateVscodeWorkspace(input) {
   if (resolvedTemplate && Array.isArray(resolvedTemplate.folders)) {
     for (const folder of resolvedTemplate.folders) {
       const rawPath = folder.path;
-      const normalizedPath = (typeof rawPath === "string" && !isAbsolute3(rawPath) ? resolve8(workspacePath, rawPath) : rawPath).replace(/\\/g, "/");
+      const normalizedPath = (typeof rawPath === "string" && !isAbsolute3(rawPath) ? resolve9(workspacePath, rawPath) : rawPath).replace(/\\/g, "/");
       if (!seenPaths.has(normalizedPath)) {
         const entry = { path: normalizedPath };
         if (folder.name)
@@ -28795,22 +28929,22 @@ function getWorkspaceOutputPath(workspacePath, vscodeConfig) {
   const name = vscodeConfig?.output;
   if (name) {
     const filename = name.endsWith(".code-workspace") ? name : `${name}.code-workspace`;
-    return resolve8(workspacePath, filename);
+    return resolve9(workspacePath, filename);
   }
-  const dirName = basename5(resolve8(workspacePath));
-  return resolve8(workspacePath, `${dirName}.code-workspace`);
+  const dirName = basename5(resolve9(workspacePath));
+  return resolve9(workspacePath, `${dirName}.code-workspace`);
 }
 function computeWorkspaceHash(content) {
   return createHash2("sha256").update(content).digest("hex");
 }
 function reconcileVscodeWorkspaceFolders(workspacePath, codeWorkspaceFolders, lastSyncedRepos, currentRepos) {
-  const normalizedWorkspacePath = resolve8(workspacePath).replace(/\\/g, "/");
+  const normalizedWorkspacePath = resolve9(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 : resolve8(workspacePath, folder.path)).replace(/\\/g, "/");
+    const absPath = (isAbsolute3(folder.path) ? folder.path : resolve9(workspacePath, folder.path)).replace(/\\/g, "/");
     codeWorkspaceAbsPaths.add(absPath);
     if (folder.name)
       codeWorkspaceNames.set(absPath, folder.name);
@@ -28818,7 +28952,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 = resolve8(workspacePath, repo.path).replace(/\\/g, "/");
+    const absPath = resolve9(workspacePath, repo.path).replace(/\\/g, "/");
     currentReposByAbsPath.set(absPath, repo);
   }
   const currentAbsPaths = new Set(currentReposByAbsPath.keys());
@@ -28834,10 +28968,9 @@ function reconcileVscodeWorkspaceFolders(workspacePath, codeWorkspaceFolders, la
     } else {
       const folderName = codeWorkspaceNames.get(absPath);
       if (folderName !== repo.name) {
-        const updatedRepo = { ...repo };
-        if (folderName === undefined) {
-          delete updatedRepo.name;
-        } else {
+        const { name: _name, ...repoWithoutName } = repo;
+        const updatedRepo = folderName === undefined ? { ...repoWithoutName } : { ...repo };
+        if (folderName !== undefined) {
           updatedRepo.name = folderName;
         }
         updatedRepos.push(updatedRepo);
@@ -28851,7 +28984,7 @@ function reconcileVscodeWorkspaceFolders(workspacePath, codeWorkspaceFolders, la
     const inLastSync = lastSyncedSet.has(absPath);
     const inCurrentRepos = currentAbsPaths.has(absPath);
     if (!inLastSync && !inCurrentRepos) {
-      const relPath = relative3(normalizedWorkspacePath, absPath).replace(/\\/g, "/");
+      const relPath = relative4(normalizedWorkspacePath, absPath).replace(/\\/g, "/");
       added.push(relPath);
       const newRepo = { path: relPath };
       const folderName = codeWorkspaceNames.get(absPath);
@@ -28870,8 +29003,8 @@ var init_vscode_workspace = __esm(() => {
 });
 
 // src/core/vscode-mcp.ts
-import { existsSync as existsSync11, readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { join as join14, dirname as dirname7 } from "node:path";
+import { existsSync as existsSync13, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join as join16, dirname as dirname7 } from "node:path";
 function deepEqual(a, b) {
   if (a === b)
     return true;
@@ -28903,17 +29036,17 @@ function getVscodeMcpConfigPath() {
     if (!appData) {
       throw new Error("APPDATA environment variable not set");
     }
-    return join14(appData, "Code", "User", "mcp.json");
+    return join16(appData, "Code", "User", "mcp.json");
   }
   const home = getHomeDir();
   if (platform2 === "darwin") {
-    return join14(home, "Library", "Application Support", "Code", "User", "mcp.json");
+    return join16(home, "Library", "Application Support", "Code", "User", "mcp.json");
   }
-  return join14(home, ".config", "Code", "User", "mcp.json");
+  return join16(home, ".config", "Code", "User", "mcp.json");
 }
 function readPluginMcpConfig(pluginPath) {
-  const mcpPath = join14(pluginPath, ".mcp.json");
-  if (!existsSync11(mcpPath)) {
+  const mcpPath = join16(pluginPath, ".mcp.json");
+  if (!existsSync13(mcpPath)) {
     return null;
   }
   try {
@@ -28964,7 +29097,7 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingConfig = {};
-  if (existsSync11(configPath)) {
+  if (existsSync13(configPath)) {
     try {
       const content = readFileSync(configPath, "utf-8");
       existingConfig = import_json5.default.parse(content);
@@ -29015,7 +29148,7 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
   if (hasChanges && !dryRun) {
     existingConfig.servers = existingServers;
     const dir = dirname7(configPath);
-    if (!existsSync11(dir)) {
+    if (!existsSync13(dir)) {
       mkdirSync(dir, { recursive: true });
     }
     writeFileSync(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -29033,7 +29166,7 @@ function syncVscodeMcpConfig(validatedPlugins, options2) {
     if (result.removed > 0 && !dryRun) {
       existingConfig.servers = existingServers;
       const dir = dirname7(configPath);
-      if (!existsSync11(dir)) {
+      if (!existsSync13(dir)) {
         mkdirSync(dir, { recursive: true });
       }
       writeFileSync(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -29052,7 +29185,7 @@ var init_vscode_mcp = __esm(() => {
 // src/core/native/types.ts
 import { spawn as spawn2 } from "node:child_process";
 function executeCommand(binary2, args, options2 = {}) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const proc = spawn2(binary2, args, {
       cwd: options2.cwd,
       stdio: ["ignore", "pipe", "pipe"],
@@ -29073,7 +29206,7 @@ function executeCommand(binary2, args, options2 = {}) {
         return;
       resolved = true;
       const trimmedStderr = stderr.trim();
-      resolve9({
+      resolve10({
         success: code === 0,
         output: stdout.trim(),
         ...trimmedStderr && { error: trimmedStderr }
@@ -29083,7 +29216,7 @@ function executeCommand(binary2, args, options2 = {}) {
       if (resolved)
         return;
       resolved = true;
-      resolve9({
+      resolve10({
         success: false,
         output: "",
         error: `Failed to execute ${binary2} CLI: ${err.message}`
@@ -29102,7 +29235,7 @@ function mergeNativeSyncResults(results) {
 var init_types2 = () => {};
 
 // src/core/codex-mcp.ts
-import { existsSync as existsSync12, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
+import { existsSync as existsSync14, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "node:fs";
 import { dirname as dirname8 } from "node:path";
 function buildCodexMcpAddArgs(name, config) {
   if (typeof config.url === "string") {
@@ -29313,7 +29446,7 @@ function syncCodexProjectMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingContent = "";
-  if (existsSync12(configPath)) {
+  if (existsSync14(configPath)) {
     try {
       existingContent = readFileSync2(configPath, "utf-8");
     } catch {
@@ -29369,7 +29502,7 @@ function syncCodexProjectMcpConfig(validatedPlugins, options2) {
 `)}
 `;
     const dir = dirname8(configPath);
-    if (!existsSync12(dir)) {
+    if (!existsSync14(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     writeFileSync2(configPath, output, "utf-8");
@@ -29383,7 +29516,7 @@ var init_codex_mcp = __esm(() => {
 });
 
 // src/core/claude-mcp.ts
-import { existsSync as existsSync13, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
+import { existsSync as existsSync15, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "node:fs";
 import { dirname as dirname9 } from "node:path";
 function deepEqual2(a, b) {
   if (a === b)
@@ -29451,7 +29584,7 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
     trackedServers: []
   };
   let existingConfig = {};
-  if (existsSync13(configPath)) {
+  if (existsSync15(configPath)) {
     try {
       const content = readFileSync3(configPath, "utf-8");
       existingConfig = import_json52.default.parse(content);
@@ -29502,7 +29635,7 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
   if (hasChanges && !dryRun) {
     existingConfig.mcpServers = existingServers;
     const dir = dirname9(configPath);
-    if (!existsSync13(dir)) {
+    if (!existsSync15(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     writeFileSync3(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -29520,7 +29653,7 @@ function syncClaudeMcpConfig(validatedPlugins, options2) {
     if (result.removed > 0 && !dryRun) {
       existingConfig.mcpServers = existingServers;
       const dir = dirname9(configPath);
-      if (!existsSync13(dir)) {
+      if (!existsSync15(dir)) {
         mkdirSync3(dir, { recursive: true });
       }
       writeFileSync3(configPath, `${JSON.stringify(existingConfig, null, 2)}
@@ -29619,9 +29752,9 @@ var init_claude_mcp = __esm(() => {
 });
 
 // src/core/copilot-mcp.ts
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 function getCopilotMcpConfigPath() {
-  return join15(getHomeDir(), ".copilot", "mcp-config.json");
+  return join17(getHomeDir(), ".copilot", "mcp-config.json");
 }
 var init_copilot_mcp = __esm(() => {
   init_constants();
@@ -29919,9 +30052,9 @@ function padStart2(str3, len) {
 }
 
 // src/core/sync.ts
-import { existsSync as existsSync14, readFileSync as readFileSync4, writeFileSync as writeFileSync4, lstatSync } from "node:fs";
+import { existsSync as existsSync16, readFileSync as readFileSync4, writeFileSync as writeFileSync4, lstatSync as lstatSync2 } from "node:fs";
 import { rm as rm4, unlink as unlink2, rmdir, copyFile } from "node:fs/promises";
-import { join as join16, resolve as resolve9, dirname as dirname10, relative as relative4 } from "node:path";
+import { join as join18, resolve as resolve10, dirname as dirname10, relative as relative5 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -30035,11 +30168,11 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
     const previousFiles = getPreviouslySyncedFiles(state, client);
     const purgedPaths = [];
     for (const filePath of previousFiles) {
-      const fullPath = join16(workspacePath, filePath);
+      const fullPath = join18(workspacePath, filePath);
       const cleanPath = fullPath.replace(/\/$/, "");
       let stats;
       try {
-        stats = lstatSync(cleanPath);
+        stats = lstatSync2(cleanPath);
       } catch {
         continue;
       }
@@ -30064,8 +30197,8 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
 async function cleanupEmptyParents(workspacePath, filePath) {
   let parentPath = dirname10(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
-    const fullParentPath = join16(workspacePath, parentPath);
-    if (!existsSync14(fullParentPath)) {
+    const fullParentPath = join18(workspacePath, parentPath);
+    if (!existsSync16(fullParentPath)) {
       parentPath = dirname10(parentPath);
       continue;
     }
@@ -30150,8 +30283,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         errors2.push(`Cannot resolve file '${file}' - no workspace.source configured`);
         continue;
       }
-      const fullPath = join16(defaultSourcePath, file);
-      if (!existsSync14(fullPath)) {
+      const fullPath = join18(defaultSourcePath, file);
+      if (!existsSync16(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -30169,8 +30302,8 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           errors2.push(`GitHub cache not found for ${cacheKey}`);
           continue;
         }
-        const fullPath = join16(cachePath, parsed.filePath);
-        if (!existsSync14(fullPath)) {
+        const fullPath = join18(cachePath, parsed.filePath);
+        if (!existsSync16(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -30178,13 +30311,13 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         if (file.source.startsWith("/")) {
           fullPath = file.source;
         } else if (file.source.startsWith("../")) {
-          fullPath = resolve9(file.source);
+          fullPath = resolve10(file.source);
         } else if (defaultSourcePath) {
-          fullPath = join16(defaultSourcePath, file.source);
+          fullPath = join18(defaultSourcePath, file.source);
         } else {
-          fullPath = resolve9(file.source);
+          fullPath = resolve10(file.source);
         }
-        if (!existsSync14(fullPath)) {
+        if (!existsSync16(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -30193,8 +30326,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 = join16(defaultSourcePath, file.dest ?? "");
-      if (!existsSync14(fullPath)) {
+      const fullPath = join18(defaultSourcePath, file.dest ?? "");
+      if (!existsSync16(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -30211,7 +30344,7 @@ function collectSyncedPaths(copyResults, workspacePath, clients, clientMappings)
     if (copyResult.action !== "copied" && copyResult.action !== "generated") {
       continue;
     }
-    const relativePath = relative4(workspacePath, copyResult.destination).replace(/\\/g, "/");
+    const relativePath = relative5(workspacePath, copyResult.destination).replace(/\\/g, "/");
     for (const client of clients) {
       const mapping = mappings[client];
       if (mapping.skillsPath && relativePath.startsWith(mapping.skillsPath)) {
@@ -30340,7 +30473,7 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
         ...fetchResult.error && { error: fetchResult.error }
       };
     }
-    const resolvedPath2 = parsed?.subpath ? join16(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
+    const resolvedPath2 = parsed?.subpath ? join18(fetchResult.cachePath, parsed.subpath) : fetchResult.cachePath;
     return {
       plugin: pluginSource,
       resolved: resolvedPath2,
@@ -30349,8 +30482,8 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
       nativeClients: []
     };
   }
-  const resolvedPath = resolve9(workspacePath, pluginSource);
-  if (!existsSync14(resolvedPath)) {
+  const resolvedPath = resolve10(workspacePath, pluginSource);
+  if (!existsSync16(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -30511,10 +30644,10 @@ function buildPluginSkillNameMaps(allSkills) {
   return pluginMaps;
 }
 function generateVscodeWorkspaceFile(workspacePath, config) {
-  const configDir = join16(workspacePath, CONFIG_DIR);
-  const templatePath = join16(configDir, VSCODE_TEMPLATE_FILE);
+  const configDir = join18(workspacePath, CONFIG_DIR);
+  const templatePath = join18(configDir, VSCODE_TEMPLATE_FILE);
   let template;
-  if (existsSync14(templatePath)) {
+  if (existsSync16(templatePath)) {
     try {
       template = import_json53.default.parse(readFileSync4(templatePath, "utf-8"));
     } catch (error) {
@@ -30661,7 +30794,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   let updatedConfig = config;
   if (previousState?.vscodeWorkspaceHash && previousState?.vscodeWorkspaceRepos) {
     const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
-    if (existsSync14(outputPath)) {
+    if (existsSync16(outputPath)) {
       const existingContent = readFileSync4(outputPath, "utf-8");
       const currentHash = computeWorkspaceHash(existingContent);
       if (currentHash !== previousState.vscodeWorkspaceHash) {
@@ -30691,7 +30824,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   }
   const writtenContent = generateVscodeWorkspaceFile(workspacePath, updatedConfig);
   const hash = computeWorkspaceHash(writtenContent);
-  const repos = updatedConfig.repositories.map((r) => resolve9(workspacePath, r.path).replace(/\\/g, "/"));
+  const repos = updatedConfig.repositories.map((r) => resolve10(workspacePath, r.path).replace(/\\/g, "/"));
   return { config: updatedConfig, hash, repos };
 }
 async function persistSyncState(workspacePath, pluginResults, workspaceFileResults, syncClients, nativePluginsByClient, nativeResult, extra) {
@@ -30725,9 +30858,9 @@ 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 = join16(workspacePath, CONFIG_DIR);
-  const configPath = join16(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync14(configPath)) {
+  const configDir = join18(workspacePath, CONFIG_DIR);
+  const configPath = join18(configDir, WORKSPACE_CONFIG_FILE);
+  if (!existsSync16(configPath)) {
     return failedSyncResult(`${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
   Run 'allagents workspace init <path>' to create a new workspace`);
   }
@@ -30816,8 +30949,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 = join16(sourcePath, agentFile);
-        if (existsSync14(agentPath) && !filesToCopy.includes(agentFile)) {
+        const agentPath = join18(sourcePath, agentFile);
+        if (existsSync16(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -30839,12 +30972,13 @@ ${errors2.map((e) => `  - ${e}`).join(`
 ${fileValidationErrors.map((e) => `  - ${e}`).join(`
 `)}`, { pluginResults, totalFailed: fileValidationErrors.length });
     }
-    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache, repositories: config.repositories });
+    const repoSkills = hasRepositories && !dryRun ? await discoverWorkspaceSkills(workspacePath, config.repositories, syncClients) : [];
+    workspaceFileResults = await copyWorkspaceFiles(sourcePath, workspacePath, filesToCopy, { dryRun, githubCache, repositories: config.repositories, skills: repoSkills });
     if (hasRepositories && !dryRun && syncClients.includes("claude") && sourcePath) {
-      const claudePath = join16(workspacePath, "CLAUDE.md");
-      const agentsPath = join16(workspacePath, "AGENTS.md");
-      const claudeExistsInSource = existsSync14(join16(sourcePath, "CLAUDE.md"));
-      if (!claudeExistsInSource && existsSync14(agentsPath) && !existsSync14(claudePath)) {
+      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)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -30865,7 +30999,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   const mcpResults = {};
   if (syncClients.includes("vscode")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "vscode");
-    const projectMcpPath = join16(workspacePath, ".vscode", "mcp.json");
+    const projectMcpPath = join18(workspacePath, ".vscode", "mcp.json");
     const vscodeMcp = syncVscodeMcpConfig(validPlugins, {
       dryRun,
       force: false,
@@ -30879,7 +31013,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   }
   if (syncClients.includes("claude")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "claude");
-    const projectMcpJsonPath = join16(workspacePath, ".mcp.json");
+    const projectMcpJsonPath = join18(workspacePath, ".mcp.json");
     const claudeMcp = syncClaudeMcpConfig(validPlugins, {
       dryRun,
       force: false,
@@ -30893,7 +31027,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   }
   if (syncClients.includes("codex")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "codex");
-    const projectCodexConfigPath = join16(workspacePath, ".codex", "config.toml");
+    const projectCodexConfigPath = join18(workspacePath, ".codex", "config.toml");
     const codexMcp = syncCodexProjectMcpConfig(validPlugins, {
       dryRun,
       force: false,
@@ -30907,7 +31041,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   }
   if (syncClients.includes("copilot")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "copilot");
-    const projectCopilotMcpPath = join16(workspacePath, ".copilot", "mcp-config.json");
+    const projectCopilotMcpPath = join18(workspacePath, ".copilot", "mcp-config.json");
     const copilotMcp = syncClaudeMcpConfig(validPlugins, {
       dryRun,
       force: false,
@@ -30977,7 +31111,7 @@ async function seedFetchCacheFromMarketplaces(results) {
 }
 function readGitBranch(repoPath) {
   try {
-    const head = readFileSync4(join16(repoPath, ".git", "HEAD"), "utf-8").trim();
+    const head = readFileSync4(join18(repoPath, ".git", "HEAD"), "utf-8").trim();
     const prefix = "ref: refs/heads/";
     return head.startsWith(prefix) ? head.slice(prefix.length) : null;
   } catch {
@@ -30987,7 +31121,7 @@ function readGitBranch(repoPath) {
 async function syncUserWorkspace(options2 = {}) {
   await migrateUserWorkspaceSkillsV1toV2();
   const sw = new Stopwatch;
-  const homeDir = resolve9(getHomeDir());
+  const homeDir = resolve10(getHomeDir());
   const config = await getUserWorkspaceConfig();
   if (!config) {
     return {
@@ -31125,6 +31259,7 @@ var init_sync = __esm(() => {
   init_plugin();
   init_transform();
   init_workspace_repo();
+  init_repo_skills();
   init_client_mapping();
   init_skill_name_resolver();
   init_marketplace();
@@ -31141,11 +31276,11 @@ var init_sync = __esm(() => {
 });
 
 // src/core/github-fetch.ts
-import { existsSync as existsSync15, readFileSync as readFileSync5 } from "node:fs";
-import { join as join17 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync5 } from "node:fs";
+import { join as join19 } from "node:path";
 function readFileFromClone(tempDir, filePath) {
-  const fullPath = join17(tempDir, filePath);
-  if (existsSync15(fullPath)) {
+  const fullPath = join19(tempDir, filePath);
+  if (existsSync17(fullPath)) {
     return readFileSync5(fullPath, "utf-8");
   }
   return null;
@@ -31244,15 +31379,15 @@ var init_github_fetch = __esm(() => {
 });
 
 // src/core/workspace.ts
-import { cp as cp2, mkdir as mkdir8, readFile as readFile10, writeFile as writeFile7, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
-import { existsSync as existsSync16 } from "node:fs";
-import { join as join18, resolve as resolve10, dirname as dirname11, relative as relative5, sep as sep2, isAbsolute as isAbsolute4 } from "node:path";
+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 { fileURLToPath } from "node:url";
 async function initWorkspace(targetPath = ".", options2 = {}) {
-  const absoluteTarget = resolve10(targetPath);
-  const configDir = join18(absoluteTarget, CONFIG_DIR);
-  const configPath = join18(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync16(configPath)) {
+  const absoluteTarget = resolve11(targetPath);
+  const configDir = join20(absoluteTarget, CONFIG_DIR);
+  const configPath = join20(configDir, WORKSPACE_CONFIG_FILE);
+  if (existsSync18(configPath)) {
     if (options2.force) {
       await unlink3(configPath);
     } else {
@@ -31263,7 +31398,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
   const currentFilePath = fileURLToPath(import.meta.url);
   const currentFileDir = dirname11(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
-  const defaultTemplatePath = isProduction ? join18(currentFileDir, "templates", "default") : join18(currentFileDir, "..", "templates", "default");
+  const defaultTemplatePath = isProduction ? join20(currentFileDir, "templates", "default") : join20(currentFileDir, "..", "templates", "default");
   let githubTempDir;
   let parsedFromUrl;
   let githubBasePath = "";
@@ -31271,6 +31406,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
   try {
     await mkdir8(absoluteTarget, { recursive: true });
     await mkdir8(configDir, { recursive: true });
+    await ensureConfigGitignore(absoluteTarget);
     let workspaceYamlContent;
     let sourceDir;
     if (options2.from) {
@@ -31301,20 +31437,20 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
-        const fromPath = resolve10(options2.from);
-        if (!existsSync16(fromPath)) {
+        const fromPath = resolve11(options2.from);
+        if (!existsSync18(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 = join18(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-          const rootPath = join18(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync16(nestedPath)) {
+          const nestedPath = join20(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+          const rootPath = join20(fromPath, WORKSPACE_CONFIG_FILE);
+          if (existsSync18(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync16(rootPath)) {
+          } else if (existsSync18(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -31330,14 +31466,14 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
             sourceDir = parentDir;
           }
         }
-        workspaceYamlContent = await readFile10(sourceYamlPath, "utf-8");
+        workspaceYamlContent = await readFile12(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 = resolve10(sourceDir, source);
+              workspace.source = resolve11(sourceDir, source);
               workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
             }
           }
@@ -31345,36 +31481,36 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         console.log(`✓ Using workspace.yaml from: ${sourceYamlPath}`);
       }
     } else {
-      const defaultYamlPath = join18(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync16(defaultYamlPath)) {
+      const defaultYamlPath = join20(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      if (!existsSync18(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
-      workspaceYamlContent = await readFile10(defaultYamlPath, "utf-8");
+      workspaceYamlContent = await readFile12(defaultYamlPath, "utf-8");
     }
     if (options2.clients && options2.clients.length > 0) {
       const configParsed = load(workspaceYamlContent);
       configParsed.clients = options2.clients;
       workspaceYamlContent = dump(configParsed, { lineWidth: -1 });
     }
-    await writeFile7(configPath, workspaceYamlContent, "utf-8");
+    await writeFile8(configPath, workspaceYamlContent, "utf-8");
     const parsed = load(workspaceYamlContent);
     const clients = parsed?.clients ?? [];
     const clientNames = getClientTypes(clients);
     const VSCODE_TEMPLATE_FILE2 = "template.code-workspace";
     if (clientNames.includes("vscode") && options2.from) {
-      const targetTemplatePath = join18(configDir, VSCODE_TEMPLATE_FILE2);
-      if (!existsSync16(targetTemplatePath)) {
+      const targetTemplatePath = join20(configDir, VSCODE_TEMPLATE_FILE2);
+      if (!existsSync18(targetTemplatePath)) {
         if (isGitHubUrl(options2.from) && githubTempDir) {
           if (parsedFromUrl) {
             const templatePath = githubBasePath ? `${githubBasePath}/${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}` : `${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}`;
             const templateContent = readFileFromClone(githubTempDir, templatePath);
             if (templateContent) {
-              await writeFile7(targetTemplatePath, templateContent, "utf-8");
+              await writeFile8(targetTemplatePath, templateContent, "utf-8");
             }
           }
         } else if (sourceDir) {
-          const sourceTemplatePath = join18(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
-          if (existsSync16(sourceTemplatePath)) {
+          const sourceTemplatePath = join20(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
+          if (existsSync18(sourceTemplatePath)) {
             await copyFile2(sourceTemplatePath, targetTemplatePath);
           }
         }
@@ -31387,15 +31523,15 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       if (options2.from && isGitHubUrl(options2.from) && githubTempDir) {
         if (parsedFromUrl) {
           for (const agentFile of AGENT_FILES) {
-            const targetFilePath = join18(absoluteTarget, agentFile);
-            if (existsSync16(targetFilePath)) {
+            const targetFilePath = join20(absoluteTarget, agentFile);
+            if (existsSync18(targetFilePath)) {
               copiedAgentFiles.push(agentFile);
               continue;
             }
             const filePath = githubBasePath ? `${githubBasePath}/${agentFile}` : agentFile;
             const content = readFileFromClone(githubTempDir, filePath);
             if (content) {
-              await writeFile7(targetFilePath, content, "utf-8");
+              await writeFile8(targetFilePath, content, "utf-8");
               copiedAgentFiles.push(agentFile);
             }
           }
@@ -31403,30 +31539,30 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       } else {
         const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
         for (const agentFile of AGENT_FILES) {
-          const targetFilePath = join18(absoluteTarget, agentFile);
-          if (existsSync16(targetFilePath)) {
+          const targetFilePath = join20(absoluteTarget, agentFile);
+          if (existsSync18(targetFilePath)) {
             copiedAgentFiles.push(agentFile);
             continue;
           }
-          const sourcePath = join18(effectiveSourceDir, agentFile);
-          if (existsSync16(sourcePath)) {
-            const content = await readFile10(sourcePath, "utf-8");
-            await writeFile7(targetFilePath, content, "utf-8");
+          const sourcePath = join20(effectiveSourceDir, agentFile);
+          if (existsSync18(sourcePath)) {
+            const content = await readFile12(sourcePath, "utf-8");
+            await writeFile8(targetFilePath, content, "utf-8");
             copiedAgentFiles.push(agentFile);
           }
         }
       }
       if (copiedAgentFiles.length === 0) {
-        await ensureWorkspaceRules(join18(absoluteTarget, "AGENTS.md"), repositories);
+        await ensureWorkspaceRules(join20(absoluteTarget, "AGENTS.md"), repositories);
         copiedAgentFiles.push("AGENTS.md");
       } else {
         for (const agentFile of copiedAgentFiles) {
-          await ensureWorkspaceRules(join18(absoluteTarget, agentFile), repositories);
+          await ensureWorkspaceRules(join20(absoluteTarget, agentFile), repositories);
         }
       }
       if (clientNames.includes("claude") && !copiedAgentFiles.includes("CLAUDE.md") && copiedAgentFiles.includes("AGENTS.md")) {
-        const agentsPath = join18(absoluteTarget, "AGENTS.md");
-        const claudePath = join18(absoluteTarget, "CLAUDE.md");
+        const agentsPath = join20(absoluteTarget, "AGENTS.md");
+        const claudePath = join20(absoluteTarget, "CLAUDE.md");
         await copyFile2(agentsPath, claudePath);
       }
     }
@@ -31452,7 +31588,7 @@ Syncing plugins...`);
     if (targetPath !== ".") {
       console.log(`
 Next steps:`);
-      console.log(`  cd ${relative5(process.cwd(), absoluteTarget)}`);
+      console.log(`  cd ${relative6(process.cwd(), absoluteTarget)}`);
     }
     return {
       path: absoluteTarget,
@@ -31471,14 +31607,14 @@ Next steps:`);
 async function seedCacheFromClone(tempDir, owner, repo, branch) {
   const cachePaths = [
     getPluginCachePath(owner, repo, branch),
-    join18(getMarketplacesDir(), repo)
+    join20(getMarketplacesDir(), repo)
   ];
   for (const cachePath of cachePaths) {
-    if (existsSync16(cachePath))
+    if (existsSync18(cachePath))
       continue;
     try {
       const parentDir = dirname11(cachePath);
-      if (!existsSync16(parentDir)) {
+      if (!existsSync18(parentDir)) {
         await mkdir8(parentDir, { recursive: true });
       }
       await cp2(tempDir, cachePath, { recursive: true });
@@ -31495,14 +31631,15 @@ var init_workspace = __esm(() => {
   init_github_fetch();
   init_git();
   init_marketplace();
+  init_config_gitignore();
 });
 
 // src/core/status.ts
-import { existsSync as existsSync17 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync19 } from "node:fs";
+import { join as join21 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
-  const configPath = join19(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync17(configPath) || isUserConfigPath(workspacePath)) {
+  const configPath = join21(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync19(configPath) || isUserConfigPath(workspacePath)) {
     const userPlugins = await getUserPluginStatuses();
     return {
       success: true,
@@ -31544,7 +31681,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 ? existsSync17(cachePath) : false;
+    const available2 = cachePath ? existsSync19(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -31554,7 +31691,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync17(parsed.normalized);
+  const available = existsSync19(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -33691,9 +33828,9 @@ var init_prompt_clients = __esm(() => {
 });
 
 // src/core/skills.ts
-import { existsSync as existsSync20 } from "node:fs";
-import { readFile as readFile12, readdir as readdir4 } from "node:fs/promises";
-import { join as join22, basename as basename6, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync22 } 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";
 async function resolvePluginPath(pluginSource, workspacePath) {
   if (isPluginSpec(pluginSource)) {
     const resolved2 = await resolvePluginSpecWithAutoRegister(pluginSource, {
@@ -33714,18 +33851,18 @@ async function resolvePluginPath(pluginSource, workspacePath) {
     });
     if (!result.success)
       return null;
-    const path = parsed?.subpath ? join22(result.cachePath, parsed.subpath) : result.cachePath;
+    const path = parsed?.subpath ? join24(result.cachePath, parsed.subpath) : result.cachePath;
     return { path };
   }
-  const resolved = resolve12(workspacePath, pluginSource);
-  return existsSync20(resolved) ? { path: resolved } : null;
+  const resolved = resolve13(workspacePath, pluginSource);
+  return existsSync22(resolved) ? { path: resolved } : null;
 }
 async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
-  const configPath = join22(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync20(configPath)) {
+  const configPath = join24(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (!existsSync22(configPath)) {
     return [];
   }
-  const content = await readFile12(configPath, "utf-8");
+  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;
@@ -33738,30 +33875,30 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
       continue;
     const pluginPath = resolved.path;
     const pluginName = resolved.pluginName ?? getPluginName(pluginPath);
-    const skillsDir = join22(pluginPath, "skills");
+    const skillsDir = join24(pluginPath, "skills");
     const pluginSkillsConfig = typeof pluginEntry === "string" ? undefined : pluginEntry.skills;
     const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && [...enabledSkills].some((s) => s.startsWith(`${pluginName}`));
     let skillEntries;
-    if (existsSync20(skillsDir)) {
-      const entries = await readdir4(skillsDir, { withFileTypes: true });
-      skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join22(skillsDir, e.name) }));
+    if (existsSync22(skillsDir)) {
+      const entries = await readdir5(skillsDir, { withFileTypes: true });
+      skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join24(skillsDir, e.name) }));
     } else {
-      const entries = await readdir4(pluginPath, { withFileTypes: true });
+      const entries = await readdir5(pluginPath, { withFileTypes: true });
       const flatSkills = [];
       for (const entry of entries) {
         if (!entry.isDirectory())
           continue;
-        const skillMdPath = join22(pluginPath, entry.name, "SKILL.md");
-        if (existsSync20(skillMdPath)) {
-          flatSkills.push({ name: entry.name, skillPath: join22(pluginPath, entry.name) });
+        const skillMdPath = join24(pluginPath, entry.name, "SKILL.md");
+        if (existsSync22(skillMdPath)) {
+          flatSkills.push({ name: entry.name, skillPath: join24(pluginPath, entry.name) });
         }
       }
       if (flatSkills.length > 0) {
         skillEntries = flatSkills;
       } else {
-        const rootSkillMd = join22(pluginPath, "SKILL.md");
-        if (existsSync20(rootSkillMd)) {
-          const skillContent = await readFile12(rootSkillMd, "utf-8");
+        const rootSkillMd = join24(pluginPath, "SKILL.md");
+        if (existsSync22(rootSkillMd)) {
+          const skillContent = await readFile14(rootSkillMd, "utf-8");
           const metadata = parseSkillMetadata(skillContent);
           const skillName = metadata?.name ?? basename6(pluginPath);
           skillEntries = [{ name: skillName, skillPath: pluginPath }];
@@ -33802,28 +33939,28 @@ async function findSkillByName(skillName, workspacePath = process.cwd()) {
   return allSkills.filter((s) => s.name === skillName);
 }
 async function discoverSkillNames(pluginPath) {
-  if (!existsSync20(pluginPath))
+  if (!existsSync22(pluginPath))
     return [];
-  const skillsDir = join22(pluginPath, "skills");
-  if (existsSync20(skillsDir)) {
-    const entries2 = await readdir4(skillsDir, { withFileTypes: true });
+  const skillsDir = join24(pluginPath, "skills");
+  if (existsSync22(skillsDir)) {
+    const entries2 = await readdir5(skillsDir, { withFileTypes: true });
     return entries2.filter((e) => e.isDirectory()).map((e) => e.name);
   }
-  const entries = await readdir4(pluginPath, { withFileTypes: true });
+  const entries = await readdir5(pluginPath, { withFileTypes: true });
   const flatSkills = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    if (existsSync20(join22(pluginPath, entry.name, "SKILL.md"))) {
+    if (existsSync22(join24(pluginPath, entry.name, "SKILL.md"))) {
       flatSkills.push(entry.name);
     }
   }
   if (flatSkills.length > 0)
     return flatSkills;
-  const rootSkillMd = join22(pluginPath, "SKILL.md");
-  if (existsSync20(rootSkillMd)) {
+  const rootSkillMd = join24(pluginPath, "SKILL.md");
+  if (existsSync22(rootSkillMd)) {
     try {
-      const content = await readFile12(rootSkillMd, "utf-8");
+      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)];
@@ -33932,12 +34069,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve13, reject) {
+      return new Promise(function(resolve14, reject) {
         isexe(path, options2 || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve13(is);
+            resolve14(is);
           }
         });
       });
@@ -33999,27 +34136,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve13, reject) => {
+    const step = (i2) => new Promise((resolve14, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve13(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve14(found) : reject(getNotFoundError(cmd));
       const ppRaw = pathEnv[i2];
       const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
       const pCmd = path.join(pathPart, cmd);
       const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
-      resolve13(subStep(p, i2, 0));
+      resolve14(subStep(p, i2, 0));
     });
-    const subStep = (p, i2, ii) => new Promise((resolve13, reject) => {
+    const subStep = (p, i2, ii) => new Promise((resolve14, reject) => {
       if (ii === pathExt.length)
-        return resolve13(step(i2 + 1));
+        return resolve14(step(i2 + 1));
       const ext = pathExt[ii];
       isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
         if (!er && is) {
           if (opt.all)
             found.push(p + ext);
           else
-            return resolve13(p + ext);
+            return resolve14(p + ext);
         }
-        return resolve13(subStep(p, i2, ii + 1));
+        return resolve14(subStep(p, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -34341,7 +34478,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.4.11",
+    version: "1.6.0",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -34421,13 +34558,13 @@ var init_package = __esm(() => {
 });
 
 // src/cli/update-check.ts
-import { readFile as readFile15 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { readFile as readFile17 } from "node:fs/promises";
+import { join as join27 } from "node:path";
 import { spawn as spawn3 } from "node:child_process";
 async function getCachedUpdateInfo(path3) {
-  const filePath = path3 ?? join25(getHomeDir(), CONFIG_DIR, CACHE_FILE);
+  const filePath = path3 ?? join27(getHomeDir(), CONFIG_DIR, CACHE_FILE);
   try {
-    const raw = await readFile15(filePath, "utf-8");
+    const raw = await readFile17(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.latestVersion === "string" && typeof data.lastCheckedAt === "string") {
       return data;
@@ -34463,8 +34600,8 @@ function buildNotice(currentVersion, latestVersion) {
 Run \`allagents self update\` to upgrade.`);
 }
 function backgroundUpdateCheck() {
-  const dir = join25(getHomeDir(), CONFIG_DIR);
-  const filePath = join25(dir, CACHE_FILE);
+  const dir = join27(getHomeDir(), CONFIG_DIR);
+  const filePath = join27(dir, CACHE_FILE);
   const script = `
     const https = require('https');
     const fs = require('fs');
@@ -34551,15 +34688,15 @@ class TuiCache {
 }
 
 // src/cli/tui/context.ts
-import { existsSync as existsSync23 } from "node:fs";
-import { join as join26 } from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import { join as join28 } from "node:path";
 async function getTuiContext(cwd = process.cwd(), cache2) {
   const cachedContext = cache2?.getContext();
   if (cachedContext) {
     return cachedContext;
   }
-  const configPath = join26(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  const hasWorkspace = existsSync23(configPath) && !isUserConfigPath(cwd);
+  const configPath = join28(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  const hasWorkspace = existsSync25(configPath) && !isUserConfigPath(cwd);
   let projectPluginCount = 0;
   if (hasWorkspace) {
     try {
@@ -35810,7 +35947,7 @@ __export(exports_wizard, {
   runWizard: () => runWizard,
   buildMenuOptions: () => buildMenuOptions
 });
-import { relative as relative6 } from "node:path";
+import { relative as relative7 } from "node:path";
 function buildMenuOptions(context) {
   const options2 = [];
   if (context.needsSync) {
@@ -35839,7 +35976,7 @@ function buildCompactSummary(context) {
 function buildSummary(context) {
   const lines = [];
   if (context.hasWorkspace && context.workspacePath) {
-    const relPath = relative6(process.cwd(), context.workspacePath) || ".";
+    const relPath = relative7(process.cwd(), context.workspacePath) || ".";
     lines.push(`Workspace: ${relPath}`);
     lines.push(`Project plugins: ${context.projectPluginCount}`);
   } else {
@@ -35975,8 +36112,8 @@ init_workspace();
 init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync19 } from "node:fs";
-import { join as join21, resolve as resolve11 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join23, resolve as resolve12 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -35984,9 +36121,9 @@ init_constants();
 init_marketplace();
 init_user_workspace();
 init_workspace_config();
-import { readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
-import { existsSync as existsSync18 } from "node:fs";
-import { join as join20 } from "node:path";
+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";
 async function isOrphanedPlugin(pluginSpec) {
   if (!isPluginSpec(pluginSpec))
     return false;
@@ -36013,14 +36150,14 @@ async function prunePlugins(plugins) {
 }
 async function pruneOrphanedPlugins(workspacePath) {
   let projectResult = { removed: [], kept: [], keptEntries: [] };
-  const projectConfigPath = join20(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (existsSync18(projectConfigPath) && !isUserConfigPath(workspacePath)) {
-    const content = await readFile11(projectConfigPath, "utf-8");
+  const projectConfigPath = join22(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+  if (existsSync20(projectConfigPath) && !isUserConfigPath(workspacePath)) {
+    const content = await readFile13(projectConfigPath, "utf-8");
     const config = load(content);
     projectResult = await prunePlugins(config.plugins);
     if (projectResult.removed.length > 0) {
       config.plugins = projectResult.keptEntries;
-      await writeFile8(projectConfigPath, dump(config, { lineWidth: -1 }), "utf-8");
+      await writeFile9(projectConfigPath, dump(config, { lineWidth: -1 }), "utf-8");
     }
   }
   let userResult = { removed: [], kept: [], keptEntries: [] };
@@ -36030,7 +36167,7 @@ async function pruneOrphanedPlugins(workspacePath) {
     if (userResult.removed.length > 0) {
       userConfig.plugins = userResult.keptEntries;
       const userConfigPath = getUserWorkspaceConfigPath();
-      await writeFile8(userConfigPath, dump(userConfig, { lineWidth: -1 }), "utf-8");
+      await writeFile9(userConfigPath, dump(userConfig, { lineWidth: -1 }), "utf-8");
     }
   }
   return {
@@ -36092,14 +36229,14 @@ var initMeta = {
   }
 };
 var syncMeta = {
-  command: "workspace sync",
-  description: "Sync plugins to workspace",
+  command: "update",
+  description: "Update plugins in workspace",
   whenToUse: "After modifying workspace.yaml or pulling shared config changes",
   examples: [
-    "allagents workspace sync",
-    "allagents workspace sync --dry-run",
-    "allagents workspace sync --offline",
-    "allagents workspace sync --verbose"
+    "allagents update",
+    "allagents update --dry-run",
+    "allagents update --offline",
+    "allagents update --verbose"
   ],
   expectedOutput: "Lists synced files with status per plugin. Exit 0 on success, exit 1 if any files failed.",
   options: [
@@ -36290,8 +36427,8 @@ Plugin sync results:`);
   }
 });
 var syncCmd = import_cmd_ts2.command({
-  name: "sync",
-  aliases: ["update"],
+  name: "update",
+  aliases: ["sync"],
   description: buildDescription(syncMeta),
   args: {
     offline: import_cmd_ts2.flag({ long: "offline", description: "Use cached plugins without fetching latest from remote" }),
@@ -36306,8 +36443,8 @@ var syncCmd = import_cmd_ts2.command({
 `);
       }
       const userConfigExists = !!await getUserWorkspaceConfig();
-      const projectConfigPath = join21(process.cwd(), ".allagents", "workspace.yaml");
-      const projectConfigExists = existsSync19(projectConfigPath);
+      const projectConfigPath = join23(process.cwd(), ".allagents", "workspace.yaml");
+      const projectConfigExists = existsSync21(projectConfigPath);
       if (!userConfigExists && !projectConfigExists) {
         await ensureUserWorkspace();
         if (isJsonMode()) {
@@ -36595,7 +36732,7 @@ var repoAddCmd = import_cmd_ts2.command({
   },
   handler: async ({ path: repoPath, description }) => {
     try {
-      const resolvedPath = resolve11(process.cwd(), repoPath);
+      const resolvedPath = resolve12(process.cwd(), repoPath);
       const remote = await detectRemote(resolvedPath);
       const result = await addRepository(repoPath, {
         source: remote?.source,
@@ -36975,9 +37112,9 @@ init_workspace_modify();
 init_user_workspace();
 init_skills();
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync21 } from "node:fs";
-import { readFile as readFile13 } from "node:fs/promises";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { readFile as readFile15 } from "node:fs/promises";
+import { join as join25 } from "node:path";
 
 // src/cli/metadata/plugin-skills.ts
 var skillsListMeta = {
@@ -37068,7 +37205,7 @@ init_skill();
 init_marketplace();
 init_marketplace_manifest_parser();
 function hasProjectConfig(dir) {
-  return existsSync21(join23(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
+  return existsSync23(join25(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
 }
 function resolveScope(cwd) {
   if (isUserConfigPath(cwd))
@@ -37099,7 +37236,7 @@ async function resolveSkillNameFromRepo(url, parsed, fallbackName, fetchFn = fet
   if (!fetchResult.success)
     return fallbackName;
   try {
-    const skillMd = await readFile13(join23(fetchResult.cachePath, "SKILL.md"), "utf-8");
+    const skillMd = await readFile15(join25(fetchResult.cachePath, "SKILL.md"), "utf-8");
     const metadata = parseSkillMetadata(skillMd);
     return metadata?.name ?? fallbackName;
   } catch {
@@ -37656,9 +37793,9 @@ init_format_sync();
 init_workspace_config();
 init_constants();
 init_js_yaml();
-import { readFile as readFile14 } from "node:fs/promises";
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join24 } from "node:path";
+import { readFile as readFile16 } from "node:fs/promises";
+import { existsSync as existsSync24 } from "node:fs";
+import { join as join26 } from "node:path";
 async function runSyncAndPrint(options2) {
   if (!isJsonMode()) {
     console.log(`
@@ -37903,7 +38040,7 @@ var marketplaceAddCmd = import_cmd_ts4.command({
         process.exit(1);
       }
       if (effectiveScope === "project") {
-        if (!existsSync22(join24(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
+        if (!existsSync24(join26(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 });
@@ -38210,10 +38347,10 @@ var pluginListCmd = import_cmd_ts4.command({
       };
       const pluginClients = new Map;
       async function loadConfigClients(configPath, scope) {
-        if (!existsSync22(configPath))
+        if (!existsSync24(configPath))
           return;
         try {
-          const content = await readFile14(configPath, "utf-8");
+          const content = await readFile16(configPath, "utf-8");
           const config = load(content);
           if (!config?.plugins || !config?.clients)
             return;
@@ -38225,8 +38362,8 @@ var pluginListCmd = import_cmd_ts4.command({
           }
         } catch {}
       }
-      const userConfigPath = join24(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
-      const projectConfigPath = join24(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+      const userConfigPath = join26(getAllagentsDir(), WORKSPACE_CONFIG_FILE);
+      const projectConfigPath = join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
       const cwdIsHome = isUserConfigPath(process.cwd());
       await loadConfigClients(userConfigPath, "user");
       if (!cwdIsHome) {
@@ -38368,7 +38505,7 @@ var pluginInstallCmd = import_cmd_ts4.command({
       const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
       if (isUser) {
         const userConfigPath = getUserWorkspaceConfigPath();
-        if (!existsSync22(userConfigPath)) {
+        if (!existsSync24(userConfigPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -38380,8 +38517,8 @@ var pluginInstallCmd = import_cmd_ts4.command({
           await ensureUserWorkspace(clients);
         }
       } else {
-        const configPath = join24(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-        if (!existsSync22(configPath)) {
+        const configPath = join26(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
+        if (!existsSync24(configPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -38658,14 +38795,14 @@ var pluginUpdateCmd = import_cmd_ts4.command({
         }
       }
       if (updateProject && !isUserConfigPath(process.cwd())) {
-        const { existsSync: existsSync23 } = await import("node:fs");
-        const { readFile: readFile15 } = await import("node:fs/promises");
-        const { join: join25 } = await import("node:path");
+        const { existsSync: existsSync25 } = await import("node:fs");
+        const { readFile: readFile17 } = await import("node:fs/promises");
+        const { join: join27 } = 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 = join25(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
-        if (existsSync23(configPath)) {
-          const content = await readFile15(configPath, "utf-8");
+        const configPath = join27(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
+        if (existsSync25(configPath)) {
+          const content = await readFile17(configPath, "utf-8");
           const config = load2(content);
           for (const entry of config.plugins ?? []) {
             const p = getPluginSource(entry);
@@ -39697,7 +39834,7 @@ var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise
     return spawnedPromise;
   }
   let timeoutId;
-  const timeoutPromise = new Promise((resolve13, reject) => {
+  const timeoutPromise = new Promise((resolve14, reject) => {
     timeoutId = setTimeout(() => {
       timeoutKill(spawned, killSignal, reject);
     }, timeout);
@@ -40061,9 +40198,9 @@ var mergePromise = (spawned, promise) => {
     Reflect.defineProperty(spawned, property, { ...descriptor, value });
   }
 };
-var getSpawnedPromise = (spawned) => new Promise((resolve13, reject) => {
+var getSpawnedPromise = (spawned) => new Promise((resolve14, reject) => {
   spawned.on("exit", (exitCode, signal) => {
-    resolve13({ exitCode, signal });
+    resolve14({ exitCode, signal });
   });
   spawned.on("error", (error) => {
     reject(error);
@@ -40581,6 +40718,7 @@ var app = conciseSubcommands({
 ` + "For AI agents: use --agent-help for machine-readable help, or --json for structured output",
   version: package_default.version,
   cmds: {
+    update: syncCmd,
     workspace: workspaceCmd,
     plugin: pluginCmd,
     self: selfCmd,