agentloom 0.1.8 → 0.1.9

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";
@@ -136,7 +137,11 @@ 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,
+            });
             updated += 1;
         }
         catch (err) {

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/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/package.json

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