agents-inc 0.164.0 → 0.166.0

package/dist/commands/uninstall.js

@@ -1,52 +1,59 @@
 #!/usr/bin/env node
 import {
   RemovalPlanConfirm
-} from "../chunk-ZVXGW2IC.js";
-import "../chunk-OZXAJNLA.js";
+} from "../chunk-TODCQFRB.js";
 import {
   promptConfirm
-} from "../chunk-JCPANDNR.js";
+} from "../chunk-4AAOOAIN.js";
+import "../chunk-OZXAJNLA.js";
 import {
   lazyGateDeps,
   mutateGlobal,
   propagateGlobalRemoval
-} from "../chunk-X37UYIE3.js";
-import "../chunk-2CQNPLVF.js";
+} from "../chunk-G6UREQ4V.js";
+import "../chunk-HWEKHVLE.js";
 import {
   loadAgentDefs
-} from "../chunk-B6FSLXYN.js";
+} from "../chunk-PMJWD27C.js";
+import "../chunk-ZR4YPKXQ.js";
 import {
-  listAgentMdFiles,
+  listAgentFilesOf,
   splitAgentsByProvenance
-} from "../chunk-JU4ZGJ7A.js";
+} from "../chunk-GE3WKJ6Q.js";
 import "../chunk-JFLVEFFP.js";
+import {
+  providerFlag,
+  providerNamedBy,
+  refuseAnAmbiguousInstallation
+} from "../chunk-NBXXFIIW.js";
 import {
   BaseCommand,
   EXIT_CODES
-} from "../chunk-JIERYE6B.js";
-import "../chunk-NKGYKOB7.js";
-import "../chunk-PHCPUQVR.js";
+} from "../chunk-Y3VIRVVE.js";
+import "../chunk-VAPTVR3J.js";
+import "../chunk-RZDXDMT6.js";
 import {
   ConfigLoadError,
   INFO_MESSAGES,
   SUCCESS_MESSAGES,
   UNINSTALL_PLAN,
+  agentCodec,
   buildMarketplacePluginRef,
-  claudePluginUninstallBestEffort,
   compiledAgentsRemoval,
   directoryExists,
   fileExists,
   getErrorMessage,
   getProjectPluginsDir,
-  isClaudeCLIAvailable,
+  hostAt,
   isHomeDirectory,
   listDirectories,
   listPluginNames,
-  loadProjectConfigFromDir,
+  loadProjectConfigAt,
   loadSkillsMatrixFromSource,
   localSkillsRemoval,
   notInstalledHere,
   parseMarketplacePluginRef,
+  providerInUse,
   readForkedFromMetadata,
   registeredProjectUpdateSkipped,
   registeredProjectsUpdateFailed,
@@ -54,17 +61,19 @@ import {
   remove,
   removeDirIfEmpty,
   resolveInstallPaths,
-  toClaudePluginScope,
+  sourceFolderInUse,
+  sourceRootOf,
+  uninstallConfigUnreadable,
+  uninstallNeedsTerminal,
   unmarkedAgentsKept
-} from "../chunk-XPDVAJDH.js";
-import "../chunk-AVK2HEKB.js";
+} from "../chunk-A4KDXNOT.js";
+import "../chunk-V5WXIM2F.js";
 import {
   CLAUDE_DIR,
-  CLAUDE_SRC_DIR,
   DEFAULT_BRANDING,
   EJECT_SOURCE,
   STANDARD_FILES
-} from "../chunk-UITEKY2R.js";
+} from "../chunk-ENGYJCTF.js";
 import "../chunk-OI2H6M5I.js";
 
 // src/cli/commands/uninstall.tsx
@@ -80,7 +89,7 @@ function buildRemovalPlan(target) {
       ...pluginsEntry(target),
       ...localSkillsEntry(target),
       ...agents,
-      ...configManifestEntry(target)
+      ...configManifestEntries(target)
     ],
     kept: keptStatements(target, agents)
   };
@@ -100,19 +109,16 @@ function compiledAgentsEntry(target) {
   if (!target.hasLocalAgents) return [];
   const agentNames = identifiableAgents(target);
   if (agentNames.length === 0) return [];
-  return [{ kind: "agents", agentsDir: target.agentsDir, agentNames }];
+  return [{ kind: "agents", agentsDir: target.agentsDir, agentNames, codec: target.agentCodec }];
 }
 function identifiableAgents(target) {
   if (target.configuredAgents.length > 0) return target.configuredAgents;
   return target.markedAgents;
 }
-function configManifestEntry(target) {
-  const fileNames = [
-    ...target.hasClaudeSrcConfig ? [STANDARD_FILES.CONFIG_TS] : [],
-    ...target.hasClaudeSrcConfigTypes ? [STANDARD_FILES.CONFIG_TYPES_TS] : []
-  ];
-  if (fileNames.length === 0) return [];
-  return [{ kind: "config", claudeSrcDir: target.claudeSrcDir, fileNames }];
+function configManifestEntries(target) {
+  const { dir, manifestFiles } = target.sourceFolder;
+  if (manifestFiles.length === 0) return [];
+  return [{ kind: "config", sourceDir: dir, fileNames: manifestFiles }];
 }
 function keptStatements(target, agentRemovals) {
   const removing = new Set(agentRemovals.flatMap((entry) => entry.agentNames));
@@ -120,6 +126,11 @@ function keptStatements(target, agentRemovals) {
   if (kept.length === 0) return [];
   return [unmarkedAgentsKept(target.agentsDir, kept.length)];
 }
+function planEntries(plan, kind) {
+  return plan.entries.filter(
+    (entry) => entry.kind === kind
+  );
+}
 function planEntry(plan, kind) {
   return plan.entries.find(
     (entry) => entry.kind === kind
@@ -142,7 +153,7 @@ function describeEntry(entry) {
     case "config":
       return {
         label: UNINSTALL_PLAN.CONFIG_HEADING,
-        items: entry.fileNames.map((fileName) => `${entry.claudeSrcDir}/${fileName}`)
+        items: entry.fileNames.map((fileName) => `${entry.sourceDir}/${fileName}`)
       };
     default: {
       const _exhaustive = entry;
@@ -183,7 +194,7 @@ var Uninstall = class _Uninstall extends BaseCommand {
    */
   brandingName = DEFAULT_BRANDING.NAME;
   static summary = `Remove ${DEFAULT_BRANDING.NAME} from this project`;
-  static description = `Uninstall ${DEFAULT_BRANDING.NAME} from this project. Removes CLI-managed skills (matched by marketplace), compiled agents, plugins, and the .claude-src/ config manifest (config.ts + config-types.ts). User-created content is preserved.`;
+  static description = `Uninstall ${DEFAULT_BRANDING.NAME} from this project. Removes CLI-managed skills (matched by marketplace), compiled agents, plugins, and the config manifest (config.ts + config-types.ts) this project keeps. User-created content is preserved.`;
   static examples = [
     "<%= config.bin %> <%= command.id %>",
     "<%= config.bin %> <%= command.id %> --yes"
@@ -193,18 +204,30 @@ var Uninstall = class _Uninstall extends BaseCommand {
       char: "y",
       description: "Skip confirmation prompt",
       default: false
-    })
+    }),
+    provider: providerFlag()
   };
+  /**
+   * Starts at any terminal size. The size gate exists for the wizard's layout, and this command
+   * draws none — a plan and a one-line confirm fit any terminal — while it is the way out of every
+   * state, so a window too small to hold a wizard must not hold up an uninstall.
+   */
+  async ensureTerminalSize() {
+  }
   async run() {
     const { flags } = await this.parse(_Uninstall);
     const projectDir = process.cwd();
+    await refuseAnAmbiguousInstallation(
+      projectDir,
+      "uninstall",
+      providerNamedBy(flags.provider),
+      (message) => this.error(message, { exit: EXIT_CODES.INVALID_ARGS })
+    );
     this.brandingName = await this.resolveBrandingName(projectDir);
     this.printHeader();
     const target = await detectUninstallTarget(
       projectDir,
-      (reason) => this.warn(
-        `Could not read the project config \u2014 plugins and compiled agents it lists may be left behind: ${reason}`
-      )
+      (failure) => this.warn(uninstallConfigUnreadable(failure))
     );
     const plan = buildRemovalPlan(target);
     if (!hasAnythingToRemove(plan)) {
@@ -249,6 +272,9 @@ var Uninstall = class _Uninstall extends BaseCommand {
     return true;
   }
   async confirmRemoval(plan) {
+    if (!process.stdin.isTTY) {
+      this.error(uninstallNeedsTerminal(), { exit: EXIT_CODES.ERROR });
+    }
     const outcome = await promptConfirm(({ onConfirm, onCancel }) => /* @__PURE__ */ jsx(
       RemovalPlanConfirm,
       {
@@ -289,7 +315,7 @@ var Uninstall = class _Uninstall extends BaseCommand {
   /**
    * Loads what updating registered projects needs (global config with its
    * projects[] registry, skills matrix, agent definitions) BEFORE the global
-   * .claude-src manifest is deleted — source resolution reads that config.
+   * the config manifest is deleted — source resolution reads that config.
    * Returns null when nothing is registered or loading fails; a load failure
    * warns and never aborts the uninstall.
    *
@@ -302,20 +328,30 @@ var Uninstall = class _Uninstall extends BaseCommand {
    * local-installer.test.ts). Skipping avoids fetching every registered extra
    * source (network on a cold cache, plus unreachable-remote warnings) during
    * an uninstall that must never hang or noise-fail on remote state.
+   *
+   * `purpose: "upkeep"` because the prune only rewrites projects that are already installed: a
+   * marketplace that has since lost its manifest must not leave every registered project naming
+   * the global content this uninstall deletes.
    */
   async prepareGlobalPropagation(target, projectDir) {
+    if (target.config === null || target.registeredProjects.length === 0) return null;
     const globalConfig = target.config;
-    if (!globalConfig?.projects?.length) return null;
     try {
       const [sourceResult, agentDefs] = await Promise.all([
         loadSkillsMatrixFromSource({
           projectDir,
+          purpose: "upkeep",
           skipExtraSources: true,
           matrixOnly: true
         }),
         loadAgentDefs()
       ]);
-      return { globalConfig, matrix: sourceResult.matrix, agents: agentDefs.agents };
+      return {
+        globalConfig,
+        matrix: sourceResult.matrix,
+        agents: agentDefs.agents,
+        provider: providerInUse(projectDir)
+      };
     } catch (error) {
       this.warn(registeredProjectsUpdateFailed(getErrorMessage(error)));
       return null;
@@ -331,15 +367,18 @@ var Uninstall = class _Uninstall extends BaseCommand {
    */
   async updateRegisteredProjects(propagation) {
     try {
-      const report = await propagateGlobalRemoval(propagation.globalConfig, {
-        matrix: propagation.matrix,
-        agents: propagation.agents
-      });
-      for (const skippedPath of report.propagated.skipped) {
+      const report = await propagateGlobalRemoval(
+        propagation.globalConfig,
+        { matrix: propagation.matrix, agents: propagation.agents },
+        propagation.provider
+      );
+      const { updated, unreadable, failed } = report.propagated;
+      this.reportProjectsOutOfReach(report.propagated);
+      for (const skippedPath of [...unreadable, ...failed]) {
         this.warn(registeredProjectUpdateSkipped(skippedPath));
       }
-      if (report.propagated.updated.length === 0) return;
-      this.logSuccess(registeredProjectsUpdated(report.propagated.updated.length));
+      if (updated.length === 0) return;
+      this.logSuccess(registeredProjectsUpdated(updated.length));
       this.reportPropagatedRecompile(report);
     } catch (error) {
       this.warn(registeredProjectsUpdateFailed(getErrorMessage(error)));
@@ -362,18 +401,35 @@ var Uninstall = class _Uninstall extends BaseCommand {
     for (const statement of plan.kept) {
       this.log(statement);
     }
-    const cleanup = await cleanupEmptyDirs(target, planEntry(plan, "config"));
-    if (cleanup.claudeSrcDirRemoved) {
-      this.logSuccess(`Removed ${CLAUDE_SRC_DIR}/`);
-    } else if (cleanup.claudeSrcManifestRemoved) {
-      this.logSuccess(`Removed CLI config from ${CLAUDE_SRC_DIR}/`);
-    }
+    const cleanup = await cleanupEmptyDirs(target, planEntries(plan, "config"));
+    this.reportSourceFolderCleanup(cleanup.sourceFolder);
+    this.reportSourceRootCleanup(target.sourceRoot, cleanup);
     if (cleanup.claudeDirRemoved) {
       this.logSuccess(`Removed ${CLAUDE_DIR}/`);
     } else if (cleanup.claudeDirKept) {
       this.log(`Kept ${CLAUDE_DIR}/ (contains user content)`);
     }
   }
+  /** What became of one source folder: gone, emptied of the CLI's files, or kept for the user's. */
+  reportSourceFolderCleanup(folder) {
+    if (folder.dirRemoved) {
+      this.logSuccess(`Removed ${folder.relName}/`);
+    } else if (folder.manifestRemoved) {
+      this.logSuccess(`Removed CLI config from ${folder.relName}/`);
+    } else if (folder.kept) {
+      this.log(`Kept ${folder.relName}/ (contains user content)`);
+    }
+  }
+  /** What became of the `.agents-inc/` parent, said out loud in both directions. */
+  reportSourceRootCleanup(sourceRoot, cleanup) {
+    if (cleanup.sourceRootRemoved) {
+      this.logSuccess(`Removed ${sourceRoot.relName}/`);
+      return;
+    }
+    if (cleanup.sourceRootKept) {
+      this.log(`Kept ${sourceRoot.relName}/ (contains user content)`);
+    }
+  }
   async removePlannedPlugins(entry, config, projectDir) {
     if (!entry) return;
     this.log("Uninstalling plugins...");
@@ -384,9 +440,11 @@ var Uninstall = class _Uninstall extends BaseCommand {
         projectDir,
         (name) => this.log(`  Uninstalled plugin '${name}'`)
       );
-      this.logSuccess(
-        `Uninstalled ${pluginResult.totalUninstalled} ${pluginResult.totalUninstalled === 1 ? "plugin" : "plugins"}`
-      );
+      if (pluginResult.totalUninstalled > 0) {
+        this.logSuccess(
+          `Uninstalled ${pluginResult.totalUninstalled} ${pluginResult.totalUninstalled === 1 ? "plugin" : "plugins"}`
+        );
+      }
     } catch (error) {
       this.log("Plugin uninstall failed");
       this.error(getErrorMessage(error), {
@@ -435,53 +493,69 @@ function getCliInstalledPluginKeys(config) {
     ])
   );
 }
-async function loadUninstallConfig(projectDir, onLoadFailed) {
+async function loadUninstallConfig(configPath, projectDir, provider, onLoadFailed) {
   try {
-    const result = await loadProjectConfigFromDir(projectDir);
+    const result = await loadProjectConfigAt(configPath, projectDir, provider);
     return result?.config ?? null;
   } catch (error) {
     if (!(error instanceof ConfigLoadError)) throw error;
-    onLoadFailed(getErrorMessage(error));
+    onLoadFailed(error);
     return null;
   }
 }
+async function readSourceFolder(folder, projectDir, provider, onConfigLoadFailed) {
+  const [manifestFiles, config] = await Promise.all([
+    manifestFilesIn(folder.dir),
+    loadUninstallConfig(
+      path.join(folder.dir, STANDARD_FILES.CONFIG_TS),
+      projectDir,
+      provider,
+      onConfigLoadFailed
+    )
+  ]);
+  return { ...folder, manifestFiles, config };
+}
+async function manifestFilesIn(dir) {
+  const manifest = [STANDARD_FILES.CONFIG_TS, STANDARD_FILES.CONFIG_TYPES_TS];
+  const present = await Promise.all(
+    manifest.map((fileName) => fileExists(path.join(dir, fileName)))
+  );
+  return manifest.filter((_, index) => present[index]);
+}
+function activeConfigOf(config) {
+  return {
+    ...config,
+    skills: config.skills.filter((s) => !s.excluded),
+    agents: config.agents.filter((a) => !a.excluded)
+  };
+}
 async function detectUninstallTarget(projectDir, onConfigLoadFailed) {
   const pluginsDir = getProjectPluginsDir(projectDir);
   const { skillsDir, agentsDir } = resolveInstallPaths(projectDir);
   const claudeDir = path.join(projectDir, CLAUDE_DIR);
-  const claudeSrcDir = path.join(projectDir, CLAUDE_SRC_DIR);
-  const claudeSrcConfigPath = path.join(claudeSrcDir, STANDARD_FILES.CONFIG_TS);
-  const claudeSrcConfigTypesPath = path.join(claudeSrcDir, STANDARD_FILES.CONFIG_TYPES_TS);
-  const [
-    hasLocalSkills,
-    hasLocalAgents,
-    hasClaudeDir,
-    hasClaudeSrcConfig,
-    hasClaudeSrcConfigTypes,
-    config,
-    agentProvenance
-  ] = await Promise.all([
+  const provider = providerInUse(projectDir);
+  const [hasLocalSkills, hasLocalAgents, hasClaudeDir, sourceFolder, agentProvenance] = await Promise.all([
     directoryExists(skillsDir),
     directoryExists(agentsDir),
     directoryExists(claudeDir),
-    fileExists(claudeSrcConfigPath),
-    fileExists(claudeSrcConfigTypesPath),
-    loadUninstallConfig(projectDir, onConfigLoadFailed),
-    splitAgentsByProvenance(agentsDir)
+    readSourceFolder(
+      sourceFolderInUse(projectDir, provider),
+      projectDir,
+      provider,
+      onConfigLoadFailed
+    ),
+    splitAgentsByProvenance(agentsDir, agentCodec(provider))
   ]);
+  const { config } = sourceFolder;
   let pluginNames = [];
   try {
     pluginNames = await listPluginNames(projectDir);
   } catch {
   }
-  const activeConfig = config ? {
-    ...config,
-    skills: config.skills.filter((s) => !s.excluded),
-    agents: config.agents.filter((a) => !a.excluded)
-  } : null;
+  const activeConfig = config === null ? null : activeConfigOf(config);
   const configuredAgents = collectConfiguredAgents(activeConfig);
   const cliInstalledKeys = getCliInstalledPluginKeys(activeConfig);
-  const cliPluginNames = pluginNames.filter((name) => cliInstalledKeys.has(name));
+  const cliPluginNames = thisRunOwnsAnyPlugin(projectDir) ? pluginNames.filter((name) => cliInstalledKeys.has(name)) : [];
   return {
     hasPlugins: cliPluginNames.length > 0,
     pluginNames,
@@ -489,19 +563,24 @@ async function detectUninstallTarget(projectDir, onConfigLoadFailed) {
     hasLocalSkills,
     hasLocalAgents,
     hasClaudeDir,
-    hasClaudeSrcConfig,
-    hasClaudeSrcConfigTypes,
     pluginsDir,
     skillsDir,
     agentsDir,
     claudeDir,
-    claudeSrcDir,
+    sourceFolder,
+    sourceRoot: sourceRootOf(projectDir),
     config,
+    registeredProjects: config?.projects ?? [],
     configuredAgents,
+    agentCodec: agentCodec(provider),
     markedAgents: agentProvenance.marked,
     unmarkedAgents: agentProvenance.unmarked
   };
 }
+function thisRunOwnsAnyPlugin(projectDir) {
+  if (isHomeDirectory(projectDir)) return true;
+  return hostAt(projectDir).installsProjectScopedPlugins;
+}
 function shouldRemoveSkill(forkedFrom) {
   return forkedFrom !== null;
 }
@@ -545,10 +624,10 @@ async function cleanupSkillsDir(dir, allRemoved) {
   return removeDirIfEmpty(dir);
 }
 async function removeMatchingAgents(entry, onRemoved) {
-  const agentFiles = await listAgentFiles(entry.agentsDir);
-  const removedNames = agentFiles.map((agentFile) => agentFile.replace(/\.md$/, "")).filter((agentName) => entry.agentNames.includes(agentName));
+  const agentFiles = await listAgentFiles(entry.agentsDir, entry.codec);
+  const removedNames = agentFiles.map((agentFile) => path.basename(agentFile, entry.codec.extension)).filter((agentName) => entry.agentNames.includes(agentName));
   for (const agentName of removedNames) {
-    await remove(path.join(entry.agentsDir, `${agentName}.md`));
+    await remove(path.join(entry.agentsDir, `${agentName}${entry.codec.extension}`));
     onRemoved?.(agentName);
   }
   const dirCleaned = await removeDirIfEmpty(entry.agentsDir);
@@ -558,45 +637,94 @@ async function removeMatchingAgents(entry, onRemoved) {
     dirCleaned
   };
 }
+var SCOPE_OF_AN_UNRECORDED_SKILL = "project";
+function pluginScopesToSweep(host, primary) {
+  const offered = host.offeredPlacements.filter((placement) => placement.mode === "plugin").map((placement) => placement.scope);
+  if (!offered.includes(primary)) return offered;
+  return [primary, ...offered.filter((scope) => scope !== primary)];
+}
+async function removePluginWhereverItIsFiled(host, pluginRef, primaryScope, projectDir) {
+  let outcome = "absent";
+  for (const scope of pluginScopesToSweep(host, primaryScope)) {
+    try {
+      const swept = await host.uninstallPlugin(pluginRef, scope, projectDir);
+      if (swept === "removed") outcome = "removed";
+    } catch {
+    }
+  }
+  return outcome;
+}
 async function uninstallPlugins(entry, config, projectDir, onUninstalled) {
-  const cliAvailable = await isClaudeCLIAvailable();
+  const host = hostAt(projectDir);
+  const hostAvailable = await host.isAvailable();
+  const observed = [];
   for (const pluginName of entry.names) {
-    if (cliAvailable) {
-      const skillId = parseMarketplacePluginRef(pluginName);
-      const skillConfig = config?.skills.find((s) => s.id === skillId);
-      const primaryScope = toClaudePluginScope(skillConfig?.scope);
-      await claudePluginUninstallBestEffort(pluginName, primaryScope, projectDir);
+    const removal = hostAvailable ? await removePluginWhereverItIsFiled(
+      host,
+      pluginName,
+      scopeThePluginIsFiledUnder(config, pluginName),
+      projectDir
+    ) : nothingWasObserved();
+    await remove(path.join(entry.pluginsDir, pluginName));
+    if (removal === "removed") {
+      observed.push(pluginName);
+      onUninstalled?.(pluginName);
     }
-    const pluginPath = path.join(entry.pluginsDir, pluginName);
-    await remove(pluginPath);
-    onUninstalled?.(pluginName);
   }
   return {
-    uninstalledNames: entry.names,
-    totalUninstalled: entry.names.length
+    uninstalledNames: observed,
+    totalUninstalled: observed.length
   };
 }
+function scopeThePluginIsFiledUnder(config, pluginName) {
+  const skillId = parseMarketplacePluginRef(pluginName);
+  return config?.skills.find((skill) => skill.id === skillId)?.scope ?? SCOPE_OF_AN_UNRECORDED_SKILL;
+}
+function nothingWasObserved() {
+  return "absent";
+}
 async function removeConfigManifest(entry) {
   if (!entry) return { manifestRemoved: false, dirRemoved: false };
   await Promise.all(
-    entry.fileNames.map((fileName) => remove(path.join(entry.claudeSrcDir, fileName)))
+    entry.fileNames.map((fileName) => remove(path.join(entry.sourceDir, fileName)))
   );
-  return { manifestRemoved: true, dirRemoved: await removeDirIfEmpty(entry.claudeSrcDir) };
+  return { manifestRemoved: true, dirRemoved: await removeDirIfEmpty(entry.sourceDir) };
 }
-async function cleanupEmptyDirs(target, manifestEntry) {
-  const manifest = await removeConfigManifest(manifestEntry);
+async function cleanupEmptyDirs(target, manifestEntries) {
+  const sourceFolder = await cleanupSourceFolder(
+    target.sourceFolder,
+    manifestEntries.find((entry) => entry.sourceDir === target.sourceFolder.dir)
+  );
+  const sourceRoot = await cleanupSourceRoot(target.sourceRoot, sourceFolder.dirRemoved);
   const claudeDirRemoved = target.hasClaudeDir && await removeDirIfEmpty(target.claudeDir);
   const claudeDirKept = !claudeDirRemoved && target.hasClaudeDir && await directoryExists(target.claudeDir);
   return {
     claudeDirRemoved,
-    claudeSrcManifestRemoved: manifest.manifestRemoved,
-    claudeSrcDirRemoved: manifest.dirRemoved,
+    sourceFolder,
+    sourceRootRemoved: sourceRoot.removed,
+    sourceRootKept: sourceRoot.kept,
     claudeDirKept
   };
 }
-async function listAgentFiles(agentsDir) {
+async function cleanupSourceFolder(folder, entry) {
+  const manifest = await removeConfigManifest(entry);
+  const dirRemoved = manifest.dirRemoved || await removeDirIfEmpty(folder.dir);
+  const kept = !dirRemoved && await directoryExists(folder.dir);
+  return {
+    relName: folder.relName,
+    manifestRemoved: manifest.manifestRemoved,
+    dirRemoved,
+    kept
+  };
+}
+async function cleanupSourceRoot(sourceRoot, providerDirRemoved) {
+  if (!providerDirRemoved) return { removed: false, kept: false };
+  const removed = await removeDirIfEmpty(sourceRoot.dir);
+  return { removed, kept: !removed && await directoryExists(sourceRoot.dir) };
+}
+async function listAgentFiles(agentsDir, codec) {
   try {
-    return await listAgentMdFiles(agentsDir);
+    return await listAgentFilesOf(agentsDir, codec);
   } catch {
     return [];
   }