allagents 1.7.0 → 1.7.2-next.1

package/dist/index.js

@@ -6,39 +6,60 @@ var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
-var __moduleCache = /* @__PURE__ */ new WeakMap;
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -11490,16 +11511,22 @@ function resolveInstallMode(pluginEntry, clientEntry) {
     return pluginMode;
   return clientEntry.install;
 }
-var RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, InstallModeSchema, ClientEntrySchema, PluginSkillsConfigSchema, PluginEntrySchema, VscodeConfigSchema, SyncModeSchema, McpProxyServerSchema, McpProxyConfigSchema, WorkspaceConfigSchema;
+var ManagedModeSchema, RepositorySchema, WorkspaceFileSchema, WorkspaceSchema, PluginSourceSchema, ClientTypeSchema, InstallModeSchema, ClientEntrySchema, PluginSkillsConfigSchema, PluginEntrySchema, VscodeConfigSchema, SyncModeSchema, McpProxyServerSchema, McpProxyConfigSchema, WorkspaceConfigSchema;
 var init_workspace_config = __esm(() => {
   init_zod();
+  ManagedModeSchema = exports_external.union([
+    exports_external.boolean(),
+    exports_external.enum(["clone", "sync"])
+  ]);
   RepositorySchema = exports_external.object({
     path: exports_external.string(),
     name: exports_external.string().optional(),
     source: exports_external.string().optional(),
     repo: exports_external.string().optional(),
     description: exports_external.string().optional(),
-    skills: exports_external.union([exports_external.boolean(), exports_external.array(exports_external.string())]).optional()
+    skills: exports_external.union([exports_external.boolean(), exports_external.array(exports_external.string())]).optional(),
+    managed: ManagedModeSchema.optional(),
+    branch: exports_external.string().optional()
   });
   WorkspaceFileSchema = exports_external.union([
     exports_external.string(),
@@ -28441,7 +28468,8 @@ async function discoverWorkspaceSkills(workspacePath, repositories, clientNames)
     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, "/");
+      const base = repo.path.replace(/[/\\]+$/, "");
+      const location = `${base}/${skill.relativePath}`.replace(/\\/g, "/");
       const candidate = {
         repoPath: repo.path,
         name: skill.name,
@@ -29955,7 +29983,7 @@ class ClaudeNativeClient {
       for (const plugin of plugins) {
         const spec = this.toPluginSpec(plugin);
         if (spec) {
-          result.pluginsInstalled.push(spec);
+          result.pluginsInstalled.push({ plugin: spec });
         } else {
           result.skipped.push(plugin);
         }
@@ -29982,7 +30010,7 @@ class ClaudeNativeClient {
       }
       const installResult = await this.installPlugin(spec, scope, options2);
       if (installResult.success) {
-        result.pluginsInstalled.push(spec);
+        result.pluginsInstalled.push({ plugin: spec });
       } else {
         result.pluginsFailed.push({
           plugin: spec,
@@ -30050,7 +30078,7 @@ class CopilotNativeClient {
       for (const plugin of plugins) {
         const spec = this.toPluginSpec(plugin);
         if (spec) {
-          result.pluginsInstalled.push(spec);
+          result.pluginsInstalled.push({ plugin: spec });
         } else {
           result.skipped.push(plugin);
         }
@@ -30077,7 +30105,7 @@ class CopilotNativeClient {
       }
       const installResult = await this.installPlugin(spec, scope, options2);
       if (installResult.success) {
-        result.pluginsInstalled.push(spec);
+        result.pluginsInstalled.push({ plugin: spec });
       } else {
         const rawError = installResult.error ?? "Unknown error";
         const error = rawError.includes("Plugin path escapes marketplace directory") ? `${rawError} (Copilot rejected a plugin path from this marketplace manifest. Use file install for copilot to avoid native install for this plugin.)` : rawError;
@@ -30192,10 +30220,145 @@ function padStart2(str3, len) {
   return str3.length >= len ? str3 : " ".repeat(len - str3.length) + str3;
 }
 
+// src/core/managed-repos.ts
+import { existsSync as existsSync17 } from "node:fs";
+import { mkdir as mkdir8 } from "node:fs/promises";
+import { dirname as dirname11, resolve as resolve10 } from "node:path";
+function expandHome(p) {
+  if (p.startsWith("~/") || p === "~") {
+    return p.replace("~", getHomeDir());
+  }
+  return p;
+}
+function shouldClone(managed) {
+  if (managed === undefined || managed === false)
+    return false;
+  return true;
+}
+function shouldPull(managed) {
+  if (managed === true || managed === "sync")
+    return true;
+  return false;
+}
+function isValidRepo(repo) {
+  return /^[\w.\-/]+$/.test(repo);
+}
+function buildCloneUrl(source, repo) {
+  if (!isValidRepo(repo)) {
+    throw new Error(`Invalid repo identifier: ${repo}`);
+  }
+  switch (source) {
+    case "github":
+      return `https://github.com/${repo}.git`;
+    case "gitlab":
+      return `https://gitlab.com/${repo}.git`;
+    case "bitbucket":
+      return `https://bitbucket.org/${repo}.git`;
+    case "azure-devops": {
+      const parts = repo.split("/");
+      if (parts.length === 3) {
+        return `https://dev.azure.com/${parts[0]}/${parts[1]}/_git/${parts[2]}`;
+      }
+      return `https://dev.azure.com/${repo}`;
+    }
+    default:
+      return `https://${source}/${repo}.git`;
+  }
+}
+async function cloneRepo(url, dest, branch) {
+  await mkdir8(dirname11(dest), { recursive: true });
+  const git = esm_default({ timeout: { block: CLONE_TIMEOUT_MS2 } });
+  const cloneOptions = branch ? ["--branch", branch] : [];
+  await git.clone(url, dest, cloneOptions);
+}
+async function pullRepo(repoPath, branch) {
+  const git = esm_default(repoPath, { timeout: { block: CLONE_TIMEOUT_MS2 } });
+  const status = await git.status();
+  if (!status.isClean()) {
+    return "uncommitted changes";
+  }
+  if (branch) {
+    const currentBranch = status.current;
+    if (currentBranch !== branch) {
+      return `on branch '${currentBranch}', expected '${branch}'`;
+    }
+  }
+  await git.pull();
+  return;
+}
+async function processManagedRepos(repositories, workspacePath, options2 = {}) {
+  if (options2.skipManaged || options2.offline || options2.dryRun)
+    return [];
+  const managed = repositories.filter((r) => r.managed);
+  if (managed.length === 0)
+    return [];
+  const results = [];
+  for (const repo of managed) {
+    if (!repo.source || !repo.repo) {
+      results.push({
+        path: repo.path,
+        repo: repo.repo ?? repo.path,
+        action: "skipped",
+        error: "managed requires both source and repo fields"
+      });
+      continue;
+    }
+    const expandedPath = expandHome(repo.path);
+    const absolutePath = resolve10(workspacePath, expandedPath);
+    if (!existsSync17(absolutePath)) {
+      if (!shouldClone(repo.managed)) {
+        results.push({ path: repo.path, repo: repo.repo, action: "skipped" });
+        continue;
+      }
+      try {
+        const url = buildCloneUrl(repo.source, repo.repo);
+        await cloneRepo(url, absolutePath, repo.branch);
+        results.push({ path: repo.path, repo: repo.repo, action: "cloned" });
+      } catch (error) {
+        results.push({
+          path: repo.path,
+          repo: repo.repo,
+          action: "skipped",
+          error: `clone failed: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    } else if (shouldPull(repo.managed)) {
+      try {
+        const skipReason = await pullRepo(absolutePath, repo.branch);
+        if (skipReason) {
+          results.push({
+            path: repo.path,
+            repo: repo.repo,
+            action: "skipped",
+            error: `pull skipped: ${skipReason}`
+          });
+        } else {
+          results.push({ path: repo.path, repo: repo.repo, action: "pulled" });
+        }
+      } catch (error) {
+        results.push({
+          path: repo.path,
+          repo: repo.repo,
+          action: "skipped",
+          error: `pull failed: ${error instanceof Error ? error.message : String(error)}`
+        });
+      }
+    } else {
+      results.push({ path: repo.path, repo: repo.repo, action: "skipped" });
+    }
+  }
+  return results;
+}
+var CLONE_TIMEOUT_MS2 = 120000;
+var init_managed_repos = __esm(() => {
+  init_esm();
+  init_constants();
+});
+
 // src/core/sync.ts
-import { existsSync as existsSync17, readFileSync as readFileSync4, writeFileSync as writeFileSync6, lstatSync as lstatSync2 } from "node:fs";
+import { existsSync as existsSync18, 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 join19, resolve as resolve10, dirname as dirname11, relative as relative5 } from "node:path";
+import { join as join19, resolve as resolve11, dirname as dirname12, relative as relative5 } from "node:path";
 function deduplicateClientsByPath(clients, clientMappings = CLIENT_MAPPINGS) {
   const pathToClients = new Map;
   for (const client of clients) {
@@ -30241,6 +30404,10 @@ function mergeSyncResults(a, b) {
     ...deletedArtifacts.length > 0 && { deletedArtifacts },
     ...mcpResults && { mcpResults },
     ...nativeResult && { nativeResult },
+    ...(() => {
+      const managedRepoResults = [...a.managedRepoResults || [], ...b.managedRepoResults || []];
+      return managedRepoResults.length > 0 ? { managedRepoResults } : {};
+    })(),
     ...mergeTiming(a.timing, b.timing)
   };
 }
@@ -30291,6 +30458,7 @@ function collectNativePluginSources(validPlugins) {
 function attachNativeClientContext(result, clientType) {
   return {
     ...result,
+    pluginsInstalled: result.pluginsInstalled.map((installed) => ({ ...installed, client: clientType })),
     pluginsFailed: result.pluginsFailed.map((failure) => ({ ...failure, client: clientType }))
   };
 }
@@ -30336,16 +30504,16 @@ async function selectivePurgeWorkspace(workspacePath, state, clients) {
   return result;
 }
 async function cleanupEmptyParents(workspacePath, filePath) {
-  let parentPath = dirname11(filePath);
+  let parentPath = dirname12(filePath);
   while (parentPath && parentPath !== "." && parentPath !== "/") {
     const fullParentPath = join19(workspacePath, parentPath);
-    if (!existsSync17(fullParentPath)) {
-      parentPath = dirname11(parentPath);
+    if (!existsSync18(fullParentPath)) {
+      parentPath = dirname12(parentPath);
       continue;
     }
     try {
       await rmdir(fullParentPath);
-      parentPath = dirname11(parentPath);
+      parentPath = dirname12(parentPath);
     } catch {
       break;
     }
@@ -30425,7 +30593,7 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         continue;
       }
       const fullPath = join19(defaultSourcePath, file);
-      if (!existsSync17(fullPath)) {
+      if (!existsSync18(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
       continue;
@@ -30444,7 +30612,7 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
           continue;
         }
         const fullPath = join19(cachePath, parsed.filePath);
-        if (!existsSync17(fullPath)) {
+        if (!existsSync18(fullPath)) {
           errors2.push(`Path not found in repository: ${cacheKey}/${parsed.filePath}`);
         }
       } else {
@@ -30452,13 +30620,13 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         if (file.source.startsWith("/")) {
           fullPath = file.source;
         } else if (file.source.startsWith("../")) {
-          fullPath = resolve10(file.source);
+          fullPath = resolve11(file.source);
         } else if (defaultSourcePath) {
           fullPath = join19(defaultSourcePath, file.source);
         } else {
-          fullPath = resolve10(file.source);
+          fullPath = resolve11(file.source);
         }
-        if (!existsSync17(fullPath)) {
+        if (!existsSync18(fullPath)) {
           errors2.push(`File source not found: ${fullPath}`);
         }
       }
@@ -30468,7 +30636,7 @@ function validateFileSources(files, defaultSourcePath, githubCache) {
         continue;
       }
       const fullPath = join19(defaultSourcePath, file.dest ?? "");
-      if (!existsSync17(fullPath)) {
+      if (!existsSync18(fullPath)) {
         errors2.push(`File source not found: ${fullPath}`);
       }
     }
@@ -30623,8 +30791,8 @@ async function validatePlugin(pluginSource, workspacePath, offline) {
       nativeClients: []
     };
   }
-  const resolvedPath = resolve10(workspacePath, pluginSource);
-  if (!existsSync17(resolvedPath)) {
+  const resolvedPath = resolve11(workspacePath, pluginSource);
+  if (!existsSync18(resolvedPath)) {
     return {
       plugin: pluginSource,
       resolved: resolvedPath,
@@ -30788,7 +30956,7 @@ function generateVscodeWorkspaceFile(workspacePath, config) {
   const configDir = join19(workspacePath, CONFIG_DIR);
   const templatePath = join19(configDir, VSCODE_TEMPLATE_FILE);
   let template;
-  if (existsSync17(templatePath)) {
+  if (existsSync18(templatePath)) {
     try {
       template = import_json53.default.parse(readFileSync4(templatePath, "utf-8"));
     } catch (error) {
@@ -30935,7 +31103,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   let updatedConfig = config;
   if (previousState?.vscodeWorkspaceHash && previousState?.vscodeWorkspaceRepos) {
     const outputPath = getWorkspaceOutputPath(workspacePath, config.vscode);
-    if (existsSync17(outputPath)) {
+    if (existsSync18(outputPath)) {
       const existingContent = readFileSync4(outputPath, "utf-8");
       const currentHash = computeWorkspaceHash(existingContent);
       if (currentHash !== previousState.vscodeWorkspaceHash) {
@@ -30965,7 +31133,7 @@ async function syncVscodeWorkspaceFile(workspacePath, config, configPath, previo
   }
   const writtenContent = generateVscodeWorkspaceFile(workspacePath, updatedConfig);
   const hash = computeWorkspaceHash(writtenContent);
-  const repos = updatedConfig.repositories.map((r) => resolve10(workspacePath, r.path).replace(/\\/g, "/"));
+  const repos = updatedConfig.repositories.map((r) => resolve11(workspacePath, r.path).replace(/\\/g, "/"));
   return { config: updatedConfig, hash, repos };
 }
 async function persistSyncState(workspacePath, pluginResults, workspaceFileResults, syncClients, nativePluginsByClient, nativeResult, extra) {
@@ -30977,7 +31145,7 @@ async function persistSyncState(workspacePath, pluginResults, workspaceFileResul
   const resolvedMappings = resolveClientMappings(syncClients, mappings);
   const syncedFiles = collectSyncedPaths(allCopyResults, workspacePath, syncClients, resolvedMappings);
   const nativePluginsState = {};
-  const installedSet = new Set(nativeResult?.pluginsInstalled ?? []);
+  const installedSet = new Set((nativeResult?.pluginsInstalled ?? []).map((p) => p.plugin));
   for (const [client, sources] of nativePluginsByClient) {
     const nativeClient = getNativeClient(client);
     if (!nativeClient)
@@ -30998,11 +31166,11 @@ async function persistSyncState(workspacePath, pluginResults, workspaceFileResul
 }
 async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   await migrateWorkspaceSkillsV1toV2(workspacePath);
-  const { offline = false, dryRun = false, workspaceSourceBase, skipAgentFiles = false } = options2;
+  const { offline = false, dryRun = false, workspaceSourceBase, skipAgentFiles = false, skipManaged = false } = options2;
   const sw = new Stopwatch;
   const configDir = join19(workspacePath, CONFIG_DIR);
   const configPath = join19(configDir, WORKSPACE_CONFIG_FILE);
-  if (!existsSync17(configPath)) {
+  if (!existsSync18(configPath)) {
     return failedSyncResult(`${CONFIG_DIR}/${WORKSPACE_CONFIG_FILE} not found in ${workspacePath}
   Run 'allagents workspace init <path>' to create a new workspace`);
   }
@@ -31016,6 +31184,8 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   for (const name of overrides) {
     console.warn(`Warning: Workspace marketplace '${name}' overrides user marketplace of the same name.`);
   }
+  const managedRepoResults = await sw.measure("managed-repos", () => processManagedRepos(config.repositories ?? [], workspacePath, { offline, skipManaged, dryRun }));
+  const managedWarnings = managedRepoResults.filter((r) => r.error).map((r) => `${r.repo}: ${r.error}`);
   const hasRepositories = (config.repositories?.length ?? 0) > 0;
   const { plans: pluginPlans, warnings: planWarnings } = buildPluginSyncPlans(config.plugins, config.clients, "project");
   const workspaceClients = config.clients;
@@ -31053,6 +31223,7 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
   const failedValidations = validatedPlugins.filter((v) => !v.success);
   const validPlugins = validatedPlugins.filter((v) => v.success);
   const warnings = [
+    ...managedWarnings,
     ...planWarnings,
     ...workspaceSourceWarnings,
     ...failedValidations.map((v) => `${v.plugin}: ${v.error} (skipped)`)
@@ -31093,7 +31264,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     if (hasRepositories && sourcePath) {
       for (const agentFile of AGENT_FILES) {
         const agentPath = join19(sourcePath, agentFile);
-        if (existsSync17(agentPath) && !filesToCopy.includes(agentFile)) {
+        if (existsSync18(agentPath) && !filesToCopy.includes(agentFile)) {
           filesToCopy.push(agentFile);
         }
       }
@@ -31130,8 +31301,8 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     if (hasRepositories && !dryRun && syncClients.includes("claude") && sourcePath) {
       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)) {
+      const claudeExistsInSource = existsSync18(join19(sourcePath, "CLAUDE.md"));
+      if (!claudeExistsInSource && existsSync18(agentsPath) && !existsSync18(claudePath)) {
         await copyFile(agentsPath, claudePath);
       }
     }
@@ -31275,6 +31446,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     ...messages.length > 0 && { messages },
     ...Object.keys(mcpResults).length > 0 && { mcpResults },
     ...nativeResult && { nativeResult },
+    ...managedRepoResults.length > 0 && { managedRepoResults },
     timing: sw.toJSON()
   };
 }
@@ -31304,7 +31476,7 @@ function readGitBranch(repoPath) {
 async function syncUserWorkspace(options2 = {}) {
   await migrateUserWorkspaceSkillsV1toV2();
   const sw = new Stopwatch;
-  const homeDir = resolve10(getHomeDir());
+  const homeDir = resolve11(getHomeDir());
   const config = await getUserWorkspaceConfig();
   if (!config) {
     return {
@@ -31495,15 +31667,16 @@ var init_sync = __esm(() => {
   init_claude_mcp();
   init_copilot_mcp();
   init_native();
+  init_managed_repos();
   import_json53 = __toESM(require_lib(), 1);
 });
 
 // src/core/github-fetch.ts
-import { existsSync as existsSync18, readFileSync as readFileSync5 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync5 } from "node:fs";
 import { join as join20 } from "node:path";
 function readFileFromClone(tempDir, filePath) {
   const fullPath = join20(tempDir, filePath);
-  if (existsSync18(fullPath)) {
+  if (existsSync19(fullPath)) {
     return readFileSync5(fullPath, "utf-8");
   }
   return null;
@@ -31602,15 +31775,15 @@ 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 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 { cp as cp2, mkdir as mkdir9, readFile as readFile12, writeFile as writeFile8, copyFile as copyFile2, unlink as unlink3 } from "node:fs/promises";
+import { existsSync as existsSync20 } from "node:fs";
+import { join as join21, resolve as resolve12, dirname as dirname13, 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 absoluteTarget = resolve12(targetPath);
   const configDir = join21(absoluteTarget, CONFIG_DIR);
   const configPath = join21(configDir, WORKSPACE_CONFIG_FILE);
-  if (existsSync19(configPath)) {
+  if (existsSync20(configPath)) {
     if (options2.force) {
       await unlink3(configPath);
     } else {
@@ -31619,7 +31792,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     }
   }
   const currentFilePath = fileURLToPath(import.meta.url);
-  const currentFileDir = dirname12(currentFilePath);
+  const currentFileDir = dirname13(currentFilePath);
   const isProduction = currentFilePath.includes(`${sep2}dist${sep2}`);
   const defaultTemplatePath = isProduction ? join21(currentFileDir, "templates", "default") : join21(currentFileDir, "..", "templates", "default");
   let githubTempDir;
@@ -31627,8 +31800,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
   let githubBasePath = "";
   let githubBranch = "main";
   try {
-    await mkdir8(absoluteTarget, { recursive: true });
-    await mkdir8(configDir, { recursive: true });
+    await mkdir9(absoluteTarget, { recursive: true });
+    await mkdir9(configDir, { recursive: true });
     await ensureConfigGitignore(absoluteTarget);
     let workspaceYamlContent;
     let sourceDir;
@@ -31660,8 +31833,8 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         }
         console.log(`✓ Using workspace.yaml from: ${options2.from}`);
       } else {
-        const fromPath = resolve11(options2.from);
-        if (!existsSync19(fromPath)) {
+        const fromPath = resolve12(options2.from);
+        if (!existsSync20(fromPath)) {
           throw new Error(`Template not found: ${fromPath}`);
         }
         const { stat: stat2 } = await import("node:fs/promises");
@@ -31670,10 +31843,10 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         if (fromStat.isDirectory()) {
           const nestedPath = join21(fromPath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
           const rootPath = join21(fromPath, WORKSPACE_CONFIG_FILE);
-          if (existsSync19(nestedPath)) {
+          if (existsSync20(nestedPath)) {
             sourceYamlPath = nestedPath;
             sourceDir = fromPath;
-          } else if (existsSync19(rootPath)) {
+          } else if (existsSync20(rootPath)) {
             sourceYamlPath = rootPath;
             sourceDir = fromPath;
           } else {
@@ -31682,9 +31855,9 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else {
           sourceYamlPath = fromPath;
-          const parentDir = dirname12(fromPath);
+          const parentDir = dirname13(fromPath);
           if (parentDir.endsWith(CONFIG_DIR)) {
-            sourceDir = dirname12(parentDir);
+            sourceDir = dirname13(parentDir);
           } else {
             sourceDir = parentDir;
           }
@@ -31696,7 +31869,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           if (workspace?.source) {
             const source = workspace.source;
             if (!isGitHubUrl(source) && !isAbsolute4(source)) {
-              workspace.source = resolve11(sourceDir, source);
+              workspace.source = resolve12(sourceDir, source);
               workspaceYamlContent = dump(parsed2, { lineWidth: -1 });
             }
           }
@@ -31705,7 +31878,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
       }
     } else {
       const defaultYamlPath = join21(defaultTemplatePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-      if (!existsSync19(defaultYamlPath)) {
+      if (!existsSync20(defaultYamlPath)) {
         throw new Error(`Default template not found at: ${defaultTemplatePath}`);
       }
       workspaceYamlContent = await readFile12(defaultYamlPath, "utf-8");
@@ -31722,7 +31895,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
     const VSCODE_TEMPLATE_FILE2 = "template.code-workspace";
     if (clientNames.includes("vscode") && options2.from) {
       const targetTemplatePath = join21(configDir, VSCODE_TEMPLATE_FILE2);
-      if (!existsSync19(targetTemplatePath)) {
+      if (!existsSync20(targetTemplatePath)) {
         if (isGitHubUrl(options2.from) && githubTempDir) {
           if (parsedFromUrl) {
             const templatePath = githubBasePath ? `${githubBasePath}/${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}` : `${CONFIG_DIR}/${VSCODE_TEMPLATE_FILE2}`;
@@ -31733,7 +31906,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
           }
         } else if (sourceDir) {
           const sourceTemplatePath = join21(sourceDir, CONFIG_DIR, VSCODE_TEMPLATE_FILE2);
-          if (existsSync19(sourceTemplatePath)) {
+          if (existsSync20(sourceTemplatePath)) {
             await copyFile2(sourceTemplatePath, targetTemplatePath);
           }
         }
@@ -31747,7 +31920,7 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         if (parsedFromUrl) {
           for (const agentFile of AGENT_FILES) {
             const targetFilePath = join21(absoluteTarget, agentFile);
-            if (existsSync19(targetFilePath)) {
+            if (existsSync20(targetFilePath)) {
               copiedAgentFiles.push(agentFile);
               continue;
             }
@@ -31763,12 +31936,12 @@ async function initWorkspace(targetPath = ".", options2 = {}) {
         const effectiveSourceDir = sourceDir ?? defaultTemplatePath;
         for (const agentFile of AGENT_FILES) {
           const targetFilePath = join21(absoluteTarget, agentFile);
-          if (existsSync19(targetFilePath)) {
+          if (existsSync20(targetFilePath)) {
             copiedAgentFiles.push(agentFile);
             continue;
           }
           const sourcePath = join21(effectiveSourceDir, agentFile);
-          if (existsSync19(sourcePath)) {
+          if (existsSync20(sourcePath)) {
             const content = await readFile12(sourcePath, "utf-8");
             await writeFile8(targetFilePath, content, "utf-8");
             copiedAgentFiles.push(agentFile);
@@ -31833,12 +32006,12 @@ async function seedCacheFromClone(tempDir, owner, repo, branch) {
     join21(getMarketplacesDir(), repo)
   ];
   for (const cachePath of cachePaths) {
-    if (existsSync19(cachePath))
+    if (existsSync20(cachePath))
       continue;
     try {
-      const parentDir = dirname12(cachePath);
-      if (!existsSync19(parentDir)) {
-        await mkdir8(parentDir, { recursive: true });
+      const parentDir = dirname13(cachePath);
+      if (!existsSync20(parentDir)) {
+        await mkdir9(parentDir, { recursive: true });
       }
       await cp2(tempDir, cachePath, { recursive: true });
     } catch {}
@@ -31858,11 +32031,11 @@ var init_workspace = __esm(() => {
 });
 
 // src/core/status.ts
-import { existsSync as existsSync20 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { join as join22 } from "node:path";
 async function getWorkspaceStatus(workspacePath = process.cwd()) {
   const configPath = join22(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync20(configPath) || isUserConfigPath(workspacePath)) {
+  if (!existsSync21(configPath) || isUserConfigPath(workspacePath)) {
     const userPlugins = await getUserPluginStatuses();
     return {
       success: true,
@@ -31904,7 +32077,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 ? existsSync20(cachePath) : false;
+    const available2 = cachePath ? existsSync21(cachePath) : false;
     return {
       source: parsed.original,
       type: "github",
@@ -31914,7 +32087,7 @@ function getPluginStatus(parsed) {
       ...parsed.repo && { repo: parsed.repo }
     };
   }
-  const available = existsSync20(parsed.normalized);
+  const available = existsSync21(parsed.normalized);
   return {
     source: parsed.original,
     type: "local",
@@ -32143,8 +32316,9 @@ function formatNativeResult(nativeResult) {
   if (nativeResult.marketplacesAdded.length > 0) {
     lines.push(`Marketplaces registered: ${nativeResult.marketplacesAdded.join(", ")}`);
   }
-  for (const plugin of nativeResult.pluginsInstalled) {
-    lines.push(`  + ${plugin} (installed via native CLI)`);
+  for (const { plugin, client } of nativeResult.pluginsInstalled) {
+    const cliName = client ? `${client} CLI` : "native CLI";
+    lines.push(`  + ${plugin} (installed via ${cliName})`);
   }
   for (const { client, plugin, error } of nativeResult.pluginsFailed) {
     const provider = client ? `[${client}] ` : "";
@@ -32241,14 +32415,38 @@ function buildSyncData(result) {
     },
     ...result.nativeResult && {
       nativePlugins: {
-        installed: result.nativeResult.pluginsInstalled,
+        installed: result.nativeResult.pluginsInstalled.map((p) => p.plugin),
         failed: result.nativeResult.pluginsFailed,
         skipped: result.nativeResult.skipped,
         marketplacesAdded: result.nativeResult.marketplacesAdded
       }
+    },
+    ...result.managedRepoResults && result.managedRepoResults.length > 0 && {
+      managedRepos: result.managedRepoResults.map((r) => ({
+        repo: r.repo,
+        path: r.path,
+        action: r.action,
+        ...r.error && { error: r.error }
+      }))
     }
   };
 }
+function formatManagedRepoResults(results) {
+  const actionResults = results.filter((r) => r.action !== "skipped" || r.error);
+  if (actionResults.length === 0)
+    return [];
+  const lines = ["Repositories:"];
+  for (const r of actionResults) {
+    if (r.action === "cloned") {
+      lines.push(`  ✓ Cloned ${r.repo} → ${r.path}`);
+    } else if (r.action === "pulled") {
+      lines.push(`  ✓ Pulled ${r.repo}`);
+    } else if (r.error) {
+      lines.push(`  ✗ ${r.repo}: ${r.error}`);
+    }
+  }
+  return lines;
+}
 var cachedLookup = null;
 var init_format_sync = __esm(() => {
   init_client_mapping();
@@ -34051,9 +34249,9 @@ var init_prompt_clients = __esm(() => {
 });
 
 // src/core/skills.ts
-import { existsSync as existsSync23 } from "node:fs";
+import { existsSync as existsSync24 } from "node:fs";
 import { readFile as readFile14, readdir as readdir5 } from "node:fs/promises";
-import { join as join25, basename as basename7, resolve as resolve13 } from "node:path";
+import { join as join25, basename as basename7, resolve as resolve14 } from "node:path";
 async function resolvePluginPath(pluginSource, workspacePath) {
   if (isPluginSpec(pluginSource)) {
     const resolved2 = await resolvePluginSpecWithAutoRegister(pluginSource, {
@@ -34077,12 +34275,12 @@ async function resolvePluginPath(pluginSource, workspacePath) {
     const path = parsed?.subpath ? join25(result.cachePath, parsed.subpath) : result.cachePath;
     return { path };
   }
-  const resolved = resolve13(workspacePath, pluginSource);
-  return existsSync23(resolved) ? { path: resolved } : null;
+  const resolved = resolve14(workspacePath, pluginSource);
+  return existsSync24(resolved) ? { path: resolved } : null;
 }
 async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
   const configPath = join25(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (!existsSync23(configPath)) {
+  if (!existsSync24(configPath)) {
     return [];
   }
   const content = await readFile14(configPath, "utf-8");
@@ -34102,7 +34300,7 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
     const pluginSkillsConfig = typeof pluginEntry === "string" ? undefined : pluginEntry.skills;
     const hasEnabledEntries = !pluginSkillsConfig && enabledSkills && [...enabledSkills].some((s) => s.startsWith(`${pluginName}`));
     let skillEntries;
-    if (existsSync23(skillsDir)) {
+    if (existsSync24(skillsDir)) {
       const entries = await readdir5(skillsDir, { withFileTypes: true });
       skillEntries = entries.filter((e) => e.isDirectory()).map((e) => ({ name: e.name, skillPath: join25(skillsDir, e.name) }));
     } else {
@@ -34112,7 +34310,7 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
         if (!entry.isDirectory())
           continue;
         const skillMdPath = join25(pluginPath, entry.name, "SKILL.md");
-        if (existsSync23(skillMdPath)) {
+        if (existsSync24(skillMdPath)) {
           flatSkills.push({ name: entry.name, skillPath: join25(pluginPath, entry.name) });
         }
       }
@@ -34120,7 +34318,7 @@ async function getAllSkillsFromPlugins(workspacePath = process.cwd()) {
         skillEntries = flatSkills;
       } else {
         const rootSkillMd = join25(pluginPath, "SKILL.md");
-        if (existsSync23(rootSkillMd)) {
+        if (existsSync24(rootSkillMd)) {
           const skillContent = await readFile14(rootSkillMd, "utf-8");
           const metadata = parseSkillMetadata(skillContent);
           const skillName = metadata?.name ?? basename7(pluginPath);
@@ -34162,10 +34360,10 @@ async function findSkillByName(skillName, workspacePath = process.cwd()) {
   return allSkills.filter((s) => s.name === skillName);
 }
 async function discoverSkillNames(pluginPath) {
-  if (!existsSync23(pluginPath))
+  if (!existsSync24(pluginPath))
     return [];
   const skillsDir = join25(pluginPath, "skills");
-  if (existsSync23(skillsDir)) {
+  if (existsSync24(skillsDir)) {
     const entries2 = await readdir5(skillsDir, { withFileTypes: true });
     return entries2.filter((e) => e.isDirectory()).map((e) => e.name);
   }
@@ -34174,14 +34372,14 @@ async function discoverSkillNames(pluginPath) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    if (existsSync23(join25(pluginPath, entry.name, "SKILL.md"))) {
+    if (existsSync24(join25(pluginPath, entry.name, "SKILL.md"))) {
       flatSkills.push(entry.name);
     }
   }
   if (flatSkills.length > 0)
     return flatSkills;
   const rootSkillMd = join25(pluginPath, "SKILL.md");
-  if (existsSync23(rootSkillMd)) {
+  if (existsSync24(rootSkillMd)) {
     try {
       const content = await readFile14(rootSkillMd, "utf-8");
       const { parseSkillMetadata: parseSkillMetadata2 } = await Promise.resolve().then(() => (init_skill(), exports_skill));
@@ -34292,12 +34490,12 @@ var require_isexe = __commonJS((exports, module) => {
       if (typeof Promise !== "function") {
         throw new TypeError("callback not provided");
       }
-      return new Promise(function(resolve14, reject) {
+      return new Promise(function(resolve15, reject) {
         isexe(path, options2 || {}, function(er, is) {
           if (er) {
             reject(er);
           } else {
-            resolve14(is);
+            resolve15(is);
           }
         });
       });
@@ -34359,27 +34557,27 @@ var require_which = __commonJS((exports, module) => {
       opt = {};
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
     const found = [];
-    const step = (i2) => new Promise((resolve14, reject) => {
+    const step = (i2) => new Promise((resolve15, reject) => {
       if (i2 === pathEnv.length)
-        return opt.all && found.length ? resolve14(found) : reject(getNotFoundError(cmd));
+        return opt.all && found.length ? resolve15(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;
-      resolve14(subStep(p, i2, 0));
+      resolve15(subStep(p, i2, 0));
     });
-    const subStep = (p, i2, ii) => new Promise((resolve14, reject) => {
+    const subStep = (p, i2, ii) => new Promise((resolve15, reject) => {
       if (ii === pathExt.length)
-        return resolve14(step(i2 + 1));
+        return resolve15(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 resolve14(p + ext);
+            return resolve15(p + ext);
         }
-        return resolve14(subStep(p, i2, ii + 1));
+        return resolve15(subStep(p, i2, ii + 1));
       });
     });
     return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
@@ -34701,7 +34899,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.7.0",
+    version: "1.7.2-next.1",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -34728,7 +34926,9 @@ var init_package = __esm(() => {
       prepare: "bun run build && (test -d .git && bunx prek install -t pre-push || true)",
       release: "bun run scripts/release.ts",
       "release:next": "bun run scripts/release.ts next",
+      "release:finalize": "bun run scripts/release.ts finalize",
       prepublishOnly: `test "$ALLOW_PUBLISH" = '1' || (echo 'ERROR: Use bun run publish:next, then bun run promote:latest' && exit 1)`,
+      publish: "bun run build && ALLOW_PUBLISH=1 npm publish",
       "publish:next": "bun run build && ALLOW_PUBLISH=1 npm publish --tag next",
       "promote:latest": "bun scripts/tag-channel.ts latest"
     },
@@ -34911,7 +35111,7 @@ class TuiCache {
 }
 
 // src/cli/tui/context.ts
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { join as join29 } from "node:path";
 async function getTuiContext(cwd = process.cwd(), cache2) {
   const cachedContext = cache2?.getContext();
@@ -34919,7 +35119,7 @@ async function getTuiContext(cwd = process.cwd(), cache2) {
     return cachedContext;
   }
   const configPath = join29(cwd, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  const hasWorkspace = existsSync26(configPath) && !isUserConfigPath(cwd);
+  const hasWorkspace = existsSync27(configPath) && !isUserConfigPath(cwd);
   let projectPluginCount = 0;
   if (hasWorkspace) {
     try {
@@ -36335,8 +36535,8 @@ init_workspace();
 init_sync();
 init_status2();
 var import_cmd_ts2 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync22 } from "node:fs";
-import { join as join24, resolve as resolve12 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { join as join24, resolve as resolve13 } from "node:path";
 
 // src/core/prune.ts
 init_js_yaml();
@@ -36345,7 +36545,7 @@ init_marketplace();
 init_user_workspace();
 init_workspace_config();
 import { readFile as readFile13, writeFile as writeFile9 } from "node:fs/promises";
-import { existsSync as existsSync21 } from "node:fs";
+import { existsSync as existsSync22 } from "node:fs";
 import { join as join23 } from "node:path";
 async function isOrphanedPlugin(pluginSpec) {
   if (!isPluginSpec(pluginSpec))
@@ -36374,7 +36574,7 @@ async function prunePlugins(plugins) {
 async function pruneOrphanedPlugins(workspacePath) {
   let projectResult = { removed: [], kept: [], keptEntries: [] };
   const projectConfigPath = join23(workspacePath, CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-  if (existsSync21(projectConfigPath) && !isUserConfigPath(workspacePath)) {
+  if (existsSync22(projectConfigPath) && !isUserConfigPath(workspacePath)) {
     const content = await readFile13(projectConfigPath, "utf-8");
     const config = load(content);
     projectResult = await prunePlugins(config.plugins);
@@ -36657,9 +36857,10 @@ var syncCmd = import_cmd_ts2.command({
     offline: import_cmd_ts2.flag({ long: "offline", description: "Use cached plugins without fetching latest from remote" }),
     dryRun: import_cmd_ts2.flag({ long: "dry-run", short: "n", description: "Simulate sync without making changes" }),
     force: import_cmd_ts2.flag({ long: "force", short: "f", description: "Overwrite existing MCP server entries that differ from plugin config" }),
-    verbose: import_cmd_ts2.flag({ long: "verbose", short: "v", description: "Show informational sync messages" })
+    verbose: import_cmd_ts2.flag({ long: "verbose", short: "v", description: "Show informational sync messages" }),
+    noManaged: import_cmd_ts2.flag({ long: "no-managed", description: "Skip managed repository clone/pull operations" })
   },
-  handler: async ({ offline, dryRun, force, verbose }) => {
+  handler: async ({ offline, dryRun, force, verbose, noManaged }) => {
     try {
       if (!isJsonMode() && dryRun) {
         console.log(`Dry run mode - no changes will be made
@@ -36667,7 +36868,7 @@ var syncCmd = import_cmd_ts2.command({
       }
       const userConfigExists = !!await getUserWorkspaceConfig();
       const projectConfigPath = join24(process.cwd(), ".allagents", "workspace.yaml");
-      const projectConfigExists = existsSync22(projectConfigPath);
+      const projectConfigExists = existsSync23(projectConfigPath);
       if (!userConfigExists && !projectConfigExists) {
         await ensureUserWorkspace();
         if (isJsonMode()) {
@@ -36687,7 +36888,8 @@ var syncCmd = import_cmd_ts2.command({
       if (projectConfigExists) {
         const projectResult = await syncWorkspace(process.cwd(), {
           offline,
-          dryRun
+          dryRun,
+          skipManaged: noManaged
         });
         combined = combined ? mergeSyncResults(combined, projectResult) : projectResult;
       }
@@ -36716,6 +36918,12 @@ var syncCmd = import_cmd_ts2.command({
         }
         console.log("");
       }
+      if (result.managedRepoResults && result.managedRepoResults.length > 0) {
+        for (const line of formatManagedRepoResults(result.managedRepoResults)) {
+          console.log(line);
+        }
+        console.log("");
+      }
       for (const line of formatSyncHeader(result)) {
         console.log(line);
       }
@@ -36955,7 +37163,7 @@ var repoAddCmd = import_cmd_ts2.command({
   },
   handler: async ({ path: repoPath, description }) => {
     try {
-      const resolvedPath = resolve12(process.cwd(), repoPath);
+      const resolvedPath = resolve13(process.cwd(), repoPath);
       const remote = await detectRemote(resolvedPath);
       const result = await addRepository(repoPath, {
         source: remote?.source,
@@ -37335,7 +37543,7 @@ init_workspace_modify();
 init_user_workspace();
 init_skills();
 var import_cmd_ts3 = __toESM(require_cjs(), 1);
-import { existsSync as existsSync24 } from "node:fs";
+import { existsSync as existsSync25 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
 import { join as join26 } from "node:path";
 
@@ -37428,7 +37636,7 @@ init_skill();
 init_marketplace();
 init_marketplace_manifest_parser();
 function hasProjectConfig(dir) {
-  return existsSync24(join26(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
+  return existsSync25(join26(dir, CONFIG_DIR, WORKSPACE_CONFIG_FILE));
 }
 function resolveScope(cwd) {
   if (isUserConfigPath(cwd))
@@ -38017,7 +38225,7 @@ init_workspace_config();
 init_constants();
 init_js_yaml();
 import { readFile as readFile16 } from "node:fs/promises";
-import { existsSync as existsSync25 } from "node:fs";
+import { existsSync as existsSync26 } from "node:fs";
 import { join as join27 } from "node:path";
 async function runSyncAndPrint(options2) {
   if (!isJsonMode()) {
@@ -38263,7 +38471,7 @@ var marketplaceAddCmd = import_cmd_ts4.command({
         process.exit(1);
       }
       if (effectiveScope === "project") {
-        if (!existsSync25(join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE))) {
+        if (!existsSync26(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 });
@@ -38570,7 +38778,7 @@ var pluginListCmd = import_cmd_ts4.command({
       };
       const pluginClients = new Map;
       async function loadConfigClients(configPath, scope) {
-        if (!existsSync25(configPath))
+        if (!existsSync26(configPath))
           return;
         try {
           const content = await readFile16(configPath, "utf-8");
@@ -38728,7 +38936,7 @@ var pluginInstallCmd = import_cmd_ts4.command({
       const isUser = scope === "user" || !scope && isUserConfigPath(process.cwd());
       if (isUser) {
         const userConfigPath = getUserWorkspaceConfigPath();
-        if (!existsSync25(userConfigPath)) {
+        if (!existsSync26(userConfigPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -38741,7 +38949,7 @@ var pluginInstallCmd = import_cmd_ts4.command({
         }
       } else {
         const configPath = join27(process.cwd(), CONFIG_DIR, WORKSPACE_CONFIG_FILE);
-        if (!existsSync25(configPath)) {
+        if (!existsSync26(configPath)) {
           const { promptForClients: promptForClients2 } = await Promise.resolve().then(() => (init_prompt_clients(), exports_prompt_clients));
           const clients = await promptForClients2();
           if (clients === null) {
@@ -39018,13 +39226,13 @@ var pluginUpdateCmd = import_cmd_ts4.command({
         }
       }
       if (updateProject && !isUserConfigPath(process.cwd())) {
-        const { existsSync: existsSync26 } = await import("node:fs");
+        const { existsSync: existsSync27 } = await import("node:fs");
         const { readFile: readFile17 } = await import("node:fs/promises");
         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 = join28(process.cwd(), CONFIG_DIR2, WORKSPACE_CONFIG_FILE2);
-        if (existsSync26(configPath)) {
+        if (existsSync27(configPath)) {
           const content = await readFile17(configPath, "utf-8");
           const config = load2(content);
           for (const entry of config.plugins ?? []) {
@@ -40057,7 +40265,7 @@ var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise
     return spawnedPromise;
   }
   let timeoutId;
-  const timeoutPromise = new Promise((resolve14, reject) => {
+  const timeoutPromise = new Promise((resolve15, reject) => {
     timeoutId = setTimeout(() => {
       timeoutKill(spawned, killSignal, reject);
     }, timeout);
@@ -40421,9 +40629,9 @@ var mergePromise = (spawned, promise) => {
     Reflect.defineProperty(spawned, property, { ...descriptor, value });
   }
 };
-var getSpawnedPromise = (spawned) => new Promise((resolve14, reject) => {
+var getSpawnedPromise = (spawned) => new Promise((resolve15, reject) => {
   spawned.on("exit", (exitCode, signal) => {
-    resolve14({ exitCode, signal });
+    resolve15({ exitCode, signal });
   });
   spawned.on("error", (error) => {
     reject(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "1.7.0",
+  "version": "1.7.2-next.1",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {
@@ -27,7 +27,9 @@
     "prepare": "bun run build && (test -d .git && bunx prek install -t pre-push || true)",
     "release": "bun run scripts/release.ts",
     "release:next": "bun run scripts/release.ts next",
+    "release:finalize": "bun run scripts/release.ts finalize",
     "prepublishOnly": "test \"$ALLOW_PUBLISH\" = '1' || (echo 'ERROR: Use bun run publish:next, then bun run promote:latest' && exit 1)",
+    "publish": "bun run build && ALLOW_PUBLISH=1 npm publish",
     "publish:next": "bun run build && ALLOW_PUBLISH=1 npm publish --tag next",
     "promote:latest": "bun scripts/tag-channel.ts latest"
   },