agentloom 0.1.8 → 0.1.10

package/README.md

@@ -60,7 +60,7 @@ Global scope uses `~/.agents` with the same file layout.
 - `agentloom update [source]`
 - `agentloom upgrade`
 - `agentloom sync`
-- `agentloom delete <source|name>`
+- `agentloom delete <source|name...>`
 
 Aggregate `add` imports discoverable entities from a source (agents, commands, rules, MCP servers, skills). In interactive sessions, each entity supports two tracking modes:
 
@@ -117,6 +117,7 @@ agentloom mcp add farnoodma/agents --mcps browser
 agentloom rule add farnoodma/agents --rules always-test
 agentloom skill add farnoodma/agents --skills pr-review
 agentloom delete farnoodma/agents
+agentloom command delete review audit
 agentloom mcp server add browser-tools --command npx --arg browser-tools-mcp
 ```
 

package/dist/commands/agent.js

@@ -7,7 +7,8 @@ import { runScopedFindCommand } from "./find.js";
 import { runScopedSyncCommand } from "./sync.js";
 import { runScopedUpdateCommand } from "./update.js";
 export async function runAgentCommand(argv, cwd) {
-    const action = argv._[1];
+    const rawAction = argv._[1];
+    const action = rawAction === "remove" ? "delete" : rawAction;
     if (argv.help || !action) {
         console.log("Usage:\n  agentloom agent <add|list|delete|find|update|sync> [options]");
         return;

package/dist/commands/command.js

@@ -7,7 +7,8 @@ import { runScopedFindCommand } from "./find.js";
 import { runScopedSyncCommand } from "./sync.js";
 import { runScopedUpdateCommand } from "./update.js";
 export async function runCommandCommand(argv, cwd) {
-    const action = argv._[1];
+    const rawAction = argv._[1];
+    const action = rawAction === "remove" ? "delete" : rawAction;
     if (argv.help) {
         if (action === "add") {
             console.log(getCommandAddHelpText());

package/dist/commands/delete.js

@@ -2,16 +2,26 @@ import fs from "node:fs";
 import path from "node:path";
 import { multiselect, isCancel, cancel, select } from "@clack/prompts";
 import { parseAgentsDir } from "../core/agents.js";
-import { parseCommandsDir } from "../core/commands.js";
+import { getStringArrayFlag } from "../core/argv.js";
+import { parseCommandsDir, stripCommandFileExtension, } from "../core/commands.js";
 import { formatUsageError } from "../core/copy.js";
 import { readLockfile, writeLockfile } from "../core/lockfile.js";
 import { readCanonicalMcp, writeCanonicalMcp } from "../core/mcp.js";
+import { getProviderCommandsDir } from "../core/provider-paths.js";
 import { normalizeRuleSelector, parseRulesDir, stripRuleFileExtension, } from "../core/rules.js";
 import { parseSourceSpec } from "../core/sources.js";
 import { parseSkillsDir } from "../core/skills.js";
 import { getNonInteractiveMode, resolvePathsForCommand, runPostMutationSync, } from "./entity-utils.js";
 const ALL_ENTITIES = ["agent", "command", "mcp", "rule", "skill"];
 const MULTISELECT_HELP_TEXT = "↑↓ move, space select, enter confirm";
+class MissingEntityError extends Error {
+    candidate;
+    constructor(candidate, message) {
+        super(message);
+        this.candidate = candidate;
+        this.name = "MissingEntityError";
+    }
+}
 function withMultiselectHelp(message) {
     return `${message}\n${MULTISELECT_HELP_TEXT}`;
 }
@@ -32,13 +42,13 @@ export async function runScopedDeleteCommand(options) {
     });
 }
 async function runEntityAwareDelete(options) {
-    const candidate = getDeleteCandidate(options.argv, options.sourceIndex);
-    if (!candidate) {
+    const candidates = getDeleteCandidates(options.argv, options.sourceIndex);
+    if (candidates.length === 0) {
         throw new Error(formatUsageError({
-            issue: "Missing required <source|name>.",
+            issue: "Missing required <source|name...>.",
             usage: options.target === "all"
-                ? "agentloom delete <source|name> [options]"
-                : `agentloom ${options.target} delete <source|name> [options]`,
+                ? "agentloom delete <source|name...> [options]"
+                : `agentloom ${options.target} delete <source|name...> [options]`,
             example: options.target === "all"
                 ? "agentloom delete farnoodma/agents"
                 : `agentloom ${options.target} delete reviewer`,
@@ -46,61 +56,69 @@ async function runEntityAwareDelete(options) {
     }
     const nonInteractive = getNonInteractiveMode(options.argv);
     const paths = await resolvePathsForCommand(options.argv, options.cwd);
-    const lockfile = readLockfile(paths);
-    const sourceMatches = lockfile.entries.filter((entry) => matchesSource(entry, candidate));
-    const sourceMode = sourceMatches.length > 0 ||
-        (typeof options.argv.source === "string" &&
-            options.argv.source.trim() !== "");
-    const entities = await resolveEntitiesForDelete({
-        argv: options.argv,
-        target: options.target,
-        sourceMode,
-        nonInteractive,
-    });
-    if (entities.length === 0) {
-        console.log("No entities selected for deletion.");
-        return;
-    }
-    if (sourceMode) {
-        await deleteBySource({
-            paths,
-            sourceFilter: candidate,
-            lockfile,
-            lockEntries: sourceMatches,
-            entities,
-        });
-    }
-    else {
-        await deleteByName({
-            candidate,
+    const explicitSourceFilters = getStringArrayFlag(options.argv.source);
+    const missingCandidates = [];
+    for (const candidate of candidates) {
+        const lockfile = readLockfile(paths);
+        const sourceMatches = lockfile.entries.filter((entry) => matchesSource(entry, candidate));
+        const sourceMode = sourceMatches.length > 0 || explicitSourceFilters.length > 0;
+        const entities = await resolveEntitiesForDelete({
             argv: options.argv,
-            paths,
-            entities,
+            target: options.target,
+            sourceMode,
             nonInteractive,
         });
+        if (entities.length === 0) {
+            console.log("No entities selected for deletion.");
+            return;
+        }
+        if (sourceMode) {
+            await deleteBySource({
+                paths,
+                sourceFilter: candidate,
+                lockfile,
+                lockEntries: sourceMatches,
+                entities,
+            });
+            continue;
+        }
+        try {
+            await deleteByName({
+                candidate,
+                argv: options.argv,
+                paths,
+                entities,
+                nonInteractive,
+            });
+        }
+        catch (error) {
+            if (error instanceof MissingEntityError) {
+                missingCandidates.push(error.candidate);
+                continue;
+            }
+            throw error;
+        }
     }
     await runPostMutationSync({
         argv: options.argv,
         paths,
         target: options.target,
     });
+    if (missingCandidates.length > 0) {
+        console.warn(`Couldn't delete these because they don't exist: ${[...new Set(missingCandidates)].join(", ")}`);
+    }
 }
-function getDeleteCandidate(argv, sourceIndex) {
-    const fromSourceFlag = typeof argv.source === "string" && argv.source.trim().length > 0
-        ? argv.source.trim()
-        : undefined;
-    if (fromSourceFlag)
+function getDeleteCandidates(argv, sourceIndex) {
+    const fromSourceFlag = getStringArrayFlag(argv.source);
+    if (fromSourceFlag.length > 0)
         return fromSourceFlag;
-    const fromNameFlag = typeof argv.name === "string" && argv.name.trim().length > 0
-        ? argv.name.trim()
-        : undefined;
-    if (fromNameFlag)
+    const fromNameFlag = getStringArrayFlag(argv.name);
+    if (fromNameFlag.length > 0)
         return fromNameFlag;
-    const positional = argv._[sourceIndex];
-    if (typeof positional !== "string" || positional.trim().length === 0) {
-        return undefined;
-    }
-    return positional.trim();
+    return argv._.slice(sourceIndex)
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter(Boolean);
 }
 async function resolveEntitiesForDelete(options) {
     if (options.target !== "all")
@@ -196,7 +214,7 @@ async function deleteByName(options) {
         const matches = detectNameMatches(options.paths, options.candidate);
         const matchingEntities = selectedEntities.filter((entity) => matches.includes(entity));
         if (matchingEntities.length === 0) {
-            throw new Error(`No installed entity named "${options.candidate}" found.`);
+            throw new MissingEntityError(options.candidate, `No installed entity named "${options.candidate}" found.`);
         }
         if (matchingEntities.length > 1) {
             if (options.nonInteractive) {
@@ -230,7 +248,7 @@ async function deleteByName(options) {
         else if (entity === "mcp") {
             const existing = Object.keys(mcp.mcpServers).find((name) => normalizeName(name) === normalizeName(options.candidate));
             if (!existing) {
-                throw new Error(`MCP server "${options.candidate}" was not found.`);
+                throw new MissingEntityError(options.candidate, `MCP server "${options.candidate}" was not found.`);
             }
             delete mcp.mcpServers[existing];
         }
@@ -261,7 +279,7 @@ function deleteAgentByName(paths, name) {
         normalizeName(agent.fileName.replace(/\.md$/i, "")) ===
             normalizeName(name));
     if (!target) {
-        throw new Error(`Agent "${name}" was not found in canonical agents.`);
+        throw new MissingEntityError(name, `Agent "${name}" was not found in canonical agents.`);
     }
     removeIfExists(target.sourcePath);
 }
@@ -271,16 +289,17 @@ function deleteCommandByName(paths, name) {
         normalizeName(command.fileName.replace(/\.(md|mdc)$/i, "")) ===
             normalizeName(name));
     if (!target) {
-        throw new Error(`Command "${name}" was not found in canonical commands.`);
+        throw new MissingEntityError(name, `Command "${name}" was not found in canonical commands.`);
     }
     removeIfExists(target.sourcePath);
+    removeLegacyGeminiCommandVariants(paths, target.fileName);
 }
 function deleteSkillByName(paths, name) {
     const skills = parseSkillsDir(paths.skillsDir);
     const target = skills.find((skill) => normalizeName(skill.name) === normalizeName(name) ||
         normalizeName(path.basename(skill.sourcePath)) === normalizeName(name));
     if (!target) {
-        throw new Error(`Skill "${name}" was not found in canonical skills.`);
+        throw new MissingEntityError(name, `Skill "${name}" was not found in canonical skills.`);
     }
     removeIfExists(target.sourcePath);
 }
@@ -288,7 +307,7 @@ function deleteRuleByName(paths, name) {
     const rules = parseRulesDir(paths.rulesDir);
     const target = rules.find((rule) => ruleMatchesCandidate(rule, name));
     if (!target) {
-        throw new Error(`Rule "${name}" was not found in canonical rules.`);
+        throw new MissingEntityError(name, `Rule "${name}" was not found in canonical rules.`);
     }
     removeIfExists(target.sourcePath);
     return target;
@@ -298,6 +317,12 @@ function removeIfExists(filePath) {
         return;
     fs.rmSync(filePath, { recursive: true, force: true });
 }
+function removeLegacyGeminiCommandVariants(paths, fileName) {
+    const commandsDir = getProviderCommandsDir(paths, "gemini");
+    const stem = stripCommandFileExtension(path.basename(fileName));
+    removeIfExists(path.join(commandsDir, `${stem}.md`));
+    removeIfExists(path.join(commandsDir, `${stem}.mdc`));
+}
 function normalizeName(value) {
     return value.trim().toLowerCase();
 }

package/dist/commands/mcp.js

@@ -9,7 +9,8 @@ import { runScopedFindCommand } from "./find.js";
 import { runScopedSyncCommand } from "./sync.js";
 import { runScopedUpdateCommand } from "./update.js";
 export async function runMcpCommand(argv, cwd) {
-    const action = argv._[1];
+    const rawAction = argv._[1];
+    const action = rawAction === "remove" ? "delete" : rawAction;
     if (argv.help) {
         if (action === "add") {
             console.log(getMcpAddHelpText());
@@ -93,7 +94,8 @@ export async function runMcpCommand(argv, cwd) {
     });
 }
 async function runMcpServerCommand(argv, cwd) {
-    const action = argv._[2];
+    const rawAction = argv._[2];
+    const action = rawAction === "remove" ? "delete" : rawAction;
     if (argv.help || !action) {
         console.log(getMcpServerHelpText());
         return;

package/dist/commands/rule.js

@@ -7,7 +7,8 @@ import { runScopedFindCommand } from "./find.js";
 import { runScopedSyncCommand } from "./sync.js";
 import { runScopedUpdateCommand } from "./update.js";
 export async function runRuleCommand(argv, cwd) {
-    const action = argv._[1];
+    const rawAction = argv._[1];
+    const action = rawAction === "remove" ? "delete" : rawAction;
     if (argv.help || !action) {
         console.log("Usage:\n  agentloom rule <add|list|delete|find|update|sync> [options]");
         return;

package/dist/commands/skills.js

@@ -8,7 +8,8 @@ import { runScopedFindCommand } from "./find.js";
 import { runScopedSyncCommand } from "./sync.js";
 import { runScopedUpdateCommand } from "./update.js";
 export async function runSkillCommand(argv, cwd) {
-    const action = argv._[1];
+    const rawAction = argv._[1];
+    const action = rawAction === "remove" ? "delete" : rawAction;
     if (argv.help || !action) {
         console.log("Usage:\n  agentloom skill <add|list|delete|find|update|sync> [options]");
         return;

package/dist/commands/update.js

@@ -5,6 +5,7 @@ import { normalizeCommandSelector, stripCommandFileExtension, } from "../core/co
 import { normalizeRuleSelector, stripRuleFileExtension, } from "../core/rules.js";
 import { readLockfile } from "../core/lockfile.js";
 import { prepareSource, parseSourceSpec } from "../core/sources.js";
+import { sendAddTelemetryEvent } from "../core/telemetry.js";
 import { getUpdateHelpText } from "../core/copy.js";
 import { resolveProvidersForSync } from "../sync/index.js";
 import { getNonInteractiveMode, resolvePathsForCommand, runPostMutationSync, } from "./entity-utils.js";
@@ -58,21 +59,28 @@ async function runEntityAwareUpdate(options) {
         console.log("No lock entries matched the requested source filter.");
         return;
     }
+    console.log(`Checking ${entries.length} lock entr${entries.length === 1 ? "y" : "ies"} for updates...`);
     let updated = 0;
     let skipped = 0;
-    for (const entry of entries) {
+    for (const [index, entry] of entries.entries()) {
+        const progressPrefix = formatUpdateProgressPrefix(index, entries.length);
+        const entryLabel = formatLockEntryLabel(entry);
         if (!entryIncludesTarget(entry, options.target)) {
+            console.log(`${progressPrefix} Skipping ${entryLabel} (does not track ${options.target}).`);
             skipped += 1;
             continue;
         }
+        console.log(`${progressPrefix} Checking ${entryLabel}...`);
         const probe = prepareSource({
             source: entry.source,
             ref: entry.requestedRef,
             subdir: entry.subdir,
         });
-        const hasNewCommit = probe.resolvedCommit !== entry.resolvedCommit;
+        const latestCommit = probe.resolvedCommit;
+        const hasNewCommit = latestCommit !== entry.resolvedCommit;
         probe.cleanup();
         if (!hasNewCommit) {
+            console.log(`${progressPrefix} Up to date at ${formatShortCommit(entry.resolvedCommit)}.`);
             skipped += 1;
             continue;
         }
@@ -82,9 +90,11 @@ async function runEntityAwareUpdate(options) {
             !updatePlan.importMcp &&
             !updatePlan.importRules &&
             !updatePlan.importSkills) {
+            console.log(`${progressPrefix} Skipping ${entryLabel} (no tracked entities selected for update).`);
             skipped += 1;
             continue;
         }
+        console.log(`${progressPrefix} Updating ${entryLabel} (${formatShortCommit(entry.resolvedCommit)} -> ${formatShortCommit(latestCommit)})...`);
         try {
             const importOptions = {
                 source: entry.source,
@@ -136,7 +146,12 @@ async function runEntityAwareUpdate(options) {
             if (updatePlan.skillRenameMap) {
                 importOptions.skillRenameMap = updatePlan.skillRenameMap;
             }
-            await importSource(importOptions);
+            const summary = await importSource(importOptions);
+            await sendAddTelemetryEvent({
+                rawSource: entry.source,
+                summary,
+            });
+            console.log(`${progressPrefix} Updated ${entryLabel} to ${formatShortCommit(summary.resolvedCommit)}.`);
             updated += 1;
         }
         catch (err) {
@@ -158,6 +173,25 @@ async function runEntityAwareUpdate(options) {
         });
     }
 }
+function formatUpdateProgressPrefix(index, total) {
+    return `[${index + 1}/${total}]`;
+}
+function formatLockEntryLabel(entry) {
+    const base = entry.source;
+    const refSuffix = typeof entry.requestedRef === "string" && entry.requestedRef.length > 0
+        ? `@${entry.requestedRef}`
+        : "";
+    const subdirSuffix = typeof entry.subdir === "string" && entry.subdir.length > 0
+        ? ` (${entry.subdir})`
+        : "";
+    return `${base}${refSuffix}${subdirSuffix}`;
+}
+function formatShortCommit(commit) {
+    const normalized = commit.trim();
+    if (normalized.length <= 12)
+        return normalized;
+    return normalized.slice(0, 12);
+}
 function buildEntryUpdatePlan(entry, target) {
     const includeAgents = shouldUpdateEntity(entry, "agent", target);
     const includeCommands = shouldUpdateEntity(entry, "command", target);

package/dist/core/copy.js

@@ -14,7 +14,7 @@ Aggregate commands:
   update [source]            Refresh lockfile-managed imports
   upgrade                    Install the latest CLI release
   sync                       Migrate provider configs then generate provider outputs
-  delete <source|name>       Delete imported entities by source or name
+  delete <source|name...>    Delete imported entities by source or name(s)
 
 Entity commands:
   agent <add|list|delete|find|update|sync>
@@ -40,8 +40,8 @@ Common options:
   --rules <csv>              Rule selectors for add/delete
   --skills <csv>             Skill selectors for add/delete
   --selection-mode <mode>    Add mode: all (default) or custom
-  --source <value>           Explicit source filter for update/delete
-  --name <value>             Explicit name filter for delete
+  --source <csv>             Explicit source filter(s) for update/delete
+  --name <csv>               Explicit name filter(s) for delete
   --entity <type>            Delete disambiguation for aggregate delete
 
 Examples:
@@ -192,7 +192,7 @@ export function getCommandDeleteHelpText() {
     return `Delete command imports by source or name.
 
 Usage:
-  agentloom command delete <source|name> [options]
+  agentloom command delete <source|name...> [options]
 `;
 }
 export function getMcpHelpText() {

package/dist/core/importer.js

@@ -417,6 +417,8 @@ export async function importSource(options) {
                 }
             }
         }
+        const selectedSubsetOfSourceAgents = sourceAgents.length > 0 &&
+            selection.selectedAgents.length < sourceAgents.length;
         const selectedSubsetOfSourceCommands = sourceCommands.length > 0 &&
             selectedSourceCommandFiles.length < sourceCommands.length;
         const selectedSubsetOfSourceMcp = sourceMcpServerNames.length > 0 &&
@@ -441,18 +443,48 @@ export async function importSource(options) {
             ? selectedSourceSkills
             : undefined;
         const lockfile = readLockfile(options.paths);
-        const isCommandOnlyImport = !shouldImportAgents &&
-            shouldImportCommands &&
-            !shouldImportMcp &&
-            !shouldImportRules &&
-            !shouldImportSkills;
-        const existingEntry = isCommandOnlyImport
-            ? findRelaxedCommandEntry(lockfile.entries, {
+        const importedEntities = [
+            shouldImportAgents ? "agent" : null,
+            shouldImportCommands ? "command" : null,
+            shouldImportMcp ? "mcp" : null,
+            shouldImportRules ? "rule" : null,
+            shouldImportSkills ? "skill" : null,
+        ].filter(Boolean);
+        const singleEntityImport = importedEntities.length === 1 ? importedEntities[0] : undefined;
+        const isAgentOnlyImport = singleEntityImport === "agent";
+        const isCommandOnlyImport = singleEntityImport === "command";
+        const isMcpOnlyImport = singleEntityImport === "mcp";
+        const isRuleOnlyImport = singleEntityImport === "rule";
+        const isSkillOnlyImport = singleEntityImport === "skill";
+        const relaxedSingleEntityEntries = singleEntityImport
+            ? findRelaxedEntityEntries(lockfile.entries, {
                 source: prepared.spec.source,
                 sourceType: prepared.spec.type,
                 subdir: options.subdir,
                 requestedAgents: options.agents,
+                entity: singleEntityImport,
             })
+            : [];
+        let relaxedSingleEntityEntry = relaxedSingleEntityEntries[0];
+        if (relaxedSingleEntityEntries.length > 1) {
+            const canonicalEntry = relaxedSingleEntityEntries[0];
+            const redundantEntries = relaxedSingleEntityEntries.slice(1);
+            const collapsibleRedundantEntries = redundantEntries.filter((entry) => !isMixedEntryForEntity(entry, singleEntityImport));
+            const consolidatedEntry = mergeRelaxedEntityEntriesForLock({
+                canonicalEntry,
+                redundantEntries: collapsibleRedundantEntries,
+                entity: singleEntityImport,
+            });
+            const canonicalEntryIndex = lockfile.entries.indexOf(canonicalEntry);
+            if (canonicalEntryIndex >= 0) {
+                lockfile.entries[canonicalEntryIndex] = consolidatedEntry;
+            }
+            const redundantEntriesSet = new Set(collapsibleRedundantEntries);
+            lockfile.entries = lockfile.entries.filter((entry) => !redundantEntriesSet.has(entry));
+            relaxedSingleEntityEntry = consolidatedEntry;
+        }
+        const existingEntry = singleEntityImport
+            ? relaxedSingleEntityEntry
             : findMatchingLockEntry(lockfile.entries, {
                 source: prepared.spec.source,
                 sourceType: prepared.spec.type,
@@ -472,8 +504,34 @@ export async function importSource(options) {
             (existingEntry?.importedAgents.length ?? 0) === 0 &&
             (existingEntry?.importedMcpServers.length ?? 0) === 0 &&
             (existingEntry?.importedSkills.length ?? 0) === 0;
+        const shouldMergeAgentOnlyEntry = isAgentOnlyImport &&
+            Boolean(existingEntry) &&
+            (selection.requestedAgentsForLock !== undefined ||
+                selectedSubsetOfSourceAgents);
+        const shouldMergeMcpOnlyEntry = isMcpOnlyImport &&
+            Boolean(existingEntry) &&
+            (existingEntry?.importedAgents.length ?? 0) === 0 &&
+            (existingEntry?.importedCommands.length ?? 0) === 0 &&
+            (existingEntry?.importedRules.length ?? 0) === 0 &&
+            (existingEntry?.importedSkills.length ?? 0) === 0 &&
+            (shouldPersistMcpSelection || selectedSubsetOfSourceMcp);
+        const shouldMergeRuleOnlyEntry = isRuleOnlyImport &&
+            Boolean(existingEntry) &&
+            (existingEntry?.importedAgents.length ?? 0) === 0 &&
+            (existingEntry?.importedCommands.length ?? 0) === 0 &&
+            (existingEntry?.importedMcpServers.length ?? 0) === 0 &&
+            (existingEntry?.importedSkills.length ?? 0) === 0 &&
+            (shouldPersistRuleSelection || selectedSubsetOfSourceRules);
+        const shouldMergeSkillOnlyEntry = isSkillOnlyImport &&
+            Boolean(existingEntry) &&
+            (shouldPersistSkillSelection || selectedSubsetOfSourceSkills);
         const lockImportedAgents = shouldImportAgents
-            ? importedAgents
+            ? shouldMergeAgentOnlyEntry
+                ? uniqueStrings([
+                    ...(existingEntry?.importedAgents ?? []),
+                    ...importedAgents,
+                ])
+                : importedAgents
             : (existingEntry?.importedAgents ?? []);
         const lockImportedCommands = shouldImportCommands
             ? shouldMergeCommandOnlyEntry
@@ -484,13 +542,30 @@ export async function importSource(options) {
                 : importedCommands
             : (existingEntry?.importedCommands ?? []);
         const lockImportedMcpServers = shouldImportMcp
-            ? importedMcpServers
+            ? shouldMergeMcpOnlyEntry
+                ? uniqueStrings([
+                    ...(existingEntry?.importedMcpServers ?? []),
+                    ...importedMcpServers,
+                ])
+                : importedMcpServers
             : (existingEntry?.importedMcpServers ?? []);
         const lockImportedRules = shouldImportRules
-            ? importedRules
+            ? shouldMergeRuleOnlyEntry
+                ? uniqueStrings([
+                    ...(existingEntry?.importedRules ?? []),
+                    ...importedRules,
+                ])
+                : importedRules
             : (existingEntry?.importedRules ?? []);
         const lockImportedSkills = shouldImportSkills
-            ? importedSkills
+            ? shouldMergeSkillOnlyEntry
+                ? mergeImportedSkills({
+                    existingImportedSkills: existingEntry?.importedSkills,
+                    importedSkills,
+                    selectedSkills,
+                    existingSkillRenameMap: existingEntry?.skillRenameMap,
+                })
+                : importedSkills
             : (existingEntry?.importedSkills ?? []);
         let lockSelectedSourceCommands;
         if (shouldImportCommands) {
@@ -516,29 +591,92 @@ export async function importSource(options) {
         else {
             lockSelectedSourceCommands = existingEntry?.selectedSourceCommands;
         }
-        const lockSelectedSourceMcpServers = shouldImportMcp
-            ? shouldPersistMcpSelection || selectedSubsetOfSourceMcp
-                ? [...selectedSourceMcpServers]
-                : undefined
-            : existingEntry?.selectedSourceMcpServers;
-        const lockSelectedSourceRules = shouldImportRules
-            ? shouldPersistRuleSelection || selectedSubsetOfSourceRules
-                ? [...selectedSourceRules]
-                : undefined
-            : existingEntry?.selectedSourceRules;
-        const lockSelectedSourceSkills = shouldImportSkills
-            ? shouldPersistSkillSelection || selectedSubsetOfSourceSkills
-                ? [...selectedSourceSkills]
-                : undefined
-            : existingEntry?.selectedSourceSkills;
+        let lockSelectedSourceMcpServers;
+        if (shouldImportMcp) {
+            if (shouldMergeMcpOnlyEntry) {
+                if (shouldPersistMcpSelection || selectedSubsetOfSourceMcp) {
+                    lockSelectedSourceMcpServers = uniqueStrings([
+                        ...(existingEntry?.selectedSourceMcpServers ?? []),
+                        ...selectedSourceMcpServers,
+                    ]);
+                }
+                else {
+                    lockSelectedSourceMcpServers = undefined;
+                }
+            }
+            else if (shouldPersistMcpSelection || selectedSubsetOfSourceMcp) {
+                lockSelectedSourceMcpServers = [...selectedSourceMcpServers];
+            }
+            else {
+                lockSelectedSourceMcpServers = undefined;
+            }
+        }
+        else {
+            lockSelectedSourceMcpServers = existingEntry?.selectedSourceMcpServers;
+        }
+        let lockSelectedSourceRules;
+        if (shouldImportRules) {
+            if (shouldMergeRuleOnlyEntry) {
+                if (shouldPersistRuleSelection || selectedSubsetOfSourceRules) {
+                    lockSelectedSourceRules = uniqueStrings([
+                        ...(existingEntry?.selectedSourceRules ?? []),
+                        ...selectedSourceRules,
+                    ]);
+                }
+                else {
+                    lockSelectedSourceRules = undefined;
+                }
+            }
+            else if (shouldPersistRuleSelection || selectedSubsetOfSourceRules) {
+                lockSelectedSourceRules = [...selectedSourceRules];
+            }
+            else {
+                lockSelectedSourceRules = undefined;
+            }
+        }
+        else {
+            lockSelectedSourceRules = existingEntry?.selectedSourceRules;
+        }
+        let lockSelectedSourceSkills;
+        if (shouldImportSkills) {
+            if (shouldMergeSkillOnlyEntry) {
+                if (shouldPersistSkillSelection || selectedSubsetOfSourceSkills) {
+                    lockSelectedSourceSkills = uniqueStrings([
+                        ...(existingEntry?.selectedSourceSkills ?? []),
+                        ...selectedSourceSkills,
+                    ]);
+                }
+                else {
+                    lockSelectedSourceSkills = undefined;
+                }
+            }
+            else if (shouldPersistSkillSelection || selectedSubsetOfSourceSkills) {
+                lockSelectedSourceSkills = [...selectedSourceSkills];
+            }
+            else {
+                lockSelectedSourceSkills = undefined;
+            }
+        }
+        else {
+            lockSelectedSourceSkills = existingEntry?.selectedSourceSkills;
+        }
         const lockRuleRenameMap = shouldImportRules
-            ? normalizeRuleRenameMap(importedRuleRenameMap)
+            ? shouldMergeRuleOnlyEntry
+                ? mergeRuleRenameMaps(existingEntry?.ruleRenameMap, importedRuleRenameMap)
+                : normalizeRuleRenameMap(importedRuleRenameMap)
             : existingEntry?.ruleRenameMap;
         const lockSkillsProviders = shouldImportSkills
-            ? (skillsProvidersForLock ?? existingEntry?.skillsProviders)
+            ? shouldMergeSkillOnlyEntry
+                ? normalizeSkillsProviders([
+                    ...(existingEntry?.skillsProviders ?? []),
+                    ...(skillsProvidersForLock ?? []),
+                ])
+                : (skillsProvidersForLock ?? existingEntry?.skillsProviders)
             : existingEntry?.skillsProviders;
         const lockSkillRenameMap = shouldImportSkills
-            ? normalizeSkillRenameMap(importedSkillRenameMap)
+            ? shouldMergeSkillOnlyEntry
+                ? mergeSkillRenameMaps(existingEntry?.skillRenameMap, importedSkillRenameMap)
+                : normalizeSkillRenameMap(importedSkillRenameMap)
             : existingEntry?.skillRenameMap;
         let lockCommandRenameMap;
         if (shouldImportCommands) {
@@ -553,7 +691,12 @@ export async function importSource(options) {
             lockCommandRenameMap = existingEntry?.commandRenameMap;
         }
         const lockRequestedAgents = shouldImportAgents
-            ? selection.requestedAgentsForLock
+            ? shouldMergeAgentOnlyEntry
+                ? uniqueStrings([
+                    ...(existingEntry?.requestedAgents ?? []),
+                    ...(selection.requestedAgentsForLock ?? []),
+                ])
+                : selection.requestedAgentsForLock
             : existingEntry?.requestedAgents;
         const trackedEntities = computeTrackedEntitiesForLock({
             requestedAgents: lockRequestedAgents,
@@ -1305,18 +1448,171 @@ function findMatchingLockEntry(entries, key) {
             wildcardWhenRightIsUndefined: true,
         }));
 }
-function findRelaxedCommandEntry(entries, key) {
+function findRelaxedEntityEntries(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.importedRules.length > 0 ||
-        entry.importedSkills.length > 0);
-    return mixed ?? matches[0];
+        (key.entity === "agent" ||
+            sameRequestedAgentsForMatch(entry.requestedAgents, key.requestedAgents)));
+    if (matches.length <= 1)
+        return matches;
+    return [...matches].sort((left, right) => {
+        const leftMixed = isMixedEntryForEntity(left, key.entity) ? 1 : 0;
+        const rightMixed = isMixedEntryForEntity(right, key.entity) ? 1 : 0;
+        if (leftMixed !== rightMixed) {
+            return rightMixed - leftMixed;
+        }
+        const leftScore = scoreEntryForEntity(left, key.entity);
+        const rightScore = scoreEntryForEntity(right, key.entity);
+        if (leftScore !== rightScore) {
+            return rightScore - leftScore;
+        }
+        return 0;
+    });
+}
+function isMixedEntryForEntity(entry, entity) {
+    return ((entity !== "agent" &&
+        (entry.importedAgents.length > 0 ||
+            (entry.requestedAgents?.length ?? 0) > 0)) ||
+        (entity !== "command" &&
+            (entry.importedCommands.length > 0 ||
+                (entry.selectedSourceCommands?.length ?? 0) > 0 ||
+                Object.keys(entry.commandRenameMap ?? {}).length > 0)) ||
+        (entity !== "mcp" &&
+            (entry.importedMcpServers.length > 0 ||
+                (entry.selectedSourceMcpServers?.length ?? 0) > 0)) ||
+        (entity !== "rule" &&
+            (entry.importedRules.length > 0 ||
+                (entry.selectedSourceRules?.length ?? 0) > 0 ||
+                Object.keys(entry.ruleRenameMap ?? {}).length > 0)) ||
+        (entity !== "skill" &&
+            (entry.importedSkills.length > 0 ||
+                (entry.selectedSourceSkills?.length ?? 0) > 0 ||
+                (entry.skillsProviders?.length ?? 0) > 0 ||
+                Object.keys(entry.skillRenameMap ?? {}).length > 0)));
+}
+function scoreEntryForEntity(entry, entity) {
+    if (entity === "agent") {
+        return (entry.importedAgents.length * 100 + (entry.requestedAgents?.length ?? 0));
+    }
+    if (entity === "command") {
+        return (entry.importedCommands.length * 100 +
+            (entry.selectedSourceCommands?.length ?? 0) * 10 +
+            Object.keys(entry.commandRenameMap ?? {}).length);
+    }
+    if (entity === "mcp") {
+        return (entry.importedMcpServers.length * 100 +
+            (entry.selectedSourceMcpServers?.length ?? 0) * 10);
+    }
+    if (entity === "rule") {
+        return (entry.importedRules.length * 100 +
+            (entry.selectedSourceRules?.length ?? 0) * 10 +
+            Object.keys(entry.ruleRenameMap ?? {}).length);
+    }
+    return (entry.importedSkills.length * 100 +
+        (entry.selectedSourceSkills?.length ?? 0) * 10 +
+        (entry.skillsProviders?.length ?? 0) * 3 +
+        Object.keys(entry.skillRenameMap ?? {}).length);
+}
+function mergeRelaxedEntityEntriesForLock(options) {
+    if (options.redundantEntries.length === 0) {
+        return options.canonicalEntry;
+    }
+    let mergedEntry = {
+        ...options.canonicalEntry,
+    };
+    if (options.entity === "agent") {
+        const mergedRequestedAgents = uniqueStrings([
+            ...(mergedEntry.requestedAgents ?? []),
+            ...options.redundantEntries.flatMap((entry) => entry.requestedAgents ?? []),
+        ]);
+        mergedEntry = {
+            ...mergedEntry,
+            importedAgents: uniqueStrings([
+                ...mergedEntry.importedAgents,
+                ...options.redundantEntries.flatMap((entry) => entry.importedAgents),
+            ]),
+            requestedAgents: mergedRequestedAgents.length > 0 ? mergedRequestedAgents : undefined,
+        };
+    }
+    else if (options.entity === "command") {
+        const mergedSelectedSourceCommands = uniqueStrings([
+            ...(mergedEntry.selectedSourceCommands ?? []),
+            ...options.redundantEntries.flatMap((entry) => entry.selectedSourceCommands ?? []),
+        ]);
+        const mergedCommandRenameMap = Object.assign({}, mergedEntry.commandRenameMap ?? {}, ...options.redundantEntries.map((entry) => entry.commandRenameMap ?? {}));
+        mergedEntry = {
+            ...mergedEntry,
+            importedCommands: uniqueStrings([
+                ...mergedEntry.importedCommands,
+                ...options.redundantEntries.flatMap((entry) => entry.importedCommands),
+            ]),
+            selectedSourceCommands: mergedSelectedSourceCommands.length > 0
+                ? mergedSelectedSourceCommands
+                : undefined,
+            commandRenameMap: normalizeCommandRenameMap(mergedCommandRenameMap),
+        };
+    }
+    else if (options.entity === "mcp") {
+        const mergedSelectedSourceMcpServers = uniqueStrings([
+            ...(mergedEntry.selectedSourceMcpServers ?? []),
+            ...options.redundantEntries.flatMap((entry) => entry.selectedSourceMcpServers ?? []),
+        ]);
+        mergedEntry = {
+            ...mergedEntry,
+            importedMcpServers: uniqueStrings([
+                ...mergedEntry.importedMcpServers,
+                ...options.redundantEntries.flatMap((entry) => entry.importedMcpServers),
+            ]),
+            selectedSourceMcpServers: mergedSelectedSourceMcpServers.length > 0
+                ? mergedSelectedSourceMcpServers
+                : undefined,
+        };
+    }
+    else if (options.entity === "rule") {
+        const mergedSelectedSourceRules = uniqueStrings([
+            ...(mergedEntry.selectedSourceRules ?? []),
+            ...options.redundantEntries.flatMap((entry) => entry.selectedSourceRules ?? []),
+        ]);
+        const mergedRuleRenameMap = Object.assign({}, mergedEntry.ruleRenameMap ?? {}, ...options.redundantEntries.map((entry) => entry.ruleRenameMap ?? {}));
+        mergedEntry = {
+            ...mergedEntry,
+            importedRules: uniqueStrings([
+                ...mergedEntry.importedRules,
+                ...options.redundantEntries.flatMap((entry) => entry.importedRules),
+            ]),
+            selectedSourceRules: mergedSelectedSourceRules.length > 0
+                ? mergedSelectedSourceRules
+                : undefined,
+            ruleRenameMap: normalizeRuleRenameMap(mergedRuleRenameMap),
+        };
+    }
+    else {
+        const mergedSelectedSourceSkills = uniqueStrings([
+            ...(mergedEntry.selectedSourceSkills ?? []),
+            ...options.redundantEntries.flatMap((entry) => entry.selectedSourceSkills ?? []),
+        ]);
+        const mergedSkillsProviders = normalizeSkillsProviders([
+            ...(mergedEntry.skillsProviders ?? []),
+            ...options.redundantEntries.flatMap((entry) => entry.skillsProviders ?? []),
+        ]);
+        const mergedSkillRenameMap = Object.assign({}, mergedEntry.skillRenameMap ?? {}, ...options.redundantEntries.map((entry) => entry.skillRenameMap ?? {}));
+        mergedEntry = {
+            ...mergedEntry,
+            importedSkills: uniqueStrings([
+                ...mergedEntry.importedSkills,
+                ...options.redundantEntries.flatMap((entry) => entry.importedSkills),
+            ]),
+            selectedSourceSkills: mergedSelectedSourceSkills.length > 0
+                ? mergedSelectedSourceSkills
+                : undefined,
+            skillsProviders: mergedSkillsProviders && mergedSkillsProviders.length > 0
+                ? mergedSkillsProviders
+                : undefined,
+            skillRenameMap: normalizeSkillRenameMap(mergedSkillRenameMap),
+        };
+    }
+    return mergedEntry;
 }
 function sameRequestedAgentsForMatch(left, right) {
     const normalizedLeft = normalizeRequestedAgentsForMatch(left);
@@ -1421,6 +1717,13 @@ function mergeCommandRenameMaps(existing, updates) {
     };
     return normalizeCommandRenameMap(merged);
 }
+function mergeRuleRenameMaps(existing, updates) {
+    const merged = {
+        ...(existing ?? {}),
+        ...(updates ?? {}),
+    };
+    return normalizeRuleRenameMap(merged);
+}
 function resolveMappedTargetFileName(sourceFileName, renameMap) {
     if (!renameMap)
         return undefined;
@@ -1495,6 +1798,53 @@ function normalizeSkillRenameMap(renameMap) {
         return undefined;
     return Object.fromEntries(normalizedEntries);
 }
+function mergeSkillRenameMaps(existing, updates) {
+    const merged = {
+        ...(existing ?? {}),
+        ...(updates ?? {}),
+    };
+    return normalizeSkillRenameMap(merged);
+}
+function mergeImportedSkills(options) {
+    if (!options.existingImportedSkills ||
+        options.existingImportedSkills.length === 0) {
+        return [...options.importedSkills];
+    }
+    const coveredSelectors = new Set();
+    for (const skill of options.selectedSkills) {
+        const byName = normalizeSkillSelector(skill.name);
+        if (byName)
+            coveredSelectors.add(byName);
+        const bySourceDir = normalizeSkillSelector(skill.sourceDirName);
+        if (bySourceDir)
+            coveredSelectors.add(bySourceDir);
+    }
+    if (coveredSelectors.size === 0) {
+        return [...options.importedSkills];
+    }
+    const selectedImportedTargets = new Set();
+    for (const [sourceSelector, importedName] of Object.entries(options.existingSkillRenameMap ?? {})) {
+        const normalizedSourceSelector = normalizeSkillSelector(sourceSelector);
+        const normalizedImportedName = normalizeSkillSelector(importedName);
+        if (!normalizedSourceSelector ||
+            !normalizedImportedName ||
+            !coveredSelectors.has(normalizedSourceSelector)) {
+            continue;
+        }
+        selectedImportedTargets.add(normalizedImportedName);
+    }
+    const retained = options.existingImportedSkills.filter((importedSkillName) => {
+        const selector = normalizeSkillSelector(importedSkillName);
+        if (!selector)
+            return true;
+        if (coveredSelectors.has(selector))
+            return false;
+        if (selectedImportedTargets.has(selector))
+            return false;
+        return true;
+    });
+    return uniqueStrings([...retained, ...options.importedSkills]);
+}
 function resolveMappedTargetSkillName(sourceSkill, selectedSkills, renameMap) {
     if (!renameMap)
         return undefined;

package/dist/core/migration.js

@@ -914,6 +914,15 @@ async function migrateMcp(options, summary) {
         writeCanonicalMcp(options.paths, merged);
     }
 }
+const MANAGED_MCP_CANONICAL_KEYS_BY_PROVIDER = {
+    cursor: ["url", "command", "args", "env"],
+    claude: ["type", "url", "command", "args", "env"],
+    codex: ["url", "command", "args", "env"],
+    opencode: ["url", "command", "args", "env"],
+    gemini: ["url", "command", "args", "env"],
+    copilot: ["type", "url", "command", "args", "env", "tools"],
+    pi: ["url", "command", "args", "env"],
+};
 function collectProviderMcpServers(paths, providers) {
     let detected = 0;
     const servers = new Map();
@@ -930,13 +939,13 @@ function collectProviderMcpServers(paths, providers) {
 }
 function readProviderMcp(paths, provider) {
     if (provider === "cursor") {
-        return readJsonMcpServers(getCursorMcpPath(paths));
+        return readJsonMcpServers(getCursorMcpPath(paths), provider);
     }
     if (provider === "claude") {
-        return readJsonMcpServers(getClaudeMcpPath(paths));
+        return readJsonMcpServers(getClaudeMcpPath(paths), provider);
     }
     if (provider === "copilot") {
-        return readJsonMcpServers(getCopilotMcpPath(paths));
+        return readJsonMcpServers(getCopilotMcpPath(paths), provider);
     }
     if (provider === "opencode") {
         return readOpenCodeMcp(getOpenCodeConfigPath(paths));
@@ -948,16 +957,16 @@ function readProviderMcp(paths, provider) {
         return readCodexMcp(getCodexConfigPath(paths));
     }
     if (provider === "pi") {
-        return readJsonMcpServers(getPiMcpPath(paths));
+        return readJsonMcpServers(getPiMcpPath(paths), provider);
     }
     return {};
 }
-function readJsonMcpServers(filePath) {
+function readJsonMcpServers(filePath, provider) {
     const parsed = readJsonIfExists(filePath);
     if (!parsed || !isObject(parsed.mcpServers)) {
         return {};
     }
-    return normalizeMcpServerRecord(parsed.mcpServers);
+    return normalizeManagedMcpServerRecord(parsed.mcpServers, MANAGED_MCP_CANONICAL_KEYS_BY_PROVIDER[provider]);
 }
 function readOpenCodeMcp(filePath) {
     const parsed = readJsonIfExists(filePath);
@@ -1013,17 +1022,31 @@ function readCodexMcp(filePath) {
     const parsed = raw.trim() ? TOML.parse(raw) : {};
     if (!isObject(parsed.mcp_servers))
         return {};
-    return normalizeMcpServerRecord(parsed.mcp_servers);
+    return normalizeManagedMcpServerRecord(parsed.mcp_servers, MANAGED_MCP_CANONICAL_KEYS_BY_PROVIDER.codex);
 }
-function normalizeMcpServerRecord(raw) {
+function normalizeManagedMcpServerRecord(raw, allowedKeys) {
     const servers = {};
     for (const [name, config] of Object.entries(raw)) {
-        if (!isObject(config))
+        const normalized = pickManagedMcpFields(config, allowedKeys);
+        if (!normalized)
             continue;
-        servers[name] = cloneRecord(config);
+        servers[name] = normalized;
     }
     return servers;
 }
+function pickManagedMcpFields(config, allowedKeys) {
+    if (!isObject(config)) {
+        return null;
+    }
+    const next = {};
+    for (const key of allowedKeys) {
+        const value = config[key];
+        if (value !== undefined) {
+            next[key] = cloneRecord(value);
+        }
+    }
+    return Object.keys(next).length > 0 ? next : null;
+}
 function normalizeCanonicalServer(server) {
     if (!server) {
         return {

package/dist/core/router.js

@@ -21,6 +21,9 @@ const ENTITY_NOUN_ALIASES = {
     rules: "rule",
     skills: "skill",
 };
+const VERB_ALIASES = {
+    remove: "delete",
+};
 const ENTITY_VERBS = new Set([
     "add",
     "list",
@@ -34,7 +37,7 @@ export function parseCommandRoute(argv) {
     const rawRoot = argv[0]?.trim().toLowerCase();
     if (!rawRoot)
         return null;
-    const root = ENTITY_NOUN_ALIASES[rawRoot] ?? rawRoot;
+    const root = ENTITY_NOUN_ALIASES[rawRoot] ?? VERB_ALIASES[rawRoot] ?? rawRoot;
     if (AGGREGATE_VERBS.has(root)) {
         return {
             mode: "aggregate",
@@ -44,7 +47,8 @@ export function parseCommandRoute(argv) {
     if (!ENTITY_NOUNS.has(root)) {
         return null;
     }
-    const action = argv[1]?.trim().toLowerCase();
+    const rawAction = argv[1]?.trim().toLowerCase();
+    const action = rawAction ? (VERB_ALIASES[rawAction] ?? rawAction) : rawAction;
     if (!action || action === "--help" || action === "-h" || action === "help") {
         return {
             mode: "entity",
@@ -53,7 +57,10 @@ export function parseCommandRoute(argv) {
         };
     }
     if (root === "mcp" && action === "server") {
-        const serverVerb = argv[2]?.trim().toLowerCase();
+        const rawServerVerb = argv[2]?.trim().toLowerCase();
+        const serverVerb = rawServerVerb
+            ? (VERB_ALIASES[rawServerVerb] ?? rawServerVerb)
+            : rawServerVerb;
         if (!serverVerb ||
             serverVerb === "--help" ||
             serverVerb === "-h" ||

package/dist/sync/index.js

@@ -361,8 +361,10 @@ function syncProviderMcp(options) {
         const resolved = resolveMcpForProvider(options.mcp, provider);
         if (provider === "cursor") {
             const outputPath = getCursorMcpPath(options.paths);
+            const existing = readJsonIfExists(outputPath) ?? {};
             const payload = {
-                mcpServers: mapMcpServers(resolved, ["url", "command", "args", "env"]),
+                ...existing,
+                mcpServers: mergeManagedMcpServerEntries(existing.mcpServers, mapMcpServers(resolved, ["url", "command", "args", "env"]), ["url", "command", "args", "env"]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -381,19 +383,24 @@ function syncProviderMcp(options) {
                 continue;
             }
             const mcpPath = getClaudeMcpPath(options.paths);
-            const claudeServers = mapMcpServers(resolved, [
+            const existingMcp = readJsonIfExists(mcpPath) ?? {};
+            const managedClaudeServers = mapMcpServers(resolved, [
                 "type",
                 "url",
                 "command",
                 "args",
                 "env",
             ]);
-            for (const [serverName, config] of Object.entries(claudeServers)) {
+            for (const [serverName, config] of Object.entries(managedClaudeServers)) {
                 if (!("type" in config) && typeof config.url === "string") {
                     config.type = "http";
                 }
             }
-            maybeWriteJson(mcpPath, { mcpServers: claudeServers }, options.dryRun);
+            const claudeServers = mergeManagedMcpServerEntries(existingMcp.mcpServers, managedClaudeServers, ["type", "url", "command", "args", "env"]);
+            maybeWriteJson(mcpPath, {
+                ...existingMcp,
+                mcpServers: claudeServers,
+            }, options.dryRun);
             options.generated.add(mcpPath);
             settings.enabledMcpjsonServers = Object.keys(claudeServers).sort();
             maybeWriteJson(settingsPath, settings, options.dryRun);
@@ -403,28 +410,34 @@ function syncProviderMcp(options) {
         if (provider === "opencode") {
             const outputPath = getOpenCodeConfigPath(options.paths);
             const existing = readJsonIfExists(outputPath) ?? {};
-            const mcp = {};
+            const managedMcp = {};
             for (const [serverName, config] of Object.entries(resolved)) {
                 if (typeof config.url === "string") {
-                    mcp[serverName] = {
+                    managedMcp[serverName] = {
                         type: "remote",
                         url: config.url,
                     };
                 }
                 else {
-                    mcp[serverName] = {
+                    managedMcp[serverName] = {
                         type: "local",
                         command: config.command,
                         args: Array.isArray(config.args) ? config.args : undefined,
                     };
                 }
                 if (isObject(config.env)) {
-                    mcp[serverName].environment = config.env;
+                    managedMcp[serverName].environment = config.env;
                 }
             }
             const payload = {
                 ...existing,
-                mcp,
+                mcp: mergeManagedMcpServerEntries(existing.mcp, managedMcp, [
+                    "type",
+                    "url",
+                    "command",
+                    "args",
+                    "environment",
+                ]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -453,7 +466,7 @@ function syncProviderMcp(options) {
             const payload = {
                 ...existing,
                 experimental,
-                mcpServers,
+                mcpServers: mergeManagedMcpServerEntries(existing.mcpServers, mcpServers, ["httpUrl", "command", "args", "env"]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -461,6 +474,8 @@ function syncProviderMcp(options) {
         }
         if (provider === "copilot") {
             const profileMcpPath = getCopilotMcpPath(options.paths);
+            const managedKeys = ["type", "url", "command", "args", "env", "tools"];
+            const existingProfileMcp = readJsonIfExists(profileMcpPath) ?? {};
             const copilotServers = mapMcpServers(resolved, [
                 "type",
                 "url",
@@ -477,20 +492,25 @@ function syncProviderMcp(options) {
                     config.type = config.url ? "http" : "local";
                 }
             }
-            maybeWriteJson(profileMcpPath, { mcpServers: copilotServers }, options.dryRun);
+            maybeWriteJson(profileMcpPath, {
+                ...existingProfileMcp,
+                mcpServers: mergeManagedMcpServerEntries(existingProfileMcp.mcpServers, copilotServers, managedKeys),
+            }, options.dryRun);
             options.generated.add(profileMcpPath);
             if (options.paths.scope === "global") {
                 const settingsPath = getVsCodeSettingsPath(options.paths.homeDir);
                 const settings = readJsonIfExists(settingsPath) ?? {};
-                settings["mcp.servers"] = copilotServers;
+                settings["mcp.servers"] = mergeManagedMcpServerEntries(settings["mcp.servers"], copilotServers, managedKeys);
                 maybeWriteJson(settingsPath, settings, options.dryRun);
                 options.generated.add(settingsPath);
             }
         }
         if (provider === "pi") {
             const outputPath = getPiMcpPath(options.paths);
+            const existing = readJsonIfExists(outputPath) ?? {};
             const payload = {
-                mcpServers: mapMcpServers(resolved, ["url", "command", "args", "env"]),
+                ...existing,
+                mcpServers: mergeManagedMcpServerEntries(existing.mcpServers, mapMcpServers(resolved, ["url", "command", "args", "env"]), ["url", "command", "args", "env"]),
             };
             maybeWriteJson(outputPath, payload, options.dryRun);
             options.generated.add(outputPath);
@@ -813,22 +833,19 @@ function syncCodex(options) {
     let nextServers = [...trackedServers];
     if (options.includeMcp) {
         const previousServers = new Set(trackedServers);
+        const managedCodexMcpServers = mapMcpServers(options.resolvedMcp, [
+            "url",
+            "command",
+            "args",
+            "env",
+        ]);
         for (const oldServer of previousServers) {
             if (!Object.prototype.hasOwnProperty.call(options.resolvedMcp, oldServer)) {
                 delete mcpServers[oldServer];
             }
         }
-        for (const [serverName, config] of Object.entries(options.resolvedMcp)) {
-            const mapped = {};
-            if (typeof config.url === "string")
-                mapped.url = config.url;
-            if (typeof config.command === "string")
-                mapped.command = config.command;
-            if (Array.isArray(config.args))
-                mapped.args = config.args;
-            if (isObject(config.env))
-                mapped.env = config.env;
-            mcpServers[serverName] = mapped;
+        for (const [serverName, config] of Object.entries(managedCodexMcpServers)) {
+            mcpServers[serverName] = mergeManagedMcpServerEntry(mcpServers[serverName], config, ["url", "command", "args", "env"]);
         }
         parsed.mcp_servers = mcpServers;
         nextServers = Object.keys(options.resolvedMcp).sort();
@@ -895,6 +912,28 @@ function mapMcpServers(servers, allowedKeys) {
     }
     return mapped;
 }
+function mergeManagedMcpServerEntries(existingServers, nextServers, managedKeys) {
+    const merged = {};
+    for (const [serverName, config] of Object.entries(nextServers)) {
+        merged[serverName] = mergeManagedMcpServerEntry(isObject(existingServers) ? existingServers[serverName] : undefined, config, managedKeys);
+    }
+    return merged;
+}
+function mergeManagedMcpServerEntry(existingConfig, nextConfig, managedKeys) {
+    const merged = isObject(existingConfig) ? cloneSyncValue(existingConfig) : {};
+    for (const key of managedKeys) {
+        delete merged[key];
+    }
+    for (const [key, value] of Object.entries(nextConfig)) {
+        if (value !== undefined) {
+            merged[key] = cloneSyncValue(value);
+        }
+    }
+    return merged;
+}
+function cloneSyncValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
 function maybeWriteJson(filePath, payload, dryRun) {
     if (dryRun)
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentloom",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Unified agent and MCP sync CLI for multi-provider AI tooling",
   "type": "module",
   "bin": {