allagents 1.4.9 → 1.4.10

package/dist/index.js

@@ -15959,9 +15959,37 @@ var init_plugin_path = __esm(() => {
 });
 
 // src/core/plugin.ts
+var exports_plugin = {};
+__export(exports_plugin, {
+  updatePlugin: () => updatePlugin,
+  updateCachedPlugins: () => updateCachedPlugins,
+  seedFetchCache: () => seedFetchCache,
+  resetFetchCache: () => resetFetchCache,
+  listCachedPlugins: () => listCachedPlugins,
+  getPluginName: () => getPluginName,
+  getPluginCacheDir: () => getPluginCacheDir,
+  fetchPlugin: () => fetchPlugin
+});
 import { mkdir, readdir, stat } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
 import { basename, dirname, join as join3, resolve as resolve3 } from "node:path";
+function resetFetchCache() {
+  fetchCache.clear();
+}
+function seedFetchCache(url, path, branch) {
+  const parsed = parseGitHubUrl(url);
+  if (!parsed)
+    return;
+  const { owner, repo } = parsed;
+  const cachePath = getPluginCachePath(owner, repo, branch ?? parsed.branch);
+  if (fetchCache.has(cachePath))
+    return;
+  fetchCache.set(cachePath, Promise.resolve({
+    success: true,
+    action: "skipped",
+    cachePath: path
+  }));
+}
 async function fetchPlugin(url, options2 = {}, deps = {}) {
   const { offline = false, branch } = options2;
   const validation = validatePluginSource(url);
@@ -15984,17 +16012,13 @@ async function fetchPlugin(url, options2 = {}, deps = {}) {
   }
   const { owner, repo } = parsed;
   const cachePath = getPluginCachePath(owner, repo, branch);
-  const existing = inflight.get(cachePath);
-  if (existing) {
-    return existing;
+  const cached = fetchCache.get(cachePath);
+  if (cached) {
+    return cached;
   }
   const promise = doFetchPlugin(cachePath, owner, repo, offline, branch, deps);
-  inflight.set(cachePath, promise);
-  try {
-    return await promise;
-  } finally {
-    inflight.delete(cachePath);
-  }
+  fetchCache.set(cachePath, promise);
+  return promise;
 }
 async function doFetchPlugin(cachePath, owner, repo, offline, branch, deps) {
   const {
@@ -16014,8 +16038,10 @@ async function doFetchPlugin(cachePath, owner, repo, offline, branch, deps) {
   const repoUrl = gitHubUrl(owner, repo);
   if (isCached) {
     try {
+      const pullStart = performance.now();
       await pullFn(cachePath);
-      return { success: true, action: "updated", cachePath };
+      const pullMs = Math.round(performance.now() - pullStart);
+      return { success: true, action: "updated", cachePath, durationMs: pullMs };
     } catch {
       return { success: true, action: "skipped", cachePath };
     }
@@ -16023,11 +16049,14 @@ async function doFetchPlugin(cachePath, owner, repo, offline, branch, deps) {
   try {
     const parentDir = dirname(cachePath);
     await mkdirFn(parentDir, { recursive: true });
+    const cloneStart = performance.now();
     await cloneToFn(repoUrl, cachePath, branch);
+    const cloneMs = Math.round(performance.now() - cloneStart);
     return {
       success: true,
       action: "fetched",
-      cachePath
+      cachePath,
+      durationMs: cloneMs
     };
   } catch (error) {
     if (error instanceof GitCloneError) {
@@ -16058,6 +16087,57 @@ async function doFetchPlugin(cachePath, owner, repo, offline, branch, deps) {
     };
   }
 }
+function getPluginCacheDir() {
+  return resolve3(getHomeDir(), ".allagents", "plugins", "marketplaces");
+}
+async function listCachedPlugins() {
+  const cacheDir = getPluginCacheDir();
+  if (!existsSync2(cacheDir)) {
+    return [];
+  }
+  const entries = await readdir(cacheDir, { withFileTypes: true });
+  const plugins = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const pluginPath = join3(cacheDir, entry.name);
+      const stats = await stat(pluginPath);
+      plugins.push({
+        name: entry.name,
+        path: pluginPath,
+        lastModified: stats.mtime
+      });
+    }
+  }
+  plugins.sort((a, b) => a.name.localeCompare(b.name));
+  return plugins;
+}
+async function updateCachedPlugins(name) {
+  const plugins = await listCachedPlugins();
+  const results = [];
+  const toUpdate = name ? plugins.filter((p) => p.name === name) : plugins;
+  if (name && toUpdate.length === 0) {
+    return [
+      {
+        name,
+        success: false,
+        error: `Plugin not found in cache: ${name}`
+      }
+    ];
+  }
+  for (const plugin of toUpdate) {
+    try {
+      await pull(plugin.path);
+      results.push({ name: plugin.name, success: true });
+    } catch (error) {
+      results.push({
+        name: plugin.name,
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  return results;
+}
 function getPluginName(pluginPath) {
   return basename(pluginPath);
 }
@@ -16135,12 +16215,12 @@ async function updatePlugin(pluginSpec, deps) {
     ...fetchResult.error && { error: fetchResult.error }
   };
 }
-var inflight;
+var fetchCache;
 var init_plugin = __esm(() => {
   init_plugin_path();
   init_constants();
   init_git();
-  inflight = new Map;
+  fetchCache = new Map;
 });
 
 // node_modules/braces/lib/utils.js
@@ -29736,6 +29816,80 @@ var init_native = __esm(() => {
   init_registry();
 });
 
+// src/utils/stopwatch.ts
+class Stopwatch {
+  entries = [];
+  active = new Map;
+  globalStart;
+  constructor() {
+    this.globalStart = performance.now();
+  }
+  start(label) {
+    this.active.set(label, performance.now());
+  }
+  stop(label, detail) {
+    const startTime = this.active.get(label);
+    if (startTime === undefined) {
+      return 0;
+    }
+    const durationMs = performance.now() - startTime;
+    this.active.delete(label);
+    this.entries.push({ label, durationMs, ...detail !== undefined && { detail } });
+    return durationMs;
+  }
+  async measure(label, fn, detail) {
+    this.start(label);
+    try {
+      const result = await fn();
+      this.stop(label, detail);
+      return result;
+    } catch (error) {
+      this.stop(label, detail ? `${detail} (failed)` : "(failed)");
+      throw error;
+    }
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  getTotalMs() {
+    return performance.now() - this.globalStart;
+  }
+  formatReport() {
+    const lines = [];
+    const totalMs = this.getTotalMs();
+    lines.push(`Sync timing report (total: ${formatMs(totalMs)})`);
+    lines.push("─".repeat(60));
+    for (const entry of this.entries) {
+      const pct = totalMs > 0 ? (entry.durationMs / totalMs * 100).toFixed(1) : "0.0";
+      const detail = entry.detail ? ` [${entry.detail}]` : "";
+      lines.push(`  ${padEnd(entry.label, 40)} ${padStart2(formatMs(entry.durationMs), 8)}  ${padStart2(pct, 5)}%${detail}`);
+    }
+    lines.push("─".repeat(60));
+    return lines;
+  }
+  toJSON() {
+    return {
+      totalMs: Math.round(this.getTotalMs()),
+      steps: this.entries.map((e) => ({
+        label: e.label,
+        durationMs: Math.round(e.durationMs),
+        ...e.detail && { detail: e.detail }
+      }))
+    };
+  }
+}
+function formatMs(ms) {
+  if (ms < 1000)
+    return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
+function padEnd(str3, len) {
+  return str3.length >= len ? str3 : str3 + " ".repeat(len - str3.length);
+}
+function padStart2(str3, len) {
+  return str3.length >= len ? str3 : " ".repeat(len - str3.length) + str3;
+}
+
 // src/core/sync.ts
 import { existsSync as existsSync14, readFileSync as readFileSync4, writeFileSync as writeFileSync4, lstatSync } from "node:fs";
 import { rm as rm4, unlink as unlink2, rmdir, copyFile } from "node:fs/promises";
@@ -29784,7 +29938,20 @@ function mergeSyncResults(a, b) {
     ...purgedPaths.length > 0 && { purgedPaths },
     ...deletedArtifacts.length > 0 && { deletedArtifacts },
     ...mcpResults && { mcpResults },
-    ...nativeResult && { nativeResult }
+    ...nativeResult && { nativeResult },
+    ...mergeTiming(a.timing, b.timing)
+  };
+}
+function mergeTiming(a, b) {
+  if (!a && !b)
+    return {};
+  const aSteps = (a?.steps ?? []).map((s) => ({ ...s, label: `user:${s.label}` }));
+  const bSteps = (b?.steps ?? []).map((s) => ({ ...s, label: `project:${s.label}` }));
+  return {
+    timing: {
+      totalMs: (a?.totalMs ?? 0) + (b?.totalMs ?? 0),
+      steps: [...aSteps, ...bSteps]
+    }
   };
 }
 function resolveNativePluginSource(vp) {
@@ -30523,6 +30690,7 @@ 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 sw = new Stopwatch;
   const configDir = join16(workspacePath, CONFIG_DIR);
   const configPath = join16(configDir, WORKSPACE_CONFIG_FILE);
   if (!existsSync14(configPath)) {
@@ -30557,11 +30725,13 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
       ]
     };
   }
-  await ensureMarketplacesRegistered(filteredPlans.map((plan) => plan.source));
-  const validatedPlugins = await validateAllPlugins(filteredPlans, workspacePath, offline);
+  const marketplaceResults = await sw.measure("marketplace-registration", () => ensureMarketplacesRegistered(filteredPlans.map((plan) => plan.source)));
+  await seedFetchCacheFromMarketplaces(marketplaceResults);
+  const validatedPlugins = await sw.measure("plugin-validation", () => validateAllPlugins(filteredPlans, workspacePath, offline), `${filteredPlans.length} plugin(s)`);
   let validatedWorkspaceSource = null;
   const workspaceSourceWarnings = [];
   if (config.workspace?.source) {
+    sw.start("workspace-source-validation");
     const sourceBasePath = workspaceSourceBase ?? workspacePath;
     const wsSourceResult = await validatePlugin(config.workspace.source, sourceBasePath, offline);
     if (wsSourceResult.success) {
@@ -30569,6 +30739,7 @@ async function syncWorkspace(workspacePath = process.cwd(), options2 = {}) {
     } else {
       workspaceSourceWarnings.push(`Workspace source: ${wsSourceResult.error}`);
     }
+    sw.stop("workspace-source-validation");
   }
   const failedValidations = validatedPlugins.filter((v) => !v.success);
   const validPlugins = validatedPlugins.filter((v) => v.success);
@@ -30589,23 +30760,24 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     paths: getPreviouslySyncedFiles(previousState, client)
   })).filter((p) => p.paths.length > 0) : [];
   if (!dryRun) {
-    await selectivePurgeWorkspace(workspacePath, previousState, syncClients);
+    await sw.measure("selective-purge", () => selectivePurgeWorkspace(workspacePath, previousState, syncClients));
   }
   const isV1Fallback = config.version === undefined || config.version < 2;
   const disabledSkillsSet = isV1Fallback ? new Set(config.disabledSkills ?? []) : undefined;
   const enabledSkillsSet = isV1Fallback && config.enabledSkills ? new Set(config.enabledSkills) : undefined;
-  const allSkills = await collectAllSkills(validPlugins, disabledSkillsSet, enabledSkillsSet);
+  const allSkills = await sw.measure("skill-collection", () => collectAllSkills(validPlugins, disabledSkillsSet, enabledSkillsSet));
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
   const syncMode = config.syncMode ?? "symlink";
-  const pluginResults = await Promise.all(validPlugins.map(async (validatedPlugin) => {
+  const pluginResults = await sw.measure("plugin-copy", () => Promise.all(validPlugins.map(async (validatedPlugin) => {
     const skillNameMap = pluginSkillMaps.get(validatedPlugin.resolved);
     const result = await copyValidatedPlugin(validatedPlugin, workspacePath, validatedPlugin.clients, dryRun, skillNameMap, undefined, syncMode);
     return { ...result, scope: "project" };
-  }));
-  const nativeResult = await syncNativePlugins(validPlugins, previousState, "project", workspacePath, dryRun, warnings, messages);
+  })), `${validPlugins.length} plugin(s)`);
+  const nativeResult = await sw.measure("native-plugin-sync", () => syncNativePlugins(validPlugins, previousState, "project", workspacePath, dryRun, warnings, messages));
   let workspaceFileResults = [];
   const skipWorkspaceFiles = !!config.workspace?.source && !validatedWorkspaceSource;
   if (config.workspace && !skipWorkspaceFiles) {
+    sw.start("workspace-files");
     const sourcePath = validatedWorkspaceSource?.resolved;
     const filesToCopy = [...config.workspace.files];
     if (hasRepositories && sourcePath) {
@@ -30642,18 +30814,20 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
         await copyFile(agentsPath, claudePath);
       }
     }
+    sw.stop("workspace-files");
   }
   if (!config.workspace && !dryRun && !skipAgentFiles) {
     await updateAgentFiles(workspacePath);
   }
   let vscodeState;
   if (syncClients.includes("vscode") && !dryRun) {
-    const result = await syncVscodeWorkspaceFile(workspacePath, config, configPath, previousState, messages);
+    const result = await sw.measure("vscode-workspace-file", () => syncVscodeWorkspaceFile(workspacePath, config, configPath, previousState, messages));
     config = result.config;
     if (result.hash && result.repos) {
       vscodeState = { hash: result.hash, repos: result.repos };
     }
   }
+  sw.start("mcp-sync");
   const mcpResults = {};
   if (syncClients.includes("vscode")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "vscode");
@@ -30711,6 +30885,7 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     }
     mcpResults.copilot = copilotMcp;
   }
+  sw.stop("mcp-sync");
   const PROJECT_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "copilot", "universal"]);
   const { servers: allMcpServers } = collectMcpServers(validPlugins);
   if (allMcpServers.size > 0) {
@@ -30729,12 +30904,12 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
   const deletedArtifacts = computeDeletedArtifacts(previousState, newStatePaths, syncClients, resolvedMappings, availableSkillNames);
   const { pluginsByClient: nativePluginsByClient } = collectNativePluginSources(validPlugins);
   if (!dryRun) {
-    await persistSyncState(workspacePath, pluginResults, workspaceFileResults, syncClients, nativePluginsByClient, nativeResult, {
+    await sw.measure("persist-state", () => persistSyncState(workspacePath, pluginResults, workspaceFileResults, syncClients, nativePluginsByClient, nativeResult, {
       ...vscodeState && { vscodeState },
       ...Object.keys(mcpResults).length > 0 && {
         mcpTrackedServers: Object.fromEntries(Object.entries(mcpResults).map(([scope, r]) => [scope, r.trackedServers]))
       }
-    });
+    }));
   }
   return {
     success: !hasFailures,
@@ -30748,11 +30923,36 @@ ${fileValidationErrors.map((e) => `  - ${e}`).join(`
     ...warnings.length > 0 && { warnings },
     ...messages.length > 0 && { messages },
     ...Object.keys(mcpResults).length > 0 && { mcpResults },
-    ...nativeResult && { nativeResult }
+    ...nativeResult && { nativeResult },
+    timing: sw.toJSON()
   };
 }
+async function seedFetchCacheFromMarketplaces(results) {
+  for (const result of results) {
+    if (!result.success || !result.name)
+      continue;
+    const entry = await getMarketplace(result.name);
+    if (!entry || entry.source.type !== "github")
+      continue;
+    seedFetchCache(entry.source.location, entry.path);
+    const branch = readGitBranch(entry.path);
+    if (branch) {
+      seedFetchCache(entry.source.location, entry.path, branch);
+    }
+  }
+}
+function readGitBranch(repoPath) {
+  try {
+    const head = readFileSync4(join16(repoPath, ".git", "HEAD"), "utf-8").trim();
+    const prefix = "ref: refs/heads/";
+    return head.startsWith(prefix) ? head.slice(prefix.length) : null;
+  } catch {
+    return null;
+  }
+}
 async function syncUserWorkspace(options2 = {}) {
   await migrateUserWorkspaceSkillsV1toV2();
+  const sw = new Stopwatch;
   const homeDir = resolve9(getHomeDir());
   const config = await getUserWorkspaceConfig();
   if (!config) {
@@ -30770,8 +30970,9 @@ async function syncUserWorkspace(options2 = {}) {
   const { plans: allPluginPlans, warnings: planWarnings } = buildPluginSyncPlans(config.plugins, workspaceClients, "user");
   const pluginPlans = allPluginPlans.filter((plan) => plan.clients.length > 0 || plan.nativeClients.length > 0);
   const syncClients = collectSyncClients(workspaceClients, pluginPlans);
-  await ensureMarketplacesRegistered(pluginPlans.map((plan) => plan.source));
-  const validatedPlugins = await validateAllPlugins(pluginPlans, homeDir, offline);
+  const marketplaceResults = await sw.measure("marketplace-registration", () => ensureMarketplacesRegistered(pluginPlans.map((plan) => plan.source)));
+  await seedFetchCacheFromMarketplaces(marketplaceResults);
+  const validatedPlugins = await sw.measure("plugin-validation", () => validateAllPlugins(pluginPlans, homeDir, offline), `${pluginPlans.length} plugin(s)`);
   const failedValidations = validatedPlugins.filter((v) => !v.success);
   const validPlugins = validatedPlugins.filter((v) => v.success);
   const warnings = [
@@ -30786,21 +30987,22 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   }
   const previousState = await loadSyncState(homeDir);
   if (!dryRun) {
-    await selectivePurgeWorkspace(homeDir, previousState, syncClients);
+    await sw.measure("selective-purge", () => selectivePurgeWorkspace(homeDir, previousState, syncClients));
   }
   const isV1FallbackUser = config.version === undefined || config.version < 2;
   const disabledSkillsSet = isV1FallbackUser ? new Set(config.disabledSkills ?? []) : undefined;
   const enabledSkillsSet = isV1FallbackUser && config.enabledSkills ? new Set(config.enabledSkills) : undefined;
-  const allSkills = await collectAllSkills(validPlugins, disabledSkillsSet, enabledSkillsSet);
+  const allSkills = await sw.measure("skill-collection", () => collectAllSkills(validPlugins, disabledSkillsSet, enabledSkillsSet));
   const pluginSkillMaps = buildPluginSkillNameMaps(allSkills);
   const syncMode = config.syncMode ?? "symlink";
-  const pluginResults = await Promise.all(validPlugins.map(async (vp) => {
+  const pluginResults = await sw.measure("plugin-copy", () => Promise.all(validPlugins.map(async (vp) => {
     const skillNameMap = pluginSkillMaps.get(vp.resolved);
     const resolvedUserMappings2 = resolveClientMappings(vp.clients, USER_CLIENT_MAPPINGS);
     const result = await copyValidatedPlugin(vp, homeDir, vp.clients, dryRun, skillNameMap, resolvedUserMappings2, syncMode);
     return { ...result, scope: "user" };
-  }));
+  })), `${validPlugins.length} plugin(s)`);
   const { totalCopied, totalFailed, totalSkipped, totalGenerated } = countCopyResults(pluginResults, []);
+  sw.start("mcp-sync");
   const mcpResults = {};
   if (syncClients.includes("vscode")) {
     const trackedMcpServers = getPreviouslySyncedMcpServers(previousState, "vscode");
@@ -30840,6 +31042,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     }
     mcpResults.copilot = copilotMcp;
   }
+  sw.stop("mcp-sync");
   const USER_MCP_CLIENTS = new Set(["claude", "codex", "vscode", "copilot", "universal"]);
   const { servers: allUserMcpServers } = collectMcpServers(validPlugins);
   if (allUserMcpServers.size > 0) {
@@ -30849,7 +31052,7 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
       }
     }
   }
-  const nativeResult = await syncNativePlugins(validPlugins, previousState, "user", homeDir, dryRun, warnings, messages);
+  const nativeResult = await sw.measure("native-plugin-sync", () => syncNativePlugins(validPlugins, previousState, "user", homeDir, dryRun, warnings, messages));
   const availableUserSkillNames = await collectAvailableSkillNames(validPlugins);
   const allCopyResultsForState = pluginResults.flatMap((r) => r.copyResults);
   const resolvedUserMappings = resolveClientMappings(syncClients, USER_CLIENT_MAPPINGS);
@@ -30857,12 +31060,12 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
   const deletedArtifacts = computeDeletedArtifacts(previousState, newStatePaths, syncClients, resolvedUserMappings, availableUserSkillNames);
   if (!dryRun) {
     const { pluginsByClient: nativePluginsByClient } = collectNativePluginSources(validPlugins);
-    await persistSyncState(homeDir, pluginResults, [], syncClients, nativePluginsByClient, nativeResult, {
+    await sw.measure("persist-state", () => persistSyncState(homeDir, pluginResults, [], syncClients, nativePluginsByClient, nativeResult, {
       clientMappings: USER_CLIENT_MAPPINGS,
       ...Object.keys(mcpResults).length > 0 && {
         mcpTrackedServers: Object.fromEntries(Object.entries(mcpResults).map(([scope, r]) => [scope, r.trackedServers]))
       }
-    });
+    }));
   }
   return {
     success: totalFailed === 0,
@@ -30875,7 +31078,8 @@ ${failedValidations.map((v) => `  - ${v.plugin}: ${v.error}`).join(`
     ...warnings.length > 0 && { warnings },
     ...messages.length > 0 && { messages },
     ...Object.keys(mcpResults).length > 0 && { mcpResults },
-    ...nativeResult && { nativeResult }
+    ...nativeResult && { nativeResult },
+    timing: sw.toJSON()
   };
 }
 var import_json53, VSCODE_TEMPLATE_FILE = "template.code-workspace";
@@ -34103,7 +34307,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "allagents",
-    version: "1.4.9",
+    version: "1.4.10",
     description: "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
     type: "module",
     bin: {
@@ -36080,6 +36284,8 @@ var syncCmd = import_cmd_ts2.command({
         return;
       }
       let combined = null;
+      const { resetFetchCache: resetFetchCache2 } = await Promise.resolve().then(() => (init_plugin(), exports_plugin));
+      resetFetchCache2();
       if (userConfigExists) {
         const userResult = await syncUserWorkspace({ offline, dryRun, force });
         combined = userResult;
@@ -36182,6 +36388,20 @@ native:`);
           console.log(line);
         }
       }
+      if (process.env.ALLAGENTS_DEBUG?.includes("timing") && result.timing) {
+        console.error("");
+        const totalMs = result.timing.totalMs;
+        console.error(`[debug] Sync timing (total: ${formatTimingMs(totalMs)})`);
+        console.error(`[debug] ${"─".repeat(56)}`);
+        for (const step of result.timing.steps) {
+          const pct = totalMs > 0 ? (step.durationMs / totalMs * 100).toFixed(1) : "0.0";
+          const detail = step.detail ? ` [${step.detail}]` : "";
+          const label = step.label.padEnd(40);
+          const duration = formatTimingMs(step.durationMs).padStart(8);
+          console.error(`[debug]   ${label} ${duration}  ${pct.padStart(5)}%${detail}`);
+        }
+        console.error(`[debug] ${"─".repeat(56)}`);
+      }
       if (!result.success || result.totalFailed > 0) {
         process.exit(1);
       }
@@ -36198,6 +36418,11 @@ native:`);
     }
   }
 });
+function formatTimingMs(ms) {
+  if (ms < 1000)
+    return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(2)}s`;
+}
 var statusCmd = import_cmd_ts2.command({
   name: "status",
   description: buildDescription(statusMeta),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "allagents",
-  "version": "1.4.9",
+  "version": "1.4.10",
   "description": "CLI tool for managing multi-repo AI agent workspaces with plugin synchronization",
   "type": "module",
   "bin": {