agentloom 0.1.0 → 0.1.2

package/dist/core/importer.js

@@ -1,90 +1,491 @@
 import fs from "node:fs";
 import path from "node:path";
-import { cancel, isCancel, select, text as promptText } from "@clack/prompts";
+import { cancel, isCancel, multiselect, select, text as promptText, } from "@clack/prompts";
 import { buildAgentMarkdown, parseAgentsDir, targetFileNameForAgent, } from "./agents.js";
+import { normalizeCommandSelector, parseCommandsDir, resolveCommandSelections, } from "./commands.js";
+import { applySkillProviderSideEffects, copySkillArtifacts, normalizeSkillSelector, parseSkillsDir, resolveSkillSelections, skillContentMatchesTarget, } from "./skills.js";
 import { ensureDir, hashContent, readJsonIfExists, relativePosix, slugify, writeTextAtomic, } from "./fs.js";
+import { ALL_PROVIDERS } from "../types.js";
 import { readLockfile, upsertLockEntry, writeLockfile } from "./lockfile.js";
 import { readCanonicalMcp, writeCanonicalMcp } from "./mcp.js";
-import { discoverSourceAgentsDir, discoverSourceMcpPath, prepareSource, } from "./sources.js";
+import { discoverSourceAgentsDir, discoverSourceCommandsDir, discoverSourceMcpPath, discoverSourceSkillsDir, prepareSource, } from "./sources.js";
 export class NonInteractiveConflictError extends Error {
     constructor(message) {
         super(message);
         this.name = "NonInteractiveConflictError";
     }
 }
+const MULTISELECT_HELP_TEXT = "↑↓ move, space select, enter confirm";
+function withMultiselectHelp(message) {
+    return `${message}\n${MULTISELECT_HELP_TEXT}`;
+}
 export async function importSource(options) {
+    const shouldImportAgents = options.importAgents ?? true;
+    const requireAgents = options.requireAgents ?? shouldImportAgents;
+    const shouldImportCommands = options.importCommands ?? true;
+    const shouldImportMcp = options.importMcp ?? true;
+    const shouldImportSkills = options.importSkills ?? false;
+    if (!shouldImportAgents &&
+        !shouldImportCommands &&
+        !shouldImportMcp &&
+        !shouldImportSkills) {
+        throw new Error("No import targets selected.");
+    }
     const prepared = prepareSource({
         source: options.source,
         ref: options.ref,
         subdir: options.subdir,
     });
+    const normalizedSubdir = options.subdir?.replace(/^\/+|\/+$/g, "");
+    const sourceLocation = prepared.spec.type === "github"
+        ? `https://github.com/${prepared.spec.source}/tree/${prepared.resolvedCommit}${normalizedSubdir ? `/${normalizedSubdir}` : ""}`
+        : options.subdir
+            ? `${options.source} (subdir: ${options.subdir})`
+            : options.source;
     try {
-        const sourceAgentsDir = discoverSourceAgentsDir(prepared.importRoot);
-        const sourceMcpPath = discoverSourceMcpPath(prepared.importRoot);
-        const sourceAgents = parseAgentsDir(sourceAgentsDir);
-        if (sourceAgents.length === 0) {
+        const sourceAgentsDir = shouldImportAgents
+            ? discoverSourceAgentsDir(prepared.importRoot)
+            : null;
+        const sourceCommandsDir = shouldImportCommands
+            ? discoverSourceCommandsDir(prepared.importRoot)
+            : null;
+        const sourceMcpPath = shouldImportMcp
+            ? discoverSourceMcpPath(prepared.importRoot)
+            : null;
+        const sourceSkillsDir = shouldImportSkills
+            ? discoverSourceSkillsDir(prepared.importRoot)
+            : null;
+        const sourceAgents = sourceAgentsDir ? parseAgentsDir(sourceAgentsDir) : [];
+        const sourceCommands = sourceCommandsDir
+            ? parseCommandsDir(sourceCommandsDir)
+            : [];
+        const sourceMcp = sourceMcpPath
+            ? normalizeMcp(readJsonIfExists(sourceMcpPath))
+            : null;
+        const sourceSkills = sourceSkillsDir ? parseSkillsDir(sourceSkillsDir) : [];
+        const hasExplicitCommandSelection = (options.commandSelectors?.length ?? 0) > 0;
+        const isAggregateImport = shouldImportAgents &&
+            shouldImportCommands &&
+            shouldImportMcp &&
+            shouldImportSkills;
+        if (shouldImportAgents && requireAgents && !sourceAgentsDir) {
+            throw new Error(`No source agents directory found under ${prepared.importRoot} (expected agents/ or .agents/agents/).`);
+        }
+        if (shouldImportAgents && requireAgents && sourceAgents.length === 0) {
             throw new Error(`No agent files found in ${sourceAgentsDir}.`);
         }
-        ensureDir(options.paths.agentsDir);
-        const importedAgents = [];
-        const importedAgentHashes = [];
-        for (const [index, agent] of sourceAgents.entries()) {
-            let targetFileName = targetFileNameForAgent(agent);
-            if (options.rename && sourceAgents.length === 1) {
-                targetFileName = `${slugify(options.rename) || "agent"}.md`;
-            }
-            const resolvedFileName = await resolveAgentConflict({
-                targetFileName,
-                agentContent: buildAgentMarkdown(agent.frontmatter, agent.body),
-                paths: options.paths,
+        if (shouldImportCommands && options.requireCommands && !sourceCommandsDir) {
+            throw new Error(`No source commands directory found under ${prepared.importRoot} (expected .agents/commands/, commands/, or prompts/).`);
+        }
+        if (shouldImportCommands &&
+            options.requireCommands &&
+            sourceCommands.length === 0) {
+            throw new Error(`No command files found in ${sourceCommandsDir}.`);
+        }
+        if (shouldImportMcp && options.requireMcp && !sourceMcpPath) {
+            throw new Error(`No source mcp.json found under ${prepared.importRoot} (expected mcp.json or .agents/mcp.json).`);
+        }
+        if (shouldImportSkills && options.requireSkills && !sourceSkillsDir) {
+            throw new Error(`No source skills directory found under ${prepared.importRoot} (expected .agents/skills/, skills/, or root SKILL.md).`);
+        }
+        if (shouldImportSkills &&
+            options.requireSkills &&
+            sourceSkills.length === 0) {
+            throw new Error(`No skills found in ${sourceSkillsDir}.`);
+        }
+        if (isAggregateImport &&
+            sourceAgents.length === 0 &&
+            sourceCommands.length === 0 &&
+            sourceSkills.length === 0 &&
+            Object.keys(sourceMcp?.mcpServers ?? {}).length === 0) {
+            throw new Error(`No importable entities found in source "${sourceLocation}".\nExpected agents/, .agents/agents/, commands/, .agents/commands/, prompts/, mcp.json/.agents/mcp.json, skills/, .agents/skills/, or root SKILL.md.`);
+        }
+        const shouldResolveAgents = shouldImportAgents &&
+            (sourceAgents.length > 0 ||
+                (options.agents?.length ?? 0) > 0 ||
+                requireAgents);
+        const selection = shouldResolveAgents
+            ? await resolveAgentsToImport({
+                sourceAgents,
+                requestedAgents: options.agents,
                 yes: !!options.yes,
                 nonInteractive: !!options.nonInteractive,
-                promptLabel: `${agent.name} (${index + 1}/${sourceAgents.length})`,
+                promptForAgentSelection: options.promptForAgentSelection ?? true,
+                selectionMode: options.selectionMode,
+            })
+            : { selectedAgents: [] };
+        let selectedSourceCommands = [];
+        let selectedSourceCommandFiles = [];
+        let commandSelectionMode = "all";
+        if (shouldImportCommands && sourceCommandsDir) {
+            const commandSelection = await resolveCommandsToImport({
+                sourceCommands,
+                selectors: options.commandSelectors ?? [],
+                promptForCommands: Boolean(options.promptForCommands),
+                nonInteractive: Boolean(options.nonInteractive),
+                selectionMode: options.selectionMode,
             });
-            if (!resolvedFileName)
-                continue;
-            const targetPath = path.join(options.paths.agentsDir, resolvedFileName);
-            const content = buildAgentMarkdown(agent.frontmatter, agent.body);
-            writeTextAtomic(targetPath, content);
-            importedAgents.push(relativePosix(options.paths.agentsRoot, targetPath));
-            importedAgentHashes.push(hashContent(content));
+            selectedSourceCommands = commandSelection.selectedCommands;
+            commandSelectionMode = commandSelection.selectionMode;
+            selectedSourceCommandFiles = selectedSourceCommands.map((command) => command.fileName);
         }
-        const importedMcpServers = [];
-        if (sourceMcpPath) {
-            const sourceMcp = normalizeMcp(readJsonIfExists(sourceMcpPath));
-            const targetMcp = readCanonicalMcp(options.paths);
-            const merged = await resolveMcpConflict({
+        let selectedSourceMcpServers = [];
+        let sourceMcpServerNames = sourceMcp
+            ? Object.keys(sourceMcp.mcpServers).sort()
+            : [];
+        let mcpSelectionMode = "all";
+        if (shouldImportMcp && sourceMcp) {
+            const mcpSelection = await resolveMcpServersToImport({
                 sourceMcp,
-                targetMcp,
-                yes: !!options.yes,
-                nonInteractive: !!options.nonInteractive,
+                selectors: options.mcpSelectors ?? [],
+                promptForMcp: options.promptForMcp ?? true,
+                nonInteractive: Boolean(options.nonInteractive),
+                selectionMode: options.selectionMode,
+            });
+            selectedSourceMcpServers = mcpSelection.selectedServerNames;
+            mcpSelectionMode = mcpSelection.selectionMode;
+        }
+        let selectedSkills = [];
+        let selectedSourceSkills = [];
+        let skillSelectionMode = "all";
+        if (shouldImportSkills && sourceSkillsDir) {
+            const skillSelection = await resolveSkillsToImport({
+                sourceSkills,
+                selectors: options.skillSelectors ?? [],
+                promptForSkills: options.promptForSkills ?? true,
+                nonInteractive: Boolean(options.nonInteractive),
+                selectionMode: options.selectionMode,
             });
-            writeCanonicalMcp(options.paths, merged);
-            importedMcpServers.push(...Object.keys(sourceMcp.mcpServers));
+            selectedSkills = skillSelection.selectedSkills;
+            skillSelectionMode = skillSelection.selectionMode;
+            selectedSourceSkills = selectedSkills.map((skill) => skill.name);
         }
+        const importedAgents = [];
+        if (shouldImportAgents && selection.selectedAgents.length > 0) {
+            ensureDir(options.paths.agentsDir);
+            for (const [index, agent] of selection.selectedAgents.entries()) {
+                let targetFileName = targetFileNameForAgent(agent);
+                if (options.rename &&
+                    selection.selectedAgents.length === 1 &&
+                    !(shouldImportCommands && hasExplicitCommandSelection)) {
+                    targetFileName = `${slugify(options.rename) || "agent"}.md`;
+                }
+                const resolvedFileName = await resolveAgentConflict({
+                    targetFileName,
+                    agentContent: buildAgentMarkdown(agent.frontmatter, agent.body),
+                    paths: options.paths,
+                    yes: !!options.yes,
+                    nonInteractive: !!options.nonInteractive,
+                    promptLabel: `${agent.name} (${index + 1}/${selection.selectedAgents.length})`,
+                });
+                if (!resolvedFileName)
+                    continue;
+                const targetPath = path.join(options.paths.agentsDir, resolvedFileName);
+                const content = buildAgentMarkdown(agent.frontmatter, agent.body);
+                writeTextAtomic(targetPath, content);
+                importedAgents.push(relativePosix(options.paths.agentsRoot, targetPath));
+            }
+        }
+        const importedCommands = [];
+        const importedCommandRenameMap = {};
+        if (shouldImportCommands && sourceCommandsDir) {
+            if (selectedSourceCommands.length > 0) {
+                ensureDir(options.paths.commandsDir);
+            }
+            for (const [index, command] of selectedSourceCommands.entries()) {
+                let targetFileName = command.fileName;
+                const mappedTargetFileName = resolveMappedTargetFileName(command.fileName, options.commandRenameMap);
+                if (mappedTargetFileName) {
+                    targetFileName = mappedTargetFileName;
+                }
+                else if (options.rename &&
+                    selectedSourceCommands.length === 1 &&
+                    (!shouldImportAgents || hasExplicitCommandSelection)) {
+                    targetFileName = `${slugify(options.rename) || "command"}.md`;
+                }
+                const resolvedFileName = await resolveCommandConflict({
+                    targetFileName,
+                    commandContent: command.content,
+                    paths: options.paths,
+                    yes: !!options.yes,
+                    nonInteractive: !!options.nonInteractive,
+                    promptLabel: `${command.fileName} (${index + 1}/${selectedSourceCommands.length})`,
+                });
+                if (!resolvedFileName)
+                    continue;
+                const targetPath = path.join(options.paths.commandsDir, resolvedFileName);
+                writeTextAtomic(targetPath, command.content);
+                importedCommands.push(relativePosix(options.paths.agentsRoot, targetPath));
+                importedCommandRenameMap[command.fileName] = resolvedFileName;
+            }
+        }
+        const importedMcpServers = [];
+        if (shouldImportMcp && sourceMcp) {
+            const selectedSourceMcp = {
+                version: 1,
+                mcpServers: Object.fromEntries(selectedSourceMcpServers.map((serverName) => [
+                    serverName,
+                    sourceMcp.mcpServers[serverName] ?? {},
+                ])),
+            };
+            if (selectedSourceMcpServers.length > 0) {
+                const targetMcp = readCanonicalMcp(options.paths);
+                const merged = await resolveMcpConflict({
+                    sourceMcp: selectedSourceMcp,
+                    targetMcp,
+                    yes: !!options.yes,
+                    nonInteractive: !!options.nonInteractive,
+                });
+                writeCanonicalMcp(options.paths, merged);
+            }
+            importedMcpServers.push(...selectedSourceMcpServers);
+        }
+        const importedSkills = [];
+        const telemetrySkills = [];
+        const importedSkillRenameMap = {};
+        let skillsProvidersForLock;
+        if (shouldImportSkills && sourceSkillsDir) {
+            if (selectedSkills.length > 0) {
+                ensureDir(options.paths.skillsDir);
+            }
+            for (const [index, sourceSkill] of selectedSkills.entries()) {
+                let targetSkillDirName = slugify(sourceSkill.name) || "skill";
+                const mappedTargetSkillDirName = resolveMappedTargetSkillName(sourceSkill.name, options.skillRenameMap);
+                if (mappedTargetSkillDirName) {
+                    targetSkillDirName = mappedTargetSkillDirName;
+                }
+                else if (options.rename &&
+                    selectedSkills.length === 1 &&
+                    importedAgents.length === 0 &&
+                    importedCommands.length === 0 &&
+                    importedMcpServers.length === 0) {
+                    targetSkillDirName = slugify(options.rename) || "skill";
+                }
+                const resolvedSkillDirName = await resolveSkillConflict({
+                    sourceSkill,
+                    targetSkillDirName,
+                    paths: options.paths,
+                    yes: !!options.yes,
+                    nonInteractive: !!options.nonInteractive,
+                    promptLabel: `${sourceSkill.name} (${index + 1}/${selectedSkills.length})`,
+                });
+                if (!resolvedSkillDirName)
+                    continue;
+                const targetSkillDir = path.join(options.paths.skillsDir, resolvedSkillDirName);
+                if (!skillContentMatchesTarget(sourceSkill, targetSkillDir)) {
+                    fs.rmSync(targetSkillDir, { recursive: true, force: true });
+                    copySkillArtifacts(sourceSkill, targetSkillDir);
+                }
+                importedSkills.push(resolvedSkillDirName);
+                telemetrySkills.push({
+                    name: sourceSkill.name,
+                    filePath: relativePosix(prepared.rootPath, sourceSkill.skillPath),
+                });
+                importedSkillRenameMap[sourceSkill.name] = resolvedSkillDirName;
+            }
+            if (importedSkills.length > 0) {
+                const resolvedSkillsProviders = normalizeSkillsProviders(options.skillsProviders && options.skillsProviders.length > 0
+                    ? options.skillsProviders
+                    : await options.resolveSkillsProviders?.());
+                if (resolvedSkillsProviders && resolvedSkillsProviders.length > 0) {
+                    applySkillProviderSideEffects({
+                        paths: options.paths,
+                        providers: resolvedSkillsProviders,
+                        warn(message) {
+                            console.warn(`Warning: ${message}`);
+                        },
+                    });
+                    skillsProvidersForLock = resolvedSkillsProviders;
+                }
+            }
+        }
+        const selectedSubsetOfSourceCommands = sourceCommands.length > 0 &&
+            selectedSourceCommandFiles.length < sourceCommands.length;
+        const selectedSubsetOfSourceMcp = sourceMcpServerNames.length > 0 &&
+            selectedSourceMcpServers.length < sourceMcpServerNames.length;
+        const selectedSubsetOfSourceSkills = sourceSkills.length > 0 &&
+            selectedSourceSkills.length < sourceSkills.length;
+        const shouldPersistCommandSelection = shouldImportCommands && commandSelectionMode === "custom";
+        const shouldPersistMcpSelection = shouldImportMcp && mcpSelectionMode === "custom";
+        const shouldPersistSkillSelection = shouldImportSkills && skillSelectionMode === "custom";
+        const selectedSourceCommandsForLock = shouldPersistCommandSelection || selectedSubsetOfSourceCommands
+            ? selectedSourceCommandFiles
+            : undefined;
+        const selectedSourceMcpServersForLock = shouldPersistMcpSelection || selectedSubsetOfSourceMcp
+            ? selectedSourceMcpServers
+            : undefined;
+        const selectedSourceSkillsForLock = shouldPersistSkillSelection || selectedSubsetOfSourceSkills
+            ? selectedSourceSkills
+            : undefined;
         const lockfile = readLockfile(options.paths);
+        const isCommandOnlyImport = !shouldImportAgents &&
+            shouldImportCommands &&
+            !shouldImportMcp &&
+            !shouldImportSkills;
+        const existingEntry = isCommandOnlyImport
+            ? findRelaxedCommandEntry(lockfile.entries, {
+                source: prepared.spec.source,
+                sourceType: prepared.spec.type,
+                subdir: options.subdir,
+                requestedAgents: options.agents,
+            })
+            : findMatchingLockEntry(lockfile.entries, {
+                source: prepared.spec.source,
+                sourceType: prepared.spec.type,
+                subdir: options.subdir,
+                requestedAgents: shouldImportAgents
+                    ? selection.requestedAgentsForLock
+                    : options.agents,
+                selectedSourceCommands: selectedSourceCommandsForLock,
+                selectedSourceMcpServers: selectedSourceMcpServersForLock,
+                selectedSourceSkills: selectedSourceSkillsForLock,
+                skillsProviders: skillsProvidersForLock,
+            });
+        const shouldMergeCommandOnlyEntry = isCommandOnlyImport &&
+            Boolean(existingEntry) &&
+            (existingEntry?.importedAgents.length ?? 0) === 0 &&
+            (existingEntry?.importedMcpServers.length ?? 0) === 0 &&
+            (existingEntry?.importedSkills.length ?? 0) === 0;
+        const lockImportedAgents = shouldImportAgents
+            ? importedAgents
+            : (existingEntry?.importedAgents ?? []);
+        const lockImportedCommands = shouldImportCommands
+            ? shouldMergeCommandOnlyEntry
+                ? uniqueStrings([
+                    ...(existingEntry?.importedCommands ?? []),
+                    ...importedCommands,
+                ])
+                : importedCommands
+            : (existingEntry?.importedCommands ?? []);
+        const lockImportedMcpServers = shouldImportMcp
+            ? importedMcpServers
+            : (existingEntry?.importedMcpServers ?? []);
+        const lockImportedSkills = shouldImportSkills
+            ? importedSkills
+            : (existingEntry?.importedSkills ?? []);
+        let lockSelectedSourceCommands;
+        if (shouldImportCommands) {
+            if (shouldMergeCommandOnlyEntry) {
+                if (shouldPersistCommandSelection || selectedSubsetOfSourceCommands) {
+                    lockSelectedSourceCommands = uniqueStrings([
+                        ...(existingEntry?.selectedSourceCommands ?? []),
+                        ...selectedSourceCommandFiles,
+                    ]);
+                }
+                else {
+                    lockSelectedSourceCommands = undefined;
+                }
+            }
+            else if (shouldPersistCommandSelection ||
+                selectedSubsetOfSourceCommands) {
+                lockSelectedSourceCommands = [...selectedSourceCommandFiles];
+            }
+            else {
+                lockSelectedSourceCommands = undefined;
+            }
+        }
+        else {
+            lockSelectedSourceCommands = existingEntry?.selectedSourceCommands;
+        }
+        const lockSelectedSourceMcpServers = shouldImportMcp
+            ? shouldPersistMcpSelection || selectedSubsetOfSourceMcp
+                ? [...selectedSourceMcpServers]
+                : undefined
+            : existingEntry?.selectedSourceMcpServers;
+        const lockSelectedSourceSkills = shouldImportSkills
+            ? shouldPersistSkillSelection || selectedSubsetOfSourceSkills
+                ? [...selectedSourceSkills]
+                : undefined
+            : existingEntry?.selectedSourceSkills;
+        const lockSkillsProviders = shouldImportSkills
+            ? (skillsProvidersForLock ?? existingEntry?.skillsProviders)
+            : existingEntry?.skillsProviders;
+        const lockSkillRenameMap = shouldImportSkills
+            ? normalizeSkillRenameMap(importedSkillRenameMap)
+            : existingEntry?.skillRenameMap;
+        let lockCommandRenameMap;
+        if (shouldImportCommands) {
+            if (shouldMergeCommandOnlyEntry) {
+                lockCommandRenameMap = mergeCommandRenameMaps(existingEntry?.commandRenameMap, importedCommandRenameMap);
+            }
+            else {
+                lockCommandRenameMap = normalizeCommandRenameMap(importedCommandRenameMap);
+            }
+        }
+        else {
+            lockCommandRenameMap = existingEntry?.commandRenameMap;
+        }
+        const lockRequestedAgents = shouldImportAgents
+            ? selection.requestedAgentsForLock
+            : existingEntry?.requestedAgents;
+        const trackedEntities = computeTrackedEntitiesForLock({
+            requestedAgents: lockRequestedAgents,
+            importedAgents: lockImportedAgents,
+            importedCommands: lockImportedCommands,
+            selectedSourceCommands: lockSelectedSourceCommands,
+            commandRenameMap: lockCommandRenameMap,
+            importedMcpServers: lockImportedMcpServers,
+            selectedSourceMcpServers: lockSelectedSourceMcpServers,
+            importedSkills: lockImportedSkills,
+            selectedSourceSkills: lockSelectedSourceSkills,
+            skillsProviders: lockSkillsProviders,
+            skillRenameMap: lockSkillRenameMap,
+        });
         const contentHash = hashContent(JSON.stringify({
-            agents: importedAgentHashes,
-            mcp: importedMcpServers,
+            agents: lockImportedAgents,
+            commands: lockImportedCommands,
+            selectedSourceCommands: lockSelectedSourceCommands ?? [],
+            commandRenameMap: lockCommandRenameMap ?? {},
+            mcp: lockImportedMcpServers,
+            selectedSourceMcpServers: lockSelectedSourceMcpServers ?? [],
+            skills: lockImportedSkills,
+            selectedSourceSkills: lockSelectedSourceSkills ?? [],
+            skillsProviders: lockSkillsProviders ?? [],
+            skillRenameMap: lockSkillRenameMap ?? {},
+            trackedEntities: trackedEntities ?? [],
         }));
         const lockEntry = {
             source: prepared.spec.source,
             sourceType: prepared.spec.type,
             requestedRef: options.ref,
+            requestedAgents: lockRequestedAgents,
             resolvedCommit: prepared.resolvedCommit,
             subdir: options.subdir,
             importedAt: new Date().toISOString(),
-            importedAgents,
-            importedMcpServers,
+            importedAgents: lockImportedAgents,
+            importedCommands: lockImportedCommands,
+            selectedSourceCommands: lockSelectedSourceCommands,
+            commandRenameMap: lockCommandRenameMap,
+            importedMcpServers: lockImportedMcpServers,
+            selectedSourceMcpServers: lockSelectedSourceMcpServers,
+            importedSkills: lockImportedSkills,
+            selectedSourceSkills: lockSelectedSourceSkills,
+            skillsProviders: lockSkillsProviders,
+            skillRenameMap: lockSkillRenameMap,
+            trackedEntities,
             contentHash,
         };
-        upsertLockEntry(lockfile, lockEntry);
+        if (existingEntry) {
+            const existingIndex = lockfile.entries.indexOf(existingEntry);
+            if (existingIndex >= 0) {
+                lockfile.entries[existingIndex] = lockEntry;
+            }
+            else {
+                upsertLockEntry(lockfile, lockEntry);
+            }
+        }
+        else {
+            upsertLockEntry(lockfile, lockEntry);
+        }
         writeLockfile(options.paths, lockfile);
         return {
             source: prepared.spec.source,
             sourceType: prepared.spec.type,
             importedAgents,
+            importedCommands,
             importedMcpServers,
+            importedSkills,
+            telemetrySkills: telemetrySkills.length > 0 ? telemetrySkills : undefined,
             resolvedCommit: prepared.resolvedCommit,
         };
     }
@@ -92,6 +493,364 @@ export async function importSource(options) {
         prepared.cleanup();
     }
 }
+async function resolveAgentsToImport(options) {
+    const requestedAgents = normalizeRequestedAgents(options.requestedAgents);
+    if (requestedAgents && requestedAgents.length > 0) {
+        const selected = resolveRequestedAgents(options.sourceAgents, requestedAgents);
+        if (selected.length === 0) {
+            throw new Error("No agents matched the requested --agent filters.");
+        }
+        return {
+            selectedAgents: selected,
+            // Persist stable selectors so updates keep targeting the same source agents
+            // even if a previously-fallback selector later gains a new exact match.
+            requestedAgentsForLock: getStableRequestedAgentsForLock({
+                selectedAgents: selected,
+                sourceAgents: options.sourceAgents,
+            }),
+        };
+    }
+    const selectionMode = await resolveSelectionMode({
+        entityLabel: "agents",
+        selectionMode: options.selectionMode,
+        promptForSelection: options.promptForAgentSelection,
+        nonInteractive: options.nonInteractive,
+    });
+    if (selectionMode === "all") {
+        return { selectedAgents: options.sourceAgents };
+    }
+    if (options.yes ||
+        options.nonInteractive ||
+        options.sourceAgents.length <= 1 ||
+        !options.promptForAgentSelection) {
+        return {
+            selectedAgents: options.sourceAgents,
+            requestedAgentsForLock: getStableRequestedAgentsForLock({
+                selectedAgents: options.sourceAgents,
+                sourceAgents: options.sourceAgents,
+            }),
+        };
+    }
+    const selected = await promptAgentSelection(options.sourceAgents);
+    if (selected.length === 0) {
+        throw new Error("No agents selected. Use --agent <name> or rerun and select at least one agent.");
+    }
+    const requestedAgentsForLock = getStableRequestedAgentsForLock({
+        selectedAgents: selected,
+        sourceAgents: options.sourceAgents,
+    });
+    return { selectedAgents: selected, requestedAgentsForLock };
+}
+function normalizeRequestedAgents(requestedAgents) {
+    if (!requestedAgents || requestedAgents.length === 0)
+        return undefined;
+    const normalized = requestedAgents.map((item) => item.trim()).filter(Boolean);
+    return normalized.length > 0 ? [...new Set(normalized)] : undefined;
+}
+function getStableRequestedAgentsForLock(options) {
+    const nameCounts = new Map();
+    for (const agent of options.sourceAgents) {
+        const normalizedName = normalizeAgentSelector(agent.name);
+        if (!normalizedName)
+            continue;
+        nameCounts.set(normalizedName, (nameCounts.get(normalizedName) ?? 0) + 1);
+    }
+    const selectors = options.selectedAgents.map((agent) => {
+        const normalizedName = normalizeAgentSelector(agent.name);
+        if (normalizedName && nameCounts.get(normalizedName) === 1) {
+            return agent.name;
+        }
+        return agent.fileName.replace(/\.md$/i, "");
+    });
+    return normalizeRequestedAgents(selectors);
+}
+function resolveRequestedAgents(sourceAgents, requestedAgents) {
+    const selectedPaths = new Set();
+    const missing = [];
+    const ambiguous = [];
+    for (const requestedAgent of requestedAgents) {
+        const exactMatches = sourceAgents.filter((agent) => agentMatchesSelector(agent, requestedAgent, false));
+        const matches = exactMatches.length > 0
+            ? exactMatches
+            : sourceAgents.filter((agent) => agentMatchesSelector(agent, requestedAgent, true));
+        if (matches.length === 0) {
+            missing.push(requestedAgent);
+            continue;
+        }
+        if (matches.length > 1) {
+            ambiguous.push(`${requestedAgent} (${matches.map((agent) => agent.name).join(", ")})`);
+            continue;
+        }
+        if (matches[0]) {
+            selectedPaths.add(matches[0].sourcePath);
+        }
+    }
+    if (missing.length > 0) {
+        throw new Error(`Requested agent(s) not found: ${missing.join(", ")}. Available agents: ${sourceAgents.map((agent) => agent.name).join(", ")}.`);
+    }
+    if (ambiguous.length > 0) {
+        throw new Error(`Requested agent selector is ambiguous: ${ambiguous.join("; ")}. Use the exact frontmatter name.`);
+    }
+    return sourceAgents.filter((agent) => selectedPaths.has(agent.sourcePath));
+}
+function agentMatchesSelector(agent, selector, includeSlugFallback) {
+    const normalizedSelector = normalizeAgentSelector(selector);
+    if (!normalizedSelector)
+        return false;
+    if (getExactAgentSelectorCandidates(agent).has(normalizedSelector)) {
+        return true;
+    }
+    if (!includeSlugFallback)
+        return false;
+    const selectorSlug = normalizeAgentSelector(slugify(selector));
+    return (selectorSlug !== "" &&
+        getSlugAgentSelectorCandidates(agent).has(selectorSlug));
+}
+function getExactAgentSelectorCandidates(agent) {
+    const fileBaseName = agent.fileName.replace(/\.md$/i, "");
+    return new Set([
+        agent.name,
+        fileBaseName,
+        path.basename(agent.sourcePath).replace(/\.md$/i, ""),
+    ]
+        .map(normalizeAgentSelector)
+        .filter(Boolean));
+}
+function getSlugAgentSelectorCandidates(agent) {
+    const fileBaseName = agent.fileName.replace(/\.md$/i, "");
+    return new Set([
+        slugify(agent.name),
+        slugify(fileBaseName),
+        slugify(path.basename(agent.sourcePath).replace(/\.md$/i, "")),
+    ]
+        .map(normalizeAgentSelector)
+        .filter(Boolean));
+}
+function normalizeAgentSelector(value) {
+    return value.trim().toLowerCase();
+}
+async function promptAgentSelection(sourceAgents) {
+    const choice = await multiselect({
+        message: withMultiselectHelp("Select agents to import"),
+        options: sourceAgents.map((agent) => ({
+            value: agent.sourcePath,
+            label: agent.name,
+            hint: agent.description,
+        })),
+        initialValues: sourceAgents.map((agent) => agent.sourcePath),
+    });
+    if (isCancel(choice)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    const selected = new Set(Array.isArray(choice) ? choice.map(String) : []);
+    return sourceAgents.filter((agent) => selected.has(agent.sourcePath));
+}
+function findMatchingLockEntry(entries, key) {
+    return entries.find((entry) => entry.source === key.source &&
+        entry.sourceType === key.sourceType &&
+        entry.subdir === key.subdir &&
+        sameRequestedAgentsForMatch(entry.requestedAgents, key.requestedAgents) &&
+        sameStringSelectionForMatch(entry.selectedSourceCommands, key.selectedSourceCommands) &&
+        sameStringSelectionForMatch(entry.selectedSourceMcpServers, key.selectedSourceMcpServers) &&
+        sameStringSelectionForMatch(entry.selectedSourceSkills, key.selectedSourceSkills, { wildcardWhenRightIsUndefined: true }) &&
+        sameStringSelectionForMatch(entry.skillsProviders, key.skillsProviders, {
+            wildcardWhenRightIsUndefined: true,
+        }));
+}
+function findRelaxedCommandEntry(entries, key) {
+    const matches = entries.filter((entry) => entry.source === key.source &&
+        entry.sourceType === key.sourceType &&
+        entry.subdir === key.subdir &&
+        sameRequestedAgentsForMatch(entry.requestedAgents, key.requestedAgents));
+    if (matches.length === 0)
+        return undefined;
+    const mixed = matches.find((entry) => entry.importedAgents.length > 0 ||
+        entry.importedMcpServers.length > 0 ||
+        entry.importedSkills.length > 0);
+    return mixed ?? matches[0];
+}
+function sameRequestedAgentsForMatch(left, right) {
+    const normalizedLeft = normalizeRequestedAgentsForMatch(left);
+    const normalizedRight = normalizeRequestedAgentsForMatch(right);
+    if (normalizedLeft.length !== normalizedRight.length) {
+        return false;
+    }
+    return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+}
+function normalizeRequestedAgentsForMatch(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return [];
+    return [
+        ...new Set(value.map((item) => item.trim().toLowerCase()).filter(Boolean)),
+    ].sort();
+}
+function sameStringSelectionForMatch(left, right, options = {}) {
+    if (options.wildcardWhenRightIsUndefined && right === undefined) {
+        return true;
+    }
+    const normalizedLeft = normalizeRequestedAgentsForMatch(left);
+    const normalizedRight = normalizeRequestedAgentsForMatch(right);
+    if (normalizedLeft.length !== normalizedRight.length) {
+        return false;
+    }
+    return normalizedLeft.every((value, index) => value === normalizedRight[index]);
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function computeTrackedEntitiesForLock(options) {
+    const tracked = [];
+    if (options.importedAgents.length > 0 ||
+        (options.requestedAgents?.length ?? 0) > 0) {
+        tracked.push("agent");
+    }
+    if (options.importedCommands.length > 0 ||
+        (options.selectedSourceCommands?.length ?? 0) > 0 ||
+        Object.keys(options.commandRenameMap ?? {}).length > 0) {
+        tracked.push("command");
+    }
+    if (options.importedMcpServers.length > 0 ||
+        (options.selectedSourceMcpServers?.length ?? 0) > 0) {
+        tracked.push("mcp");
+    }
+    if (options.importedSkills.length > 0 ||
+        (options.selectedSourceSkills?.length ?? 0) > 0 ||
+        (options.skillsProviders?.length ?? 0) > 0 ||
+        Object.keys(options.skillRenameMap ?? {}).length > 0) {
+        tracked.push("skill");
+    }
+    return tracked.length > 0 ? tracked : undefined;
+}
+function normalizeCommandRenameMap(renameMap) {
+    if (!renameMap)
+        return undefined;
+    const normalized = Object.fromEntries(Object.entries(renameMap).filter(([sourceFileName, importedFileName]) => sourceFileName.trim().length > 0 && importedFileName.trim().length > 0));
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function mergeCommandRenameMaps(existing, updates) {
+    const merged = {
+        ...(existing ?? {}),
+        ...(updates ?? {}),
+    };
+    return normalizeCommandRenameMap(merged);
+}
+function resolveMappedTargetFileName(sourceFileName, renameMap) {
+    if (!renameMap)
+        return undefined;
+    const normalizedSourceName = normalizeCommandSelector(sourceFileName);
+    for (const [sourceSelector, importedName] of Object.entries(renameMap)) {
+        if (normalizeCommandSelector(sourceSelector) !== normalizedSourceName) {
+            continue;
+        }
+        const importedBaseName = path.basename(importedName.trim());
+        if (!importedBaseName)
+            return undefined;
+        const importedExtension = path.extname(importedBaseName);
+        if (importedExtension)
+            return importedBaseName;
+        const sourceExtension = path.extname(sourceFileName) || ".md";
+        return `${slugify(importedBaseName) || "command"}${sourceExtension}`;
+    }
+    return undefined;
+}
+function normalizeSkillRenameMap(renameMap) {
+    if (!renameMap)
+        return undefined;
+    const normalizedEntries = Object.entries(renameMap)
+        .map(([sourceSelector, importedName]) => {
+        const normalizedSourceSelector = normalizeSkillSelector(sourceSelector);
+        const normalizedImportedName = slugify(path.basename(importedName.trim()));
+        if (!normalizedSourceSelector || !normalizedImportedName) {
+            return null;
+        }
+        return [normalizedSourceSelector, normalizedImportedName];
+    })
+        .filter((entry) => entry !== null);
+    if (normalizedEntries.length === 0)
+        return undefined;
+    return Object.fromEntries(normalizedEntries);
+}
+function resolveMappedTargetSkillName(sourceSkillName, renameMap) {
+    if (!renameMap)
+        return undefined;
+    const normalizedSourceName = normalizeSkillSelector(sourceSkillName);
+    if (!normalizedSourceName)
+        return undefined;
+    for (const [sourceSelector, importedName] of Object.entries(renameMap)) {
+        if (normalizeSkillSelector(sourceSelector) !== normalizedSourceName) {
+            continue;
+        }
+        return slugify(path.basename(importedName.trim())) || "skill";
+    }
+    return undefined;
+}
+function normalizeSkillsProviders(providers) {
+    if (!providers || providers.length === 0)
+        return undefined;
+    const selected = new Set();
+    for (const provider of providers) {
+        const normalized = provider.trim().toLowerCase();
+        if (ALL_PROVIDERS.includes(normalized)) {
+            selected.add(normalized);
+        }
+    }
+    return selected.size > 0 ? [...selected] : undefined;
+}
+async function resolveSkillConflict(options) {
+    const targetPath = path.join(options.paths.skillsDir, options.targetSkillDirName);
+    if (!fs.existsSync(targetPath))
+        return options.targetSkillDirName;
+    if (!fs.statSync(targetPath).isDirectory()) {
+        throw new Error(`Cannot import skill ${options.promptLabel}: ${targetPath} exists and is not a directory.`);
+    }
+    if (skillContentMatchesTarget(options.sourceSkill, targetPath)) {
+        return options.targetSkillDirName;
+    }
+    if (options.yes) {
+        return options.targetSkillDirName;
+    }
+    if (options.nonInteractive) {
+        throw new NonInteractiveConflictError(`Conflict for skill "${options.targetSkillDirName}". Use --yes or run interactively.`);
+    }
+    const choice = await select({
+        message: `Skill conflict for ${options.promptLabel}`,
+        options: [
+            { value: "overwrite", label: `Overwrite ${options.targetSkillDirName}` },
+            { value: "skip", label: "Skip this skill" },
+            { value: "rename", label: "Rename imported skill" },
+        ],
+    });
+    if (isCancel(choice)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    if (choice === "skip")
+        return null;
+    if (choice === "rename") {
+        const entered = await promptText({
+            message: `New directory name for ${options.promptLabel}`,
+            placeholder: options.targetSkillDirName,
+            validate(value) {
+                if (!value.trim())
+                    return "Name is required.";
+                if (/[\\/]/.test(value))
+                    return "Use a simple directory name.";
+                return undefined;
+            },
+        });
+        if (isCancel(entered)) {
+            cancel("Operation cancelled.");
+            process.exit(1);
+        }
+        const renamed = slugify(String(entered)) || "skill";
+        return resolveSkillConflict({
+            ...options,
+            targetSkillDirName: renamed,
+        });
+    }
+    return options.targetSkillDirName;
+}
 async function resolveAgentConflict(options) {
     const targetPath = path.join(options.paths.agentsDir, options.targetFileName);
     if (!fs.existsSync(targetPath))
@@ -143,6 +902,310 @@ async function resolveAgentConflict(options) {
     }
     return options.targetFileName;
 }
+async function resolveCommandConflict(options) {
+    const targetPath = path.join(options.paths.commandsDir, options.targetFileName);
+    if (!fs.existsSync(targetPath))
+        return options.targetFileName;
+    const existing = fs.readFileSync(targetPath, "utf8");
+    if (existing === options.commandContent)
+        return options.targetFileName;
+    if (options.yes) {
+        return options.targetFileName;
+    }
+    if (options.nonInteractive) {
+        throw new NonInteractiveConflictError(`Conflict for ${options.targetFileName}. Use --yes or run interactively.`);
+    }
+    const choice = await select({
+        message: `Command conflict for ${options.promptLabel}`,
+        options: [
+            { value: "overwrite", label: `Overwrite ${options.targetFileName}` },
+            { value: "skip", label: "Skip this command" },
+            { value: "rename", label: "Rename imported command" },
+        ],
+    });
+    if (isCancel(choice)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    if (choice === "skip")
+        return null;
+    if (choice === "rename") {
+        const entered = await promptText({
+            message: `New filename (without extension) for ${options.promptLabel}`,
+            placeholder: options.targetFileName.replace(/\.(md|mdc)$/i, ""),
+            validate(value) {
+                if (!value.trim())
+                    return "Name is required.";
+                if (/[\\/]/.test(value))
+                    return "Use a simple filename.";
+                return undefined;
+            },
+        });
+        if (isCancel(entered)) {
+            cancel("Operation cancelled.");
+            process.exit(1);
+        }
+        const extension = path.extname(options.targetFileName) || ".md";
+        const renamedFileName = `${slugify(String(entered)) || "command"}${extension}`;
+        return resolveCommandConflict({
+            ...options,
+            targetFileName: renamedFileName,
+        });
+    }
+    return options.targetFileName;
+}
+async function resolveCommandsToImport(options) {
+    const selectors = options.selectors
+        .map((selector) => selector.trim())
+        .filter(Boolean);
+    if (selectors.length > 0) {
+        const { selected, unmatched } = resolveCommandSelections(options.sourceCommands, selectors);
+        if (unmatched.length > 0) {
+            throw new Error(`Command(s) not found in source: ${unmatched.join(", ")}. Available: ${options.sourceCommands.map((item) => item.fileName).join(", ")}`);
+        }
+        return {
+            selectedCommands: selected,
+            selectionMode: "custom",
+        };
+    }
+    const selectionResolution = await resolveSelectionModeWithSkip({
+        entityLabel: "commands",
+        selectionMode: options.selectionMode,
+        promptForSelection: options.promptForCommands,
+        nonInteractive: options.nonInteractive,
+    });
+    const selectionMode = selectionResolution.selectionMode;
+    if (selectionResolution.skipImport) {
+        return {
+            selectedCommands: [],
+            selectionMode: "custom",
+        };
+    }
+    if (selectionMode === "all" ||
+        !options.promptForCommands ||
+        options.nonInteractive) {
+        return {
+            selectedCommands: options.sourceCommands,
+            selectionMode,
+        };
+    }
+    const selected = await multiselect({
+        message: withMultiselectHelp("Select commands to import"),
+        options: options.sourceCommands.map((item) => ({
+            value: item.fileName,
+            label: item.fileName,
+        })),
+        initialValues: options.sourceCommands.map((item) => item.fileName),
+    });
+    if (isCancel(selected)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    const selectedNames = Array.isArray(selected)
+        ? new Set(selected.map((value) => String(value)))
+        : new Set();
+    return {
+        selectedCommands: options.sourceCommands.filter((item) => selectedNames.has(item.fileName)),
+        selectionMode,
+    };
+}
+async function resolveMcpServersToImport(options) {
+    const available = Object.keys(options.sourceMcp.mcpServers).sort();
+    const selectors = options.selectors
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (selectors.length > 0) {
+        const selected = new Set();
+        const unmatched = [];
+        for (const selector of selectors) {
+            if (!Object.prototype.hasOwnProperty.call(options.sourceMcp.mcpServers, selector)) {
+                unmatched.push(selector);
+                continue;
+            }
+            selected.add(selector);
+        }
+        if (unmatched.length > 0) {
+            throw new Error(`MCP server(s) not found in source: ${unmatched.join(", ")}. Available: ${available.join(", ")}`);
+        }
+        return {
+            selectedServerNames: [...selected],
+            selectionMode: "custom",
+        };
+    }
+    const selectionResolution = await resolveSelectionModeWithSkip({
+        entityLabel: "MCP servers",
+        selectionMode: options.selectionMode,
+        promptForSelection: options.promptForMcp,
+        nonInteractive: options.nonInteractive,
+    });
+    const selectionMode = selectionResolution.selectionMode;
+    if (selectionResolution.skipImport) {
+        return {
+            selectedServerNames: [],
+            selectionMode: "custom",
+        };
+    }
+    if (selectionMode === "all" ||
+        !options.promptForMcp ||
+        options.nonInteractive) {
+        return {
+            selectedServerNames: available,
+            selectionMode,
+        };
+    }
+    const selected = await multiselect({
+        message: withMultiselectHelp("Select MCP servers to import"),
+        options: available.map((serverName) => ({
+            value: serverName,
+            label: serverName,
+        })),
+        initialValues: available,
+    });
+    if (isCancel(selected)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    const selectedNames = Array.isArray(selected)
+        ? new Set(selected.map((value) => String(value)))
+        : new Set();
+    return {
+        selectedServerNames: available.filter((serverName) => selectedNames.has(serverName)),
+        selectionMode,
+    };
+}
+async function resolveSkillsToImport(options) {
+    const selectors = options.selectors
+        .map((item) => item.trim())
+        .filter(Boolean);
+    if (selectors.length > 0) {
+        const { selected, unmatched } = resolveSkillSelections(options.sourceSkills, selectors);
+        if (unmatched.length > 0) {
+            throw new Error(`Skill(s) not found in source: ${unmatched.join(", ")}. Available: ${options.sourceSkills.map((skill) => skill.name).join(", ")}`);
+        }
+        return {
+            selectedSkills: selected,
+            selectionMode: "custom",
+        };
+    }
+    const selectionResolution = await resolveSelectionModeWithSkip({
+        entityLabel: "skills",
+        selectionMode: options.selectionMode,
+        promptForSelection: options.promptForSkills,
+        nonInteractive: options.nonInteractive,
+    });
+    const selectionMode = selectionResolution.selectionMode;
+    if (selectionResolution.skipImport) {
+        return {
+            selectedSkills: [],
+            selectionMode: "custom",
+        };
+    }
+    if (selectionMode === "all" ||
+        !options.promptForSkills ||
+        options.nonInteractive) {
+        return {
+            selectedSkills: options.sourceSkills,
+            selectionMode,
+        };
+    }
+    const selected = await multiselect({
+        message: withMultiselectHelp("Select skills to import"),
+        options: options.sourceSkills.map((skill) => ({
+            value: skill.name,
+            label: skill.name,
+        })),
+        initialValues: options.sourceSkills.map((skill) => skill.name),
+    });
+    if (isCancel(selected)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    const selectedNames = Array.isArray(selected)
+        ? new Set(selected.map((value) => String(value)))
+        : new Set();
+    return {
+        selectedSkills: options.sourceSkills.filter((skill) => selectedNames.has(skill.name)),
+        selectionMode,
+    };
+}
+async function resolveSelectionMode(options) {
+    if (options.selectionMode) {
+        return options.selectionMode;
+    }
+    if (!options.promptForSelection || options.nonInteractive) {
+        return "all";
+    }
+    const choice = await select({
+        message: `How should ${options.entityLabel} be tracked for future updates?`,
+        options: [
+            {
+                value: "all",
+                label: "Sync everything from source",
+                hint: "Include new items on update",
+            },
+            {
+                value: "custom",
+                label: "Use custom selection",
+                hint: "Update only currently selected items",
+            },
+        ],
+        initialValue: "all",
+    });
+    if (isCancel(choice)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    return choice === "custom" ? "custom" : "all";
+}
+async function resolveSelectionModeWithSkip(options) {
+    if (options.selectionMode) {
+        return {
+            selectionMode: options.selectionMode,
+            skipImport: false,
+        };
+    }
+    if (!options.promptForSelection || options.nonInteractive) {
+        return {
+            selectionMode: "all",
+            skipImport: false,
+        };
+    }
+    const choice = await select({
+        message: `How should ${options.entityLabel} be tracked for future updates?`,
+        options: [
+            {
+                value: "all",
+                label: "Sync everything from source",
+                hint: "Include new items on update",
+            },
+            {
+                value: "custom",
+                label: "Use custom selection",
+                hint: "Update only currently selected items",
+            },
+            {
+                value: "skip",
+                label: `Skip importing ${options.entityLabel}`,
+                hint: "Track none from this source",
+            },
+        ],
+        initialValue: "all",
+    });
+    if (isCancel(choice)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    if (choice === "skip") {
+        return {
+            selectionMode: "custom",
+            skipImport: true,
+        };
+    }
+    return {
+        selectionMode: choice === "custom" ? "custom" : "all",
+        skipImport: false,
+    };
+}
 function normalizeMcp(raw) {
     if (!raw) {
         return {