agentloom 0.1.4 → 0.1.6

package/dist/core/migration.js

@@ -4,15 +4,18 @@ import { isDeepStrictEqual } from "node:util";
 import { cancel, isCancel, select } from "@clack/prompts";
 import TOML from "@iarna/toml";
 import matter from "gray-matter";
+import YAML from "yaml";
 import { buildAgentMarkdown, parseAgentsDir } from "./agents.js";
-import { parseCommandsDir } from "./commands.js";
+import { normalizeCommandArgumentsForCanonical, parseCommandsDir, } from "./commands.js";
 import { ensureDir, isObject, readJsonIfExists, slugify } from "./fs.js";
 import { readLockfile, writeLockfile } from "./lockfile.js";
 import { readManifest, writeManifest } from "./manifest.js";
 import { readCanonicalMcp, writeCanonicalMcp } from "./mcp.js";
-import { getClaudeMcpPath, getCodexConfigPath, getCopilotMcpPath, getCursorMcpPath, getGeminiSettingsPath, getOpenCodeConfigPath, getPiMcpPath, getProviderAgentsDir, getProviderCommandsDir, getProviderSkillsPaths, } from "./provider-paths.js";
+import { getClaudeMcpPath, getCodexConfigPath, getCopilotMcpPath, getCursorRulesDir, getCursorMcpPath, getGeminiSettingsPath, getOpenCodeConfigPath, getPiMcpPath, getProviderAgentsDir, getProviderCommandsDir, getRuleInstructionPaths, getProviderSkillsPaths, } from "./provider-paths.js";
 import { readSettings, writeSettings } from "./settings.js";
-import { applySkillProviderSideEffects, copySkillArtifacts, parseSkillsDir, skillContentMatchesTarget, } from "./skills.js";
+import { applySkillProviderSideEffects, copySkillArtifacts, getLegacyCopilotSkillDirs, parseSkillsDir, skillContentMatchesTarget, } from "./skills.js";
+import { parseManagedRuleBlocks, parseRuleMarkdown, stripRuleFileExtension, } from "./rules.js";
+import { isProviderEntityFileName } from "./provider-entity-validation.js";
 import { ALL_PROVIDERS } from "../types.js";
 const PROVIDER_NAME_KEYS = new Set(ALL_PROVIDERS);
 export class MigrationConflictError extends Error {
@@ -29,6 +32,7 @@ export function createEmptyMigrationSummary(providers, target) {
             agent: { detected: 0, imported: 0, conflicts: 0, skipped: 0 },
             command: { detected: 0, imported: 0, conflicts: 0, skipped: 0 },
             mcp: { detected: 0, imported: 0, conflicts: 0, skipped: 0 },
+            rule: { detected: 0, imported: 0, conflicts: 0, skipped: 0 },
             skill: { detected: 0, imported: 0, conflicts: 0, skipped: 0 },
         },
     };
@@ -37,6 +41,7 @@ export function initializeCanonicalLayout(paths, providers) {
     ensureDir(paths.agentsRoot);
     ensureDir(paths.agentsDir);
     ensureDir(paths.commandsDir);
+    ensureDir(paths.rulesDir);
     ensureDir(paths.skillsDir);
     if (!fs.existsSync(paths.mcpPath)) {
         writeCanonicalMcp({ mcpPath: paths.mcpPath }, { version: 1, mcpServers: {} });
@@ -84,6 +89,9 @@ export async function migrateProviderStateToCanonical(options) {
     if (includesTarget(options.target, "mcp")) {
         await migrateMcp(options, summary.entities.mcp);
     }
+    if (includesTarget(options.target, "rule")) {
+        await migrateRules(options, summary.entities.rule);
+    }
     if (includesTarget(options.target, "skill")) {
         await migrateSkills(options, summary.entities.skill);
     }
@@ -91,7 +99,7 @@ export async function migrateProviderStateToCanonical(options) {
 }
 export function formatMigrationSummary(summary) {
     const lines = ["Migration summary (provider -> canonical):"];
-    for (const entity of ["agent", "command", "mcp", "skill"]) {
+    for (const entity of ["agent", "command", "mcp", "rule", "skill"]) {
         const row = summary.entities[entity];
         lines.push(`${entity}: detected=${row.detected}, imported=${row.imported}, conflicts=${row.conflicts}, skipped=${row.skipped}`);
     }
@@ -102,8 +110,13 @@ async function migrateAgents(options, summary) {
     const canonicalByKey = new Map();
     for (const agent of canonicalAgents) {
         const key = agentKey(agent.name, agent.fileName);
-        if (!canonicalByKey.has(key)) {
-            canonicalByKey.set(key, agent);
+        // Always let file-derived keys win over name aliases from earlier entries.
+        canonicalByKey.set(key, agent);
+    }
+    for (const agent of canonicalAgents) {
+        const nameKey = slugify(agent.name);
+        if (nameKey && !canonicalByKey.has(nameKey)) {
+            canonicalByKey.set(nameKey, agent);
         }
     }
     const recordsByKey = new Map();
@@ -118,10 +131,11 @@ async function migrateAgents(options, summary) {
             recordsByKey.set(record.key, next);
         }
     }
+    mergeAgentRecordsByName(recordsByKey);
     for (const [key, records] of recordsByKey.entries()) {
         if (records.length === 0)
             continue;
-        const canonical = canonicalByKey.get(key);
+        const canonical = resolveCanonicalAgentForMerge(canonicalByKey, key, records);
         const existingRaw = canonical
             ? fs.readFileSync(canonical.sourcePath, "utf8")
             : null;
@@ -152,41 +166,192 @@ async function migrateAgents(options, summary) {
         summary.imported += 1;
     }
 }
+function mergeAgentRecordsByName(recordsByKey) {
+    const groupKeyByName = new Map();
+    for (const [key, records] of [...recordsByKey.entries()]) {
+        if (!recordsByKey.has(key))
+            continue;
+        let targetKey = key;
+        for (const record of records) {
+            const nameKey = slugify(record.name);
+            if (!nameKey)
+                continue;
+            const existingKey = groupKeyByName.get(nameKey);
+            if (!existingKey || existingKey === targetKey) {
+                groupKeyByName.set(nameKey, targetKey);
+                continue;
+            }
+            const existing = recordsByKey.get(existingKey) ?? [];
+            const current = recordsByKey.get(targetKey) ?? [];
+            existing.push(...current);
+            recordsByKey.set(existingKey, existing);
+            recordsByKey.delete(targetKey);
+            targetKey = existingKey;
+            targetKey = rekeyMergedAgentGroup(recordsByKey, targetKey, nameKey);
+            groupKeyByName.set(nameKey, targetKey);
+        }
+        const merged = recordsByKey.get(targetKey) ?? [];
+        for (const record of merged) {
+            const nameKey = slugify(record.name);
+            if (nameKey) {
+                groupKeyByName.set(nameKey, targetKey);
+            }
+        }
+    }
+}
+function rekeyMergedAgentGroup(recordsByKey, currentKey, nameKey) {
+    if (!nameKey || currentKey === nameKey) {
+        return currentKey;
+    }
+    const current = recordsByKey.get(currentKey);
+    if (!current) {
+        return currentKey;
+    }
+    const existingNameKeyGroup = recordsByKey.get(nameKey);
+    if (existingNameKeyGroup && existingNameKeyGroup !== current) {
+        existingNameKeyGroup.push(...current);
+        recordsByKey.set(nameKey, existingNameKeyGroup);
+    }
+    else {
+        recordsByKey.set(nameKey, current);
+    }
+    recordsByKey.delete(currentKey);
+    return nameKey;
+}
+function resolveCanonicalAgentForMerge(canonicalByKey, key, records) {
+    const direct = canonicalByKey.get(key);
+    if (direct) {
+        return direct;
+    }
+    for (const record of records) {
+        const nameKey = slugify(record.name);
+        if (!nameKey)
+            continue;
+        const match = canonicalByKey.get(nameKey);
+        if (match) {
+            return match;
+        }
+    }
+    return undefined;
+}
 function readMarkdownProviderAgents(paths, provider) {
-    const dirPath = getProviderAgentsDir(paths, provider);
+    const records = [];
+    const seenSourcePaths = new Set();
+    const candidateDirs = [
+        {
+            path: getProviderAgentsDir(paths, provider),
+            sourcePriority: 0,
+            fallback: false,
+        },
+    ];
+    // Keep backward compatibility with historical global Copilot output.
+    if (provider === "copilot" && paths.scope === "global") {
+        candidateDirs.push({
+            path: path.join(paths.homeDir, ".github", "agents"),
+            sourcePriority: 1,
+            fallback: true,
+        });
+        candidateDirs.push({
+            path: path.join(paths.homeDir, ".vscode", "chatmodes"),
+            sourcePriority: 2,
+            fallback: true,
+        });
+    }
+    const entriesByPath = new Map();
+    for (const candidateDir of candidateDirs) {
+        entriesByPath.set(candidateDir.path, listProviderAgentEntries(candidateDir.path, provider));
+    }
+    for (const candidateDir of candidateDirs) {
+        const dirPath = candidateDir.path;
+        const entries = entriesByPath.get(dirPath) ?? [];
+        for (const fileName of entries) {
+            const sourcePath = path.join(dirPath, fileName);
+            if (seenSourcePaths.has(sourcePath))
+                continue;
+            seenSourcePaths.add(sourcePath);
+            const raw = fs.readFileSync(sourcePath, "utf8");
+            const parsed = matter(raw);
+            const data = isObject(parsed.data) ? parsed.data : {};
+            const parsedName = typeof data.name === "string" && data.name.trim().length > 0
+                ? data.name.trim()
+                : guessAgentNameFromFile(fileName);
+            const parsedDescription = typeof data.description === "string" &&
+                data.description.trim().length > 0
+                ? data.description.trim()
+                : `Migrated from ${provider}`;
+            const nameKey = providerAgentNameKey(parsedName, fileName);
+            const key = agentKey(parsedName, fileName);
+            const providerConfig = extractProviderConfigFromAgentFrontmatter(data, provider);
+            records.push({
+                provider,
+                sourcePath,
+                fileName,
+                sourcePriority: candidateDir.sourcePriority,
+                nameKey,
+                key,
+                name: parsedName,
+                description: parsedDescription,
+                body: parsed.content.trimStart(),
+                providerConfig,
+            });
+        }
+    }
+    return dedupeProviderAgentRecords(records);
+}
+function listProviderAgentEntries(dirPath, provider) {
     if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
         return [];
     }
-    const entries = fs
+    return fs
         .readdirSync(dirPath, { withFileTypes: true })
         .filter((entry) => entry.isFile())
         .map((entry) => entry.name)
-        .filter((name) => name.toLowerCase().endsWith(".md"))
+        .filter((name) => isProviderEntityFileName({
+        provider,
+        entity: "agent",
+        fileName: name,
+    }))
         .sort();
-    const records = [];
-    for (const fileName of entries) {
-        const sourcePath = path.join(dirPath, fileName);
-        const raw = fs.readFileSync(sourcePath, "utf8");
-        const parsed = matter(raw);
-        const data = isObject(parsed.data) ? parsed.data : {};
-        const parsedName = typeof data.name === "string" && data.name.trim().length > 0
-            ? data.name.trim()
-            : guessAgentNameFromFile(fileName);
-        const parsedDescription = typeof data.description === "string" && data.description.trim().length > 0
-            ? data.description.trim()
-            : `Migrated from ${provider}`;
-        const providerConfig = extractProviderConfigFromAgentFrontmatter(data, provider);
-        records.push({
-            provider,
-            sourcePath,
-            key: agentKey(parsedName, fileName),
-            name: parsedName,
-            description: parsedDescription,
-            body: parsed.content.trimStart(),
-            providerConfig,
-        });
+}
+function providerAgentNameKey(name, fileName) {
+    return slugify(name) || agentFileKey(fileName);
+}
+function dedupeProviderAgentRecords(records) {
+    const recordsByName = new Map();
+    for (const record of records) {
+        const next = recordsByName.get(record.nameKey) ?? [];
+        next.push(record);
+        recordsByName.set(record.nameKey, next);
     }
-    return records;
+    const deduped = [];
+    for (const [nameKey, bucket] of recordsByName.entries()) {
+        if (bucket.length === 1) {
+            deduped.push(bucket[0]);
+            continue;
+        }
+        const ranked = [...bucket].sort(compareProviderAgentCollisionPriority);
+        const winner = ranked[0];
+        const ignored = ranked.slice(1).map((record) => record.sourcePath);
+        console.warn(`Warning: Duplicate ${winner.provider} agents share canonical name "${nameKey}". Keeping ${winner.sourcePath} and ignoring ${ignored.join(", ")}.`);
+        deduped.push(winner);
+    }
+    return deduped.sort((a, b) => a.key.localeCompare(b.key) || a.sourcePath.localeCompare(b.sourcePath));
+}
+function compareProviderAgentCollisionPriority(left, right) {
+    if (left.sourcePriority !== right.sourcePriority) {
+        return left.sourcePriority - right.sourcePriority;
+    }
+    const leftFileMatchesName = isProviderAgentFileAlignedWithName(left) ? 0 : 1;
+    const rightFileMatchesName = isProviderAgentFileAlignedWithName(right)
+        ? 0
+        : 1;
+    if (leftFileMatchesName !== rightFileMatchesName) {
+        return leftFileMatchesName - rightFileMatchesName;
+    }
+    return left.sourcePath.localeCompare(right.sourcePath);
+}
+function isProviderAgentFileAlignedWithName(record) {
+    return agentFileKey(record.fileName) === record.nameKey;
 }
 function readCodexProviderAgents(paths) {
     const configPath = getCodexConfigPath(paths);
@@ -215,13 +380,17 @@ function readCodexProviderAgents(paths) {
         const roleToml = roleTomlRaw.trim()
             ? TOML.parse(roleTomlRaw)
             : {};
+        const inlineInstructions = typeof roleToml.developer_instructions === "string"
+            ? roleToml.developer_instructions.trim()
+            : "";
         const instructionRef = roleToml.model_instructions_file;
         const instructionPath = typeof instructionRef === "string" && instructionRef.trim().length > 0
             ? resolveCodexPath(path.dirname(roleTomlPath), instructionRef)
             : null;
-        const body = instructionPath && fs.existsSync(instructionPath)
-            ? fs.readFileSync(instructionPath, "utf8").trimStart()
+        const fileInstructions = instructionPath && fs.existsSync(instructionPath)
+            ? fs.readFileSync(instructionPath, "utf8").trimStart().trimEnd()
             : "";
+        const body = inlineInstructions || fileInstructions;
         const description = isObject(roleEntry) && typeof roleEntry.description === "string"
             ? roleEntry.description.trim()
             : roleName;
@@ -232,19 +401,32 @@ function readCodexProviderAgents(paths) {
         if (typeof roleToml.model_reasoning_effort === "string") {
             providerConfig.reasoningEffort = roleToml.model_reasoning_effort;
         }
+        if (typeof roleToml.model_reasoning_summary === "string") {
+            providerConfig.reasoningSummary = roleToml.model_reasoning_summary;
+        }
+        if (typeof roleToml.model_verbosity === "string") {
+            providerConfig.verbosity = roleToml.model_verbosity;
+        }
         if (typeof roleToml.approval_policy === "string") {
             providerConfig.approvalPolicy = roleToml.approval_policy;
         }
         if (typeof roleToml.sandbox_mode === "string") {
             providerConfig.sandboxMode = roleToml.sandbox_mode;
         }
-        if (isObject(roleToml.tools) &&
+        if (typeof roleToml.web_search === "boolean") {
+            providerConfig.webSearch = roleToml.web_search;
+        }
+        if (typeof providerConfig.webSearch !== "boolean" &&
+            isObject(roleToml.tools) &&
             typeof roleToml.tools.web_search === "boolean") {
             providerConfig.webSearch = roleToml.tools.web_search;
         }
         records.push({
             provider: "codex",
             sourcePath: roleTomlPath,
+            fileName: `${roleName}.md`,
+            sourcePriority: 0,
+            nameKey: providerAgentNameKey(roleName, `${roleName}.md`),
             key: agentKey(roleName, `${roleName}.md`),
             name: roleName,
             description: description || roleName,
@@ -279,17 +461,24 @@ function guessAgentNameFromFile(fileName) {
     const base = fileName.replace(/\.agent\.md$/i, "").replace(/\.md$/i, "");
     return base.trim() || "agent";
 }
+function agentFileKey(fileName) {
+    const normalizedFile = fileName
+        .replace(/\.agent\.md$/i, "")
+        .replace(/\.md$/i, "");
+    return slugify(normalizedFile);
+}
 function agentKey(name, fileName) {
-    return slugify(name) || slugify(fileName.replace(/\.md$/i, "")) || "agent";
+    return agentFileKey(fileName) || slugify(name) || "agent";
 }
 async function resolveAgentMerge(options) {
     const records = dedupeAgentRecords(options.records);
     if (records.length === 0) {
         return null;
     }
-    let name = options.canonical?.name ?? records[0].name;
-    let description = options.canonical?.description ?? records[0].description;
-    let body = options.canonical?.body ?? records[0].body;
+    const preferredRecord = choosePreferredProviderAgent(records);
+    let name = options.canonical?.name ?? preferredRecord.name;
+    let description = options.canonical?.description ?? preferredRecord.description;
+    let body = options.canonical?.body ?? preferredRecord.body;
     const frontmatter = options.canonical
         ? { ...options.canonical.frontmatter }
         : {
@@ -297,9 +486,8 @@ async function resolveAgentMerge(options) {
             description,
         };
     if (!options.canonical && records.length > 1) {
-        const first = records[0];
-        const different = records.some((record) => !sameAgentContent(first, record));
-        if (different) {
+        const allSameBody = records.every((record) => sameNormalizedBody(record.body, records[0].body));
+        if (!allSameBody) {
             options.onConflict();
             const chosen = await chooseProviderSource({
                 conflictLabel: `agent "${options.key}"`,
@@ -314,7 +502,7 @@ async function resolveAgentMerge(options) {
     }
     if (options.canonical) {
         for (const record of records) {
-            if (!sameAgentContent({ name, description, body }, record)) {
+            if (!sameNormalizedBody(record.body, body)) {
                 options.onConflict();
                 const decision = await resolveCanonicalConflict({
                     conflictLabel: `agent "${record.key}" from ${record.provider}`,
@@ -330,7 +518,14 @@ async function resolveAgentMerge(options) {
         }
     }
     for (const record of records) {
-        frontmatter[record.provider] = cloneRecord(record.providerConfig);
+        const providerConfig = cloneRecord(record.providerConfig);
+        if (record.name.trim() !== name.trim()) {
+            providerConfig.name = record.name;
+        }
+        if (record.description.trim() !== description.trim()) {
+            providerConfig.description = record.description;
+        }
+        frontmatter[record.provider] = providerConfig;
     }
     frontmatter.name = name;
     frontmatter.description = description;
@@ -343,6 +538,9 @@ async function resolveAgentMerge(options) {
         markdown,
     };
 }
+function choosePreferredProviderAgent(records) {
+    return records.find((record) => record.provider === "copilot") ?? records[0];
+}
 function dedupeAgentRecords(records) {
     const unique = [];
     for (const record of records) {
@@ -353,10 +551,8 @@ function dedupeAgentRecords(records) {
     }
     return unique;
 }
-function sameAgentContent(left, right) {
-    return (left.name.trim() === right.name.trim() &&
-        left.description.trim() === right.description.trim() &&
-        normalizeBody(left.body) === normalizeBody(right.body));
+function sameNormalizedBody(left, right) {
+    return normalizeBody(left) === normalizeBody(right);
 }
 async function migrateCommands(options, summary) {
     const canonicalCommands = parseCommandsDir(options.paths.commandsDir);
@@ -373,11 +569,12 @@ async function migrateCommands(options, summary) {
     }
     for (const [fileName, records] of grouped.entries()) {
         const canonical = canonicalByFile.get(fileName);
-        let content = canonical?.content ?? records[0].content;
+        let preferredRecord = choosePreferredProviderCommand(records);
+        let body = canonical?.body ?? preferredRecord.body;
         let hadConflict = false;
         if (!canonical) {
-            const allSame = records.every((record) => normalizeBody(record.content) === normalizeBody(records[0].content));
-            if (!allSame) {
+            const allSameBody = records.every((record) => sameNormalizedBody(record.body, records[0].body));
+            if (!allSameBody) {
                 hadConflict = true;
                 summary.conflicts += 1;
                 const chosen = await resolveProviderDuplicateConflict({
@@ -386,13 +583,18 @@ async function migrateCommands(options, summary) {
                     yes: Boolean(options.yes),
                     nonInteractive: Boolean(options.nonInteractive),
                 });
-                content = chosen.content;
+                preferredRecord = chosen;
+                body = chosen.body;
             }
         }
         else {
             for (const record of records) {
-                if (normalizeBody(record.content) === normalizeBody(content))
+                if (canonical.frontmatter?.[record.provider] === false) {
+                    continue;
+                }
+                if (sameNormalizedBody(record.body, body)) {
                     continue;
+                }
                 hadConflict = true;
                 summary.conflicts += 1;
                 const decision = await resolveCanonicalConflict({
@@ -401,10 +603,17 @@ async function migrateCommands(options, summary) {
                     nonInteractive: Boolean(options.nonInteractive),
                 });
                 if (decision === "provider") {
-                    content = record.content;
+                    preferredRecord = record;
+                    body = record.body;
                 }
             }
         }
+        const frontmatter = mergeCommandFrontmatter({
+            canonicalFrontmatter: canonical?.frontmatter,
+            records,
+            preferredRecord,
+        });
+        const content = buildCommandMarkdown(frontmatter, body);
         const hasChanged = canonical
             ? canonical.content !== content
             : records.length > 0;
@@ -419,24 +628,222 @@ async function migrateCommands(options, summary) {
         summary.imported += 1;
     }
 }
+function choosePreferredProviderCommand(records) {
+    const withFrontmatter = records.filter((record) => record.frontmatter);
+    if (withFrontmatter.length === 0) {
+        return records[0];
+    }
+    return (withFrontmatter.find((record) => record.provider === "copilot") ??
+        withFrontmatter[0]);
+}
+const COMMAND_GENERIC_FRONTMATTER_KEYS = new Set([
+    "name",
+    "description",
+]);
+function mergeCommandFrontmatter(options) {
+    const hasCanonical = options.canonicalFrontmatter !== undefined;
+    const merged = options.canonicalFrontmatter
+        ? cloneRecord(options.canonicalFrontmatter)
+        : {};
+    const sharedGeneric = new Map();
+    for (const key of COMMAND_GENERIC_FRONTMATTER_KEYS) {
+        if (merged[key] !== undefined) {
+            sharedGeneric.set(key, merged[key]);
+            continue;
+        }
+        if (!hasCanonical) {
+            const preferredValue = options.preferredRecord.frontmatter?.[key];
+            if (preferredValue !== undefined) {
+                const cloned = cloneRecord(preferredValue);
+                merged[key] = cloned;
+                sharedGeneric.set(key, cloned);
+            }
+        }
+    }
+    for (const record of options.records) {
+        const existingProviderValue = merged[record.provider];
+        if (existingProviderValue === false) {
+            continue;
+        }
+        const hadProviderObject = isObject(existingProviderValue);
+        const existingProviderConfig = hadProviderObject
+            ? cloneRecord(existingProviderValue)
+            : {};
+        const providerConfig = existingProviderConfig;
+        const data = record.frontmatter ?? {};
+        for (const [key, value] of Object.entries(data)) {
+            if (PROVIDER_NAME_KEYS.has(key))
+                continue;
+            if (COMMAND_GENERIC_FRONTMATTER_KEYS.has(key)) {
+                if (!sharedGeneric.has(key)) {
+                    if (hasCanonical) {
+                        providerConfig[key] = cloneRecord(value);
+                        continue;
+                    }
+                    const cloned = cloneRecord(value);
+                    merged[key] = cloned;
+                    sharedGeneric.set(key, cloned);
+                    continue;
+                }
+                const sharedValue = sharedGeneric.get(key);
+                if (!isDeepStrictEqual(sharedValue, value)) {
+                    providerConfig[key] = cloneRecord(value);
+                }
+                continue;
+            }
+            const sharedValue = merged[key];
+            if (sharedValue !== undefined && isDeepStrictEqual(sharedValue, value)) {
+                continue;
+            }
+            providerConfig[key] = cloneRecord(value);
+        }
+        if (Object.keys(providerConfig).length > 0 || hadProviderObject) {
+            merged[record.provider] = providerConfig;
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function buildCommandMarkdown(frontmatter, body) {
+    const normalizedBody = body.trimStart();
+    if (!frontmatter || Object.keys(frontmatter).length === 0) {
+        return normalizedBody.endsWith("\n")
+            ? normalizedBody
+            : `${normalizedBody}\n`;
+    }
+    const fm = YAML.stringify(frontmatter, { lineWidth: 0 }).trimEnd();
+    return `---\n${fm}\n---\n\n${normalizedBody}${normalizedBody.endsWith("\n") ? "" : "\n"}`;
+}
 function readProviderCommands(paths, provider) {
-    const commandsDir = getProviderCommandsDir(paths, provider);
+    // Codex prompts are home-scoped; importing them into local canonical state
+    // causes unrelated global prompts to appear in fresh repositories.
+    if (provider === "codex" && paths.scope === "local") {
+        return [];
+    }
+    const candidateDirs = [
+        {
+            path: getProviderCommandsDir(paths, provider),
+            sourcePriority: 0,
+        },
+    ];
+    if (provider === "copilot" && paths.scope === "global") {
+        candidateDirs.push({
+            path: path.join(paths.homeDir, ".github", "prompts"),
+            sourcePriority: 1,
+        });
+    }
+    const records = [];
+    for (const candidateDir of candidateDirs) {
+        records.push(...readProviderCommandsFromDir(candidateDir.path, provider, candidateDir.sourcePriority));
+    }
+    return dedupeProviderCommandRecords(records);
+}
+function readProviderCommandsFromDir(commandsDir, provider, sourcePriority) {
     if (!fs.existsSync(commandsDir) || !fs.statSync(commandsDir).isDirectory()) {
         return [];
     }
-    const files = parseCommandsDir(commandsDir);
-    return files.map((file) => ({
+    const markdownFiles = parseCommandsDir(commandsDir).filter((file) => isProviderEntityFileName({
+        provider,
+        entity: "command",
+        fileName: file.fileName,
+    }));
+    const files = provider === "gemini"
+        ? [...parseGeminiTomlCommandsForMigration(commandsDir), ...markdownFiles]
+        : markdownFiles;
+    const dedupedByTargetFile = new Map();
+    for (const file of files) {
+        const targetFileName = toCanonicalCommandFileName(file.fileName);
+        if (!dedupedByTargetFile.has(targetFileName)) {
+            dedupedByTargetFile.set(targetFileName, file);
+        }
+    }
+    return [...dedupedByTargetFile.entries()].map(([targetFileName, file]) => ({
         provider,
         sourcePath: file.sourcePath,
-        targetFileName: toCanonicalCommandFileName(file.fileName),
+        sourcePriority,
+        targetFileName,
         content: file.content,
+        body: provider === "gemini"
+            ? normalizeCommandArgumentsForCanonical(file.body, provider)
+            : file.body,
+        frontmatter: file.frontmatter,
     }));
 }
+function dedupeProviderCommandRecords(records) {
+    const recordsByTarget = new Map();
+    for (const record of records) {
+        const next = recordsByTarget.get(record.targetFileName) ?? [];
+        next.push(record);
+        recordsByTarget.set(record.targetFileName, next);
+    }
+    const deduped = [];
+    for (const [targetFileName, bucket] of recordsByTarget.entries()) {
+        if (bucket.length === 1) {
+            deduped.push(bucket[0]);
+            continue;
+        }
+        const ranked = [...bucket].sort(compareProviderCommandCollisionPriority);
+        const winner = ranked[0];
+        const ignored = ranked.slice(1).map((record) => record.sourcePath);
+        console.warn(`Warning: Duplicate ${winner.provider} commands map to "${targetFileName}". Keeping ${winner.sourcePath} and ignoring ${ignored.join(", ")}.`);
+        deduped.push(winner);
+    }
+    return deduped.sort((left, right) => left.targetFileName.localeCompare(right.targetFileName));
+}
+function compareProviderCommandCollisionPriority(left, right) {
+    if (left.sourcePriority !== right.sourcePriority) {
+        return left.sourcePriority - right.sourcePriority;
+    }
+    return left.sourcePath.localeCompare(right.sourcePath);
+}
+function parseGeminiTomlCommandsForMigration(commandsDir) {
+    return fs
+        .readdirSync(commandsDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .filter((fileName) => isProviderEntityFileName({
+        provider: "gemini",
+        entity: "command",
+        fileName,
+    }))
+        .filter((fileName) => fileName.toLowerCase().endsWith(".toml"))
+        .sort((a, b) => a.localeCompare(b))
+        .map((fileName) => parseGeminiTomlCommandForMigration(path.join(commandsDir, fileName)))
+        .filter((command) => command !== null);
+}
+function parseGeminiTomlCommandForMigration(sourcePath) {
+    const raw = fs.readFileSync(sourcePath, "utf8");
+    let parsed;
+    try {
+        parsed = TOML.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!isObject(parsed) || typeof parsed.prompt !== "string") {
+        return null;
+    }
+    const body = normalizeCommandArgumentsForCanonical(parsed.prompt, "gemini");
+    const frontmatter = cloneRecord(parsed);
+    delete frontmatter.prompt;
+    const normalizedFrontmatter = Object.keys(frontmatter).length > 0 ? frontmatter : undefined;
+    const fileName = path.basename(sourcePath);
+    const content = buildCommandMarkdown(normalizedFrontmatter, body);
+    return {
+        fileName,
+        sourcePath,
+        content,
+        body,
+        frontmatter: normalizedFrontmatter,
+    };
+}
 function toCanonicalCommandFileName(fileName) {
     const lower = fileName.toLowerCase();
     if (lower.endsWith(".prompt.md")) {
         return `${fileName.slice(0, -".prompt.md".length)}.md`;
     }
+    if (lower.endsWith(".toml")) {
+        return `${fileName.slice(0, -".toml".length)}.md`;
+    }
     if (lower.endsWith(".mdc")) {
         return `${fileName.slice(0, -".mdc".length)}.md`;
     }
@@ -644,8 +1051,185 @@ function isCanonicalServerEqual(left, right) {
         return false;
     return isDeepStrictEqual(normalizeCanonicalServer(left), normalizeCanonicalServer(right));
 }
+async function migrateRules(options, summary) {
+    const detectedEntries = [
+        ...getCursorRuleMigrationEntries(options),
+        ...getManagedInstructionRuleMigrationEntries(options),
+    ];
+    const entries = dedupeRuleMigrationEntries(detectedEntries);
+    summary.detected += detectedEntries.length;
+    for (const entry of entries) {
+        const targetPath = path.join(options.paths.rulesDir, `${entry.targetStem}.md`);
+        if (!fs.existsSync(targetPath)) {
+            if (shouldWriteCanonical(options)) {
+                ensureDir(options.paths.rulesDir);
+                fs.writeFileSync(targetPath, entry.canonicalContent, "utf8");
+            }
+            summary.imported += 1;
+            continue;
+        }
+        const existing = fs.readFileSync(targetPath, "utf8");
+        if (existing === entry.canonicalContent) {
+            summary.skipped += 1;
+            continue;
+        }
+        summary.conflicts += 1;
+        const decision = await resolveCanonicalConflict({
+            conflictLabel: entry.conflictLabel,
+            yes: Boolean(options.yes),
+            nonInteractive: Boolean(options.nonInteractive),
+        });
+        if (decision === "canonical") {
+            summary.skipped += 1;
+            continue;
+        }
+        if (shouldWriteCanonical(options)) {
+            ensureDir(options.paths.rulesDir);
+            fs.writeFileSync(targetPath, entry.canonicalContent, "utf8");
+        }
+        summary.imported += 1;
+    }
+}
+function dedupeRuleMigrationEntries(entries) {
+    const deduped = [];
+    for (const entry of entries) {
+        const existingIndex = deduped.findIndex((item) => item.targetStem === entry.targetStem);
+        if (existingIndex < 0) {
+            deduped.push(entry);
+            continue;
+        }
+        const existing = deduped[existingIndex];
+        if (existing.canonicalContent === entry.canonicalContent) {
+            continue;
+        }
+        const preferred = choosePreferredRuleMigrationEntry(existing, entry);
+        if (preferred === existing) {
+            continue;
+        }
+        if (preferred === entry) {
+            deduped[existingIndex] = entry;
+            continue;
+        }
+        deduped.push(entry);
+    }
+    return deduped;
+}
+function choosePreferredRuleMigrationEntry(left, right) {
+    const hasCursor = left.sourceKind === "cursor" || right.sourceKind === "cursor";
+    const hasManaged = left.sourceKind === "managed" || right.sourceKind === "managed";
+    if (!hasCursor || !hasManaged) {
+        return undefined;
+    }
+    try {
+        const leftParsed = parseRuleMarkdown(left.canonicalContent, left.conflictLabel);
+        const rightParsed = parseRuleMarkdown(right.canonicalContent, right.conflictLabel);
+        if (leftParsed.name !== rightParsed.name) {
+            return undefined;
+        }
+        if (!sameNormalizedBody(leftParsed.body, rightParsed.body)) {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return left.sourceKind === "cursor" ? left : right;
+}
+function getCursorRuleMigrationEntries(options) {
+    if (!options.providers.includes("cursor")) {
+        return [];
+    }
+    if (options.paths.scope !== "local") {
+        return [];
+    }
+    const cursorRulesDir = getCursorRulesDir(options.paths);
+    if (!fs.existsSync(cursorRulesDir) ||
+        !fs.statSync(cursorRulesDir).isDirectory()) {
+        return [];
+    }
+    return fs
+        .readdirSync(cursorRulesDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .filter((name) => /\.(md|mdc)$/i.test(name))
+        .filter((name) => stripRuleFileExtension(name).toLowerCase() !== "readme")
+        .sort((a, b) => a.localeCompare(b))
+        .map((fileName) => {
+        const sourcePath = path.join(cursorRulesDir, fileName);
+        const raw = fs.readFileSync(sourcePath, "utf8");
+        const targetStem = slugify(stripRuleFileExtension(fileName)) || "rule";
+        return {
+            canonicalContent: toCanonicalRuleMarkdown(raw, fileName, sourcePath),
+            conflictLabel: `rule "${targetStem}" from cursor`,
+            sourceKind: "cursor",
+            targetStem,
+        };
+    });
+}
+function getManagedInstructionRuleMigrationEntries(options) {
+    const instructionPaths = getManagedInstructionRulePaths(options).sort((left, right) => left.localeCompare(right));
+    const entries = [];
+    for (const instructionPath of instructionPaths) {
+        if (!fs.existsSync(instructionPath) ||
+            !fs.statSync(instructionPath).isFile()) {
+            continue;
+        }
+        const raw = fs.readFileSync(instructionPath, "utf8");
+        for (const block of parseManagedRuleBlocks(raw)) {
+            const targetStem = slugify(block.id) || "rule";
+            entries.push({
+                canonicalContent: toCanonicalRuleMarkdownFromManagedBlock(block),
+                conflictLabel: `rule "${targetStem}" from ${path.basename(instructionPath)}`,
+                sourceKind: "managed",
+                targetStem,
+            });
+        }
+    }
+    return entries;
+}
+function getManagedInstructionRulePaths(options) {
+    const instructionPaths = getRuleInstructionPaths(options.paths, options.providers);
+    if (options.paths.scope === "global" &&
+        options.providers.includes("copilot")) {
+        const legacyCopilotInstructionPath = path.join(options.paths.homeDir, ".github", "copilot-instructions.md");
+        if (fs.existsSync(legacyCopilotInstructionPath) &&
+            fs.statSync(legacyCopilotInstructionPath).isFile()) {
+            instructionPaths.push(legacyCopilotInstructionPath);
+        }
+    }
+    return [...new Set(instructionPaths)];
+}
+function toCanonicalRuleMarkdown(raw, fileName, sourcePath) {
+    try {
+        const parsed = parseRuleMarkdown(raw, sourcePath);
+        const fm = YAML.stringify(parsed.frontmatter, { lineWidth: 0 }).trimEnd();
+        return `---\n${fm}\n---\n\n${parsed.body}${parsed.body.endsWith("\n") ? "" : "\n"}`;
+    }
+    catch {
+        const parsed = matter(raw);
+        const data = isObject(parsed.data)
+            ? cloneRecord(parsed.data)
+            : {};
+        if (typeof data.name !== "string" || data.name.trim() === "") {
+            data.name = stripRuleFileExtension(fileName);
+        }
+        const fm = YAML.stringify(data, { lineWidth: 0 }).trimEnd();
+        const body = parsed.content.trimStart();
+        return `---\n${fm}\n---\n\n${body}${body.endsWith("\n") ? "" : "\n"}`;
+    }
+}
+function toCanonicalRuleMarkdownFromManagedBlock(block) {
+    const fm = YAML.stringify({ name: block.name }, { lineWidth: 0 }).trimEnd();
+    const body = block.body.trim();
+    return `---\n${fm}\n---\n\n${body}${body.endsWith("\n") ? "" : "\n"}`;
+}
 async function migrateSkills(options, summary) {
-    const providerSkillDirs = getProviderSkillsPaths(options.paths, options.providers)
+    const providerSkillDirs = getProviderSkillsPaths(options.paths, options.providers);
+    if (options.providers.includes("copilot")) {
+        providerSkillDirs.push(...getLegacyCopilotSkillDirs(options.paths));
+    }
+    const legacyCopilotSkillDirs = new Set(getLegacyCopilotSkillDirs(options.paths));
+    const existingProviderSkillDirs = [...new Set(providerSkillDirs)]
         .filter((dirPath) => fs.existsSync(dirPath))
         .filter((dirPath) => {
         try {
@@ -655,12 +1239,17 @@ async function migrateSkills(options, summary) {
             return false;
         }
     });
-    for (const providerSkillsDir of providerSkillDirs) {
-        const providerLabel = providerSkillsDir.includes(`${path.sep}.cursor${path.sep}`)
-            ? "cursor"
-            : providerSkillsDir.includes(`${path.sep}.pi${path.sep}`)
-                ? "pi"
-                : "claude";
+    for (const providerSkillsDir of existingProviderSkillDirs) {
+        const providerLabel = legacyCopilotSkillDirs.has(providerSkillsDir)
+            ? "copilot"
+            : providerSkillsDir.includes(`${path.sep}.cursor${path.sep}`)
+                ? "cursor"
+                : providerSkillsDir.includes(`${path.sep}.github${path.sep}`) ||
+                    providerSkillsDir.includes(`${path.sep}.copilot${path.sep}`)
+                    ? "copilot"
+                    : providerSkillsDir.includes(`${path.sep}.pi${path.sep}`)
+                        ? "pi"
+                        : "claude";
         const skills = parseSkillsDir(providerSkillsDir);
         summary.detected += skills.length;
         for (const skill of skills) {