bosun 0.41.2 → 0.41.3

package/infra/library-manager.mjs

@@ -20,6 +20,14 @@ import { resolve, basename, relative, extname, sep } from "node:path";
 import { execSync, spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { getAgentToolConfig, getEffectiveTools } from "../agent/agent-tool-config.mjs";
+import { nowISO, toStringArray, uniqueStrings } from "./library-manager-utils.mjs";
+import {
+  WELL_KNOWN_AGENT_SOURCES,
+  computeWellKnownSourceTrust,
+  listWellKnownAgentSources,
+  clearWellKnownAgentSourceProbeCache,
+  probeWellKnownAgentSources,
+} from "./library-manager-well-known-sources.mjs";
 
 // ── Constants ─────────────────────────────────────────────────────────────────
 
@@ -35,7 +43,6 @@ export const SKILL_ENTRY_INDEX = "skills.json";
 
 const agentProfileIndexCache = new Map();
 const skillEntryIndexCache = new Map();
-const wellKnownSourceProbeCache = new Map();
 const repoContextCache = new Map();
 
 const REPO_CONTEXT_TTL_MS = 120_000;
@@ -365,10 +372,6 @@ function slugify(name) {
     .replace(/^-|-$/g, "");
 }
 
-function nowISO() {
-  return new Date().toISOString();
-}
-
 function isSafeGitRefName(value) {
   const ref = String(value || "").trim();
   if (!ref) return false;
@@ -395,25 +398,6 @@ function isSafeGitRepositorySource(value) {
   }
 }
 
-function toStringArray(input) {
-  if (!Array.isArray(input)) return [];
-  return input.map((item) => String(item || '').trim()).filter(Boolean);
-}
-
-function uniqueStrings(values = []) {
-  const out = [];
-  const seen = new Set();
-  for (const raw of values) {
-    const value = String(raw || '').trim();
-    if (!value) continue;
-    const key = value.toLowerCase();
-    if (seen.has(key)) continue;
-    seen.add(key);
-    out.push(value);
-  }
-  return out;
-}
-
 function keywordTokens(value, { minLength = 3 } = {}) {
   return uniqueStrings(
     String(value || '')
@@ -1393,8 +1377,23 @@ export function matchAgentProfiles(rootDir, criteria = {}, opts = {}) {
     ...(fileSignals ? [...fileSignals.fileDomains, ...fileSignals.fileLanguages] : []),
   ].map((d) => d.toLowerCase()));
 
-  // Max theoretical score: 10 + 6 + 6 + 3 + 8 + 6 + 4 = 43
-  const MAX_THEORETICAL_SCORE = 43;
+  // Max theoretical score: 10 + 6 + 6 + 3 + 8 + 6 + 4 + 8 + 5 = 56
+  const MAX_THEORETICAL_SCORE = 56;
+
+  // Task-type detection (used by Signal 9)
+  const TASK_TYPE_PATTERNS = {
+    tdd: /\b(tdd|test.driven|write.*tests?|spec)\b/i,
+    test: /\b(test|testing|coverage|jest|vitest|pytest|spec)\b/i,
+    review: /\b(review|code.review|pr.review|audit|inspect)\b/i,
+    docs: /\b(doc|documentation|readme|changelog|api.doc)\b/i,
+    implementation: /\b(implement|build|create|develop|feat|feature|add)\b/i,
+    fix: /\b(fix|bug|patch|hotfix|repair|resolve)\b/i,
+    refactor: /\b(refactor|cleanup|reorganize|restructure|simplify)\b/i,
+    devops: /\b(ci|cd|deploy|pipeline|docker|k8s|infra|terraform)\b/i,
+  };
+  const detectedTaskTypes = Object.entries(TASK_TYPE_PATTERNS)
+    .filter(([, re]) => re.test(textBlob))
+    .map(([type]) => type);
 
   const candidates = [];
   for (const entry of profiles) {
@@ -1406,74 +1405,120 @@ export function matchAgentProfiles(rootDir, criteria = {}, opts = {}) {
 
     let score = 0;
     const reasons = [];
+    const breakdown = {};
 
     // ── Signal 1: titlePattern regex match → +10 (precompiled) ──
     const patterns = toStringArray(profile.titlePatterns);
+    let titlePatternScore = 0;
     for (const pattern of patterns) {
       const re = getCompiledRegex(pattern);
       if (re && re.test(textBlob)) {
-        score += 10;
+        titlePatternScore = 10;
         reasons.push(`pattern:${pattern}`);
         break;
       }
     }
+    score += titlePatternScore;
+    breakdown.titlePattern = titlePatternScore;
 
     // ── Signal 2: conventional-commit scope match → +6 ──
     const scopes = toStringArray(profile.scopes).map((s) => s.toLowerCase());
+    let scopeScore = 0;
     if (taskScope && scopes.includes(taskScope)) {
-      score += 6;
+      scopeScore = 6;
       reasons.push(`scope:${taskScope}`);
     }
+    score += scopeScore;
+    breakdown.scope = scopeScore;
 
     // ── Signal 3: tag overlap → up to +6 ──
     const profileTags = uniqueStrings([...(entry.tags || []), ...toStringArray(profile.tags)]).map((v) => v.toLowerCase());
     const tagHits = criteriaTags.filter((tag) => profileTags.includes(tag));
+    let tagScore = 0;
     if (tagHits.length > 0) {
-      const tagScore = Math.min(6, tagHits.length * 2);
-      score += tagScore;
+      tagScore = Math.min(6, tagHits.length * 2);
       reasons.push(`tags:${tagHits.slice(0, 4).join(",")}`);
     }
+    score += tagScore;
+    breakdown.tags = tagScore;
 
     // ── Signal 4: voice-type hint → +3 ──
+    let voiceScore = 0;
     if (profileType === "voice") {
       const voiceHint = /\bvoice\b|\bcall\b|\brealtime\b/.test(textBlobLower);
       if (voiceHint) {
-        score += 3;
+        voiceScore = 3;
         reasons.push("voice-hint");
       }
     }
+    score += voiceScore;
+    breakdown.voice = voiceScore;
 
     // ── Signal 5: changed-file path match → up to +8 ──
     const scopeHitsFromPaths = scopes.filter((scope) =>
       changedHints.includes(scope) || changedFiles.some((f) => String(f).toLowerCase().includes(`/${scope}/`) || String(f).toLowerCase().includes(`\\${scope}\\`)),
     );
+    let pathScore = 0;
     if (scopeHitsFromPaths.length > 0) {
-      const fileScore = Math.min(8, scopeHitsFromPaths.length * 2);
-      score += fileScore;
+      pathScore = Math.min(8, scopeHitsFromPaths.length * 2);
       reasons.push(`paths:${scopeHitsFromPaths.slice(0, 4).join(",")}`);
     }
+    score += pathScore;
+    breakdown.paths = pathScore;
 
     // ── Signal 6: repo-context domain match → up to +6 ──
+    let domainScore = 0;
     if (contextDomains.size > 0) {
       const profileAllTags = new Set([...profileTags, ...scopes]);
       const domainHits = [...contextDomains].filter((d) => profileAllTags.has(d));
       if (domainHits.length > 0) {
-        const domainScore = Math.min(6, domainHits.length * 2);
-        score += domainScore;
+        domainScore = Math.min(6, domainHits.length * 2);
         reasons.push(`repo-ctx:${domainHits.slice(0, 3).join(",")}`);
       }
     }
+    score += domainScore;
+    breakdown.repoCtx = domainScore;
 
     // ── Signal 7: file-type domain match → up to +4 ──
+    let fileTypeScore = 0;
     if (fileSignals && fileSignals.fileDomains.length > 0) {
       const profileAllTags = new Set([...profileTags, ...scopes]);
       const fileHits = fileSignals.fileDomains.filter((d) => profileAllTags.has(d));
       if (fileHits.length > 0) {
-        const fileTypeScore = Math.min(4, fileHits.length);
-        score += fileTypeScore;
+        fileTypeScore = Math.min(4, fileHits.length);
         reasons.push(`file-type:${fileHits.slice(0, 3).join(",")}`);
       }
     }
+    score += fileTypeScore;
+    breakdown.fileType = fileTypeScore;
+
+    // ── Signal 8: description keyword match → up to +8 ──
+    const profileDesc = String(profile.description || "").toLowerCase();
+    let descScore = 0;
+    if (profileDesc.length > 10) {
+      const descTokens = keywordTokens(profileDesc, { minLength: 4 });
+      const titleTokens = keywordTokens(textBlob, { minLength: 4 });
+      const descHits = descTokens.filter((t) => titleTokens.includes(t));
+      if (descHits.length > 0) {
+        descScore = Math.min(8, descHits.length * 2);
+        reasons.push(`desc:${descHits.slice(0, 4).join(",")}`);
+      }
+    }
+    score += descScore;
+    breakdown.descMatch = descScore;
+
+    // ── Signal 9: task-type hint → +5 ──
+    let taskTypeScore = 0;
+    if (detectedTaskTypes.length > 0) {
+      const profileAllTags = new Set([...profileTags, ...scopes]);
+      const taskTypeHits = detectedTaskTypes.filter((t) => profileAllTags.has(t));
+      if (taskTypeHits.length > 0) {
+        taskTypeScore = 5;
+        reasons.push(`task-type:${taskTypeHits.join(",")}`);
+      }
+    }
+    score += taskTypeScore;
+    breakdown.taskType = taskTypeScore;
 
     if (score <= 0) continue;
 
@@ -1484,6 +1529,7 @@ export function matchAgentProfiles(rootDir, criteria = {}, opts = {}) {
       score,
       confidence,
       reasons,
+      breakdown,
       matchedScope: taskScope,
     });
   }
@@ -1519,6 +1565,7 @@ export function matchAgentProfiles(rootDir, criteria = {}, opts = {}) {
       description,
       requestedAgentType,
       taskScope,
+      detectedTaskTypes,
       changedFilesCount: changedFiles.length,
       repoContext: repoCtx || null,
       fileSignals: fileSignals || null,
@@ -1538,581 +1585,13 @@ export function matchAgentProfile(rootDir, taskTitle) {
   return result.best || null;
 }
 
-const TRUSTED_GITHUB_OWNERS = new Set(["microsoft", "github", "azure", "desktop", "canonical", "mastra-ai"]);
-
-export const WELL_KNOWN_AGENT_SOURCES = Object.freeze([
-  // ── Microsoft — Official ──────────────────────────────────────────────────
-  {
-    id: "microsoft-skills",
-    name: "Microsoft Skills",
-    repoUrl: "https://github.com/microsoft/skills.git",
-    defaultBranch: "main",
-    description: "Microsoft-maintained backend, frontend, planner, infrastructure, and scaffolder agents with hundreds of Azure SDK skills.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "high",
-    estimatedPlugins: 180,
-    focuses: ["backend", "frontend", "planner", "infra", "scaffolding", "azure"],
-  },
-  {
-    id: "microsoft-hve-core",
-    name: "Microsoft HVE Core",
-    repoUrl: "https://github.com/microsoft/hve-core.git",
-    defaultBranch: "main",
-    description: "Core HVE agent library with domain and plugin agent templates and experimental skills.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "high",
-    estimatedPlugins: 60,
-    focuses: ["core", "plugins", "platform"],
-  },
-  {
-    id: "microsoft-vscode",
-    name: "Microsoft VS Code",
-    repoUrl: "https://github.com/microsoft/vscode.git",
-    defaultBranch: "main",
-    description: "VS Code editor skills for hygiene, testing, and extension development workflows.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 15,
-    focuses: ["vscode", "editor", "extensions", "testing"],
-  },
-  {
-    id: "microsoft-powertoys",
-    name: "Microsoft PowerToys",
-    repoUrl: "https://github.com/microsoft/PowerToys.git",
-    defaultBranch: "main",
-    description: "PowerToys development skills for Windows utility and plugin engineering.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 10,
-    focuses: ["windows", "utilities", "c-sharp", "plugins"],
-  },
-  {
-    id: "microsoft-typespec",
-    name: "Microsoft TypeSpec",
-    repoUrl: "https://github.com/microsoft/typespec.git",
-    defaultBranch: "main",
-    description: "TypeSpec API definition language skills for code generation and API design workflows.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 20,
-    focuses: ["api", "code-generation", "typescript", "openapi"],
-  },
-  {
-    id: "microsoft-copilot-for-azure",
-    name: "GitHub Copilot for Azure",
-    repoUrl: "https://github.com/microsoft/GitHub-Copilot-for-Azure.git",
-    defaultBranch: "main",
-    description: "Azure-focused Copilot skills for cloud infrastructure, deployment, and resource management.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "high",
-    estimatedPlugins: 45,
-    focuses: ["azure", "cloud", "infrastructure", "deployment"],
-  },
-  {
-    id: "microsoft-vscode-python-environments",
-    name: "Microsoft VS Code Python Environments",
-    repoUrl: "https://github.com/microsoft/vscode-python-environments.git",
-    defaultBranch: "main",
-    description: "Maintainer, reviewer, and documentation agents for a production VS Code extension.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 8,
-    focuses: ["vscode", "python", "extension", "maintainer"],
-  },
-  {
-    id: "microsoft-vscode-docs",
-    name: "Microsoft VS Code Documentation",
-    repoUrl: "https://github.com/microsoft/vscode-docs.git",
-    defaultBranch: "main",
-    description: "Skills for VS Code documentation authoring, editing, and review workflows.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 12,
-    focuses: ["documentation", "vscode", "markdown", "authoring"],
-  },
-  {
-    id: "microsoft-windowsappsdk",
-    name: "Microsoft Windows App SDK",
-    repoUrl: "https://github.com/microsoft/WindowsAppSDK.git",
-    defaultBranch: "main",
-    description: "Windows App SDK skills for WinUI and Windows platform development.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 8,
-    focuses: ["windows", "winui", "sdk", "desktop"],
-  },
-  {
-    id: "microsoft-vscode-java-pack",
-    name: "Microsoft VS Code Java Pack",
-    repoUrl: "https://github.com/microsoft/vscode-java-pack.git",
-    defaultBranch: "main",
-    description: "Java development skills for VS Code including debugging, testing, and project management.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 10,
-    focuses: ["java", "vscode", "debugging", "testing"],
-  },
-  {
-    id: "microsoft-duroxide",
-    name: "Microsoft Duroxide",
-    repoUrl: "https://github.com/microsoft/duroxide.git",
-    defaultBranch: "main",
-    description: "Durable Functions in Rust — skills for building resilient serverless workflows.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 6,
-    focuses: ["rust", "serverless", "durable-functions", "workflows"],
-  },
-  {
-    id: "microsoft-ebpf-for-windows",
-    name: "Microsoft eBPF for Windows",
-    repoUrl: "https://github.com/microsoft/ebpf-for-windows.git",
-    defaultBranch: "main",
-    description: "eBPF development skills for Windows kernel and networking instrumentation.",
-    owner: "microsoft",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 6,
-    focuses: ["ebpf", "windows", "kernel", "networking"],
-  },
-  // ── GitHub — Official ─────────────────────────────────────────────────────
-  {
-    id: "github-copilot-sdk",
-    name: "GitHub Copilot SDK",
-    repoUrl: "https://github.com/github/copilot-sdk.git",
-    defaultBranch: "main",
-    description: "Official GitHub workflow-authoring and docs-maintenance agents for Copilot SDK projects.",
-    owner: "github",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 10,
-    focuses: ["copilot", "workflow", "docs"],
-  },
-  {
-    id: "github-desktop",
-    name: "GitHub Desktop",
-    repoUrl: "https://github.com/desktop/desktop.git",
-    defaultBranch: "development",
-    description: "GitHub Desktop app agent profiles for Electron, TypeScript, and Git workflow development.",
-    owner: "desktop",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 10,
-    focuses: ["electron", "typescript", "git", "desktop"],
-  },
-  // ── Azure — Official ──────────────────────────────────────────────────────
-  {
-    id: "azure-sdk-for-js",
-    name: "Azure SDK for JavaScript",
-    repoUrl: "https://github.com/Azure/azure-sdk-for-js.git",
-    defaultBranch: "main",
-    description: "Azure JavaScript SDK repo with agentic workflow authoring guidance and prompts.",
-    owner: "azure",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 15,
-    focuses: ["azure", "javascript", "sdk", "workflow"],
-  },
-  // ── Community — Verified ──────────────────────────────────────────────────
-  {
-    id: "mastra-ai-mastra",
-    name: "Mastra AI Framework",
-    repoUrl: "https://github.com/mastra-ai/mastra.git",
-    defaultBranch: "main",
-    description: "AI agent framework with extensive prompt templates for issue tracking, code review, and workflow automation.",
-    owner: "mastra-ai",
-    trustTier: "community",
-    importCoverage: "high",
-    estimatedPlugins: 40,
-    focuses: ["ai", "agents", "prompts", "automation"],
-  },
-  {
-    id: "z3prover-z3",
-    name: "Z3 Theorem Prover",
-    repoUrl: "https://github.com/Z3Prover/z3.git",
-    defaultBranch: "master",
-    description: "Z3 SMT solver agent profiles for formal verification and constraint solving workflows.",
-    owner: "Z3Prover",
-    trustTier: "community",
-    importCoverage: "low",
-    estimatedPlugins: 3,
-    focuses: ["formal-verification", "smt", "solver", "c++"],
-  },
-  {
-    id: "likec4-likec4",
-    name: "LikeC4",
-    repoUrl: "https://github.com/likec4/likec4.git",
-    defaultBranch: "main",
-    description: "Architecture-as-code tool with agents for diagram generation and architecture documentation.",
-    owner: "likec4",
-    trustTier: "community",
-    importCoverage: "medium",
-    estimatedPlugins: 12,
-    focuses: ["architecture", "diagrams", "documentation", "c4"],
-  },
-  {
-    id: "canonical-copilot-collections",
-    name: "Canonical Copilot Collections",
-    repoUrl: "https://github.com/canonical/copilot-collections.git",
-    defaultBranch: "main",
-    description: "Canonical's curated collection of Copilot agent definitions for Ubuntu and open-source development.",
-    owner: "canonical",
-    trustTier: "community",
-    importCoverage: "high",
-    estimatedPlugins: 50,
-    focuses: ["ubuntu", "linux", "open-source", "devops"],
-  },
-  {
-    id: "playwright-mcp-prompts",
-    name: "Playwright MCP Prompts",
-    repoUrl: "https://github.com/debs-obrien/playwright-mcp-prompts.git",
-    defaultBranch: "main",
-    description: "Prompt templates for Playwright end-to-end testing, page objects, and test generation.",
-    owner: "debs-obrien",
-    trustTier: "community",
-    importCoverage: "high",
-    estimatedPlugins: 25,
-    focuses: ["playwright", "testing", "e2e", "automation"],
-  },
-  {
-    id: "copilot-prompts-collection",
-    name: "GitHub Copilot Prompts",
-    repoUrl: "https://github.com/raffertyuy/github-copilot-prompts.git",
-    defaultBranch: "main",
-    description: "Curated collection of GitHub Copilot prompt files for code review, refactoring, and documentation.",
-    owner: "raffertyuy",
-    trustTier: "community",
-    importCoverage: "high",
-    estimatedPlugins: 30,
-    focuses: ["prompts", "code-review", "refactoring", "docs"],
-  },
-  {
-    id: "copilot-kit",
-    name: "Copilot Kit",
-    repoUrl: "https://github.com/TheSethRose/Copilot-Kit.git",
-    defaultBranch: "main",
-    description: "Comprehensive Copilot customization kit with agent profiles, skills, and prompt templates.",
-    owner: "TheSethRose",
-    trustTier: "community",
-    importCoverage: "high",
-    estimatedPlugins: 35,
-    focuses: ["copilot", "agents", "skills", "prompts"],
-  },
-  {
-    id: "dataplat-dbatools",
-    name: "dbatools",
-    repoUrl: "https://github.com/dataplat/dbatools.git",
-    defaultBranch: "development",
-    description: "SQL Server and database administration prompts for DBA workflows and automation.",
-    owner: "dataplat",
-    trustTier: "community",
-    importCoverage: "medium",
-    estimatedPlugins: 10,
-    focuses: ["sql-server", "database", "powershell", "administration"],
-  },
-  {
-    id: "finops-focus-spec",
-    name: "FinOps FOCUS Spec",
-    repoUrl: "https://github.com/FinOps-Open-Cost-and-Usage-Spec/FOCUS_Spec.git",
-    defaultBranch: "working_draft",
-    description: "FinOps specification prompts for cloud cost management and financial operations workflows.",
-    owner: "FinOps-Open-Cost-and-Usage-Spec",
-    trustTier: "community",
-    importCoverage: "medium",
-    estimatedPlugins: 8,
-    focuses: ["finops", "cloud-costs", "specification", "governance"],
-  },
-  // ── MCP Tool Repositories ──────────────────────────────────────────────────
-  {
-    id: "modelcontextprotocol-servers",
-    name: "MCP Official Servers",
-    repoUrl: "https://github.com/modelcontextprotocol/servers.git",
-    defaultBranch: "main",
-    description: "Official Model Context Protocol reference servers — filesystem, GitHub, Git, Postgres, Slack, Google Maps, Puppeteer, and more.",
-    owner: "modelcontextprotocol",
-    trustTier: "official",
-    importCoverage: "high",
-    estimatedPlugins: 25,
-    focuses: ["mcp", "tools", "filesystem", "database", "web", "search"],
-  },
-  {
-    id: "github-mcp-server",
-    name: "GitHub MCP Server",
-    repoUrl: "https://github.com/github/github-mcp-server.git",
-    defaultBranch: "main",
-    description: "Official GitHub MCP server for repository management, issues, pull requests, and code search.",
-    owner: "github",
-    trustTier: "official",
-    importCoverage: "medium",
-    estimatedPlugins: 3,
-    focuses: ["mcp", "github", "issues", "pull-requests", "code-search"],
-  },
-  {
-    id: "punkpeye-awesome-mcp-servers",
-    name: "Awesome MCP Servers",
-    repoUrl: "https://github.com/punkpeye/awesome-mcp-servers.git",
-    defaultBranch: "main",
-    description: "Community-curated list of MCP server implementations — databases, dev tools, cloud platforms, AI services, and productivity tools.",
-    owner: "punkpeye",
-    trustTier: "community",
-    importCoverage: "low",
-    estimatedPlugins: 5,
-    focuses: ["mcp", "tools", "community", "catalog"],
-  },
-]);
-
-function clampNumber(value, min, max) {
-  const numeric = Number(value);
-  if (!Number.isFinite(numeric)) return min;
-  return Math.max(min, Math.min(max, numeric));
-}
-
-function normalizeWellKnownSource(source = {}) {
-  const repoUrl = String(source.repoUrl || "").trim();
-  const github = repoUrl.match(/^https:\/\/github\.com\/([^/]+)\/([^/.]+)(?:\.git)?$/i);
-  const owner = String(source.owner || (github?.[1] || "")).trim();
-  const repo = String(source.repo || (github?.[2] || "")).trim();
-  return {
-    ...source,
-    owner: owner || null,
-    repo: repo || null,
-    provider: source.provider || (github ? "github" : null),
-    importCoverage: String(source.importCoverage || "medium"),
-    focuses: toStringArray(source.focuses),
-  };
-}
-
-function compareWellKnownSources(a, b) {
-  // Sort by estimated plugin count (most first), then trust score, then name
-  const pluginDelta = Number(b?.estimatedPlugins || 0) - Number(a?.estimatedPlugins || 0);
-  if (pluginDelta !== 0) return pluginDelta;
-  const delta = Number(b?.trust?.score || 0) - Number(a?.trust?.score || 0);
-  if (delta !== 0) return delta;
-  return String(a?.name || "").localeCompare(String(b?.name || ""));
-}
-
-export function computeWellKnownSourceTrust(source, probe = {}, options = {}) {
-  const nowMs = Number(options?.nowMs || Date.now());
-  const normalized = normalizeWellKnownSource(source);
-  const reasons = [];
-  let score = 20;
-
-  if (normalized.trustTier === "official") {
-    score += 25;
-    reasons.push("official-maintainer");
-  }
-  if (TRUSTED_GITHUB_OWNERS.has(String(normalized.owner || "").toLowerCase())) {
-    score += 15;
-    reasons.push("trusted-owner");
-  }
-  if (normalized.importCoverage === "high") {
-    score += 12;
-    reasons.push("high-import-coverage");
-  } else if (normalized.importCoverage === "medium") {
-    score += 6;
-    reasons.push("import-coverage");
-  }
-  if (normalized.provider === "github") {
-    score += 4;
-    reasons.push("github-source");
-  }
-
-  const stars = Number(probe?.stars || 0);
-  if (stars >= 10000) {
-    score += 10;
-    reasons.push("popular-repo");
-  } else if (stars >= 1000) {
-    score += 6;
-    reasons.push("established-repo");
-  } else if (stars >= 100) {
-    score += 3;
-  }
-
-  const daysSincePush = Number.isFinite(probe?.daysSincePush)
-    ? Number(probe.daysSincePush)
-    : (probe?.pushedAt ? Math.max(0, (nowMs - Date.parse(probe.pushedAt)) / 86400000) : null);
-  if (daysSincePush != null) {
-    if (daysSincePush <= 45) {
-      score += 10;
-      reasons.push("recently-updated");
-    } else if (daysSincePush <= 180) {
-      score += 6;
-      reasons.push("active-updates");
-    } else if (daysSincePush <= 365) {
-      score += 2;
-    } else if (daysSincePush > 730) {
-      score -= 16;
-      reasons.push("stale-upstream");
-    }
-  }
-
-  if (probe?.reachable === true) {
-    score += 8;
-    reasons.push("remote-reachable");
-  } else if (probe?.reachable === false) {
-    score -= 28;
-    reasons.push("remote-unreachable");
-  }
-
-  if (probe?.branchExists === true) {
-    score += 6;
-    reasons.push("branch-ok");
-  } else if (probe?.branchExists === false) {
-    score -= 22;
-    reasons.push("branch-missing");
-  }
-
-  if (probe?.archived === true) {
-    score -= 45;
-    reasons.push("archived");
-  }
-  if (probe?.disabled === true) {
-    score -= 45;
-    reasons.push("disabled");
-  }
-
-  score = Math.round(clampNumber(score, 0, 100));
-  // Hard-disable only for unreachable/archived/disabled repos — low score gets a warning but remains importable
-  const hardBlocked = probe?.archived === true || probe?.disabled === true || probe?.reachable === false || probe?.branchExists === false;
-  const enabled = !hardBlocked;
-  const lowTrust = score < 55;
-  const status = hardBlocked ? "disabled" : score >= 85 ? "healthy" : score >= 65 ? "warning" : score >= 55 ? "degraded" : "low-trust";
-
-  return {
-    score,
-    status,
-    enabled,
-    lowTrust,
-    reasons: uniqueStrings(reasons),
-  };
-}
-
-function buildWellKnownSourceResult(source, probe = null, options = {}) {
-  const normalized = normalizeWellKnownSource(source);
-  const trust = computeWellKnownSourceTrust(normalized, probe || {}, options);
-  return {
-    ...normalized,
-    trust,
-    probe: probe ? { ...probe } : null,
-    enabled: trust.enabled,
-    status: trust.status,
-  };
-}
-
-export function listWellKnownAgentSources() {
-  return WELL_KNOWN_AGENT_SOURCES
-    .map((source) => buildWellKnownSourceResult(source))
-    .sort(compareWellKnownSources);
-}
-
-export function clearWellKnownAgentSourceProbeCache() {
-  wellKnownSourceProbeCache.clear();
-}
-
-async function fetchGithubRepoProbe(source, options = {}) {
-  const normalized = normalizeWellKnownSource(source);
-  if (normalized.provider !== "github" || !normalized.owner || !normalized.repo) {
-    return { checkedAt: nowISO(), reachable: false, branchExists: false, error: "Unsupported repository provider" };
-  }
-
-  const fetchImpl = options.fetchImpl || globalThis.fetch;
-  const spawnImpl = options.spawnImpl || spawnSync;
-  const branch = String(normalized.defaultBranch || "main").trim() || "main";
-  const headers = {
-    "Accept": "application/vnd.github+json",
-    "User-Agent": "bosun-library-manager",
-  };
-  if (process.env.GITHUB_TOKEN) headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
-
-  let repoMeta = null;
-  let repoError = null;
-  if (typeof fetchImpl === "function") {
-    try {
-      const response = await fetchImpl(`https://api.github.com/repos/${normalized.owner}/${normalized.repo}`, { headers });
-      if (response?.ok) {
-        repoMeta = await response.json();
-      } else {
-        repoError = `GitHub API returned ${Number(response?.status || 0) || "error"}`;
-      }
-    } catch (err) {
-      repoError = err?.message || String(err);
-    }
-  } else {
-    repoError = "fetch unavailable";
-  }
-
-  let reachable = false;
-  let branchExists = false;
-  let gitError = null;
-  try {
-    const remote = spawnImpl("git", ["ls-remote", "--exit-code", "--heads", normalized.repoUrl, branch], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: Number(options.timeoutMs || 15000),
-    });
-    const stdout = String(remote?.stdout || "").trim();
-    reachable = Number(remote?.status) === 0 || stdout.length > 0;
-    branchExists = reachable && stdout.length > 0;
-    if (!reachable || !branchExists) {
-      gitError = String(remote?.stderr || remote?.stdout || "git ls-remote failed").trim() || null;
-    }
-  } catch (err) {
-    gitError = err?.message || String(err);
-  }
-
-  return {
-    checkedAt: nowISO(),
-    reachable,
-    branchExists,
-    defaultBranch: String(repoMeta?.default_branch || branch || "main"),
-    archived: repoMeta?.archived === true,
-    disabled: repoMeta?.disabled === true,
-    stars: Number(repoMeta?.stargazers_count || 0),
-    forks: Number(repoMeta?.forks_count || 0),
-    openIssues: Number(repoMeta?.open_issues_count || 0),
-    pushedAt: repoMeta?.pushed_at || null,
-    daysSincePush: repoMeta?.pushed_at ? Math.max(0, Math.round((Date.now() - Date.parse(repoMeta.pushed_at)) / 86400000)) : null,
-    apiReachable: Boolean(repoMeta),
-    importReady: reachable && branchExists && repoMeta?.archived !== true && repoMeta?.disabled !== true,
-    error: gitError || repoError || null,
-  };
-}
-
-export async function probeWellKnownAgentSources(options = {}) {
-  const nowMs = Number(options?.nowMs || Date.now());
-  const ttlMs = Math.max(1000, Number(options?.ttlMs || 30 * 60 * 1000));
-  const sourceId = String(options?.sourceId || "").trim().toLowerCase();
-  const refresh = options?.refresh === true;
-  const sources = WELL_KNOWN_AGENT_SOURCES.filter((source) => !sourceId || source.id === sourceId);
-  const results = [];
-
-  for (const source of sources) {
-    const cacheKey = source.id;
-    const cached = wellKnownSourceProbeCache.get(cacheKey) || null;
-    if (!refresh && cached && (nowMs - Number(cached.cachedAt || 0)) < ttlMs) {
-      results.push(buildWellKnownSourceResult(source, cached.probe, { nowMs }));
-      continue;
-    }
-
-    const probe = await fetchGithubRepoProbe(source, options);
-    wellKnownSourceProbeCache.set(cacheKey, { cachedAt: nowMs, probe });
-    results.push(buildWellKnownSourceResult(source, probe, { nowMs }));
-  }
-
-  return results.sort(compareWellKnownSources);
-}
-
+export {
+  WELL_KNOWN_AGENT_SOURCES,
+  computeWellKnownSourceTrust,
+  listWellKnownAgentSources,
+  clearWellKnownAgentSourceProbeCache,
+  probeWellKnownAgentSources,
+};
 function parseSimpleFrontmatter(markdown = "") {
   const text = String(markdown || "");
   if (!text.startsWith("---\n")) return { attrs: {}, body: text };
@@ -2586,7 +2065,7 @@ export function syncAutoDiscoveredLibraryEntries(rootDir) {
   };
 }
 
-export function scanRepositoryForImport(options = {}) {
+function resolveRepositoryImportSource(options = {}) {
   const sourceId = String(options?.sourceId || "").trim().toLowerCase();
   const known = WELL_KNOWN_AGENT_SOURCES.find((source) => source.id === sourceId) || null;
   const repoUrl = String(options?.repoUrl || known?.repoUrl || "").trim();
@@ -2599,16 +2078,13 @@ export function scanRepositoryForImport(options = {}) {
   if (!isSafeGitRefName(branch)) {
     throw new Error("Branch name contains invalid characters");
   }
-  const maxEntries = Math.max(
-    1,
-    Math.min(
-      2000,
-      Number.parseInt(String(options?.maxEntries ?? "500"), 10) || 500,
-    ),
-  );
 
+  return { sourceId, known, repoUrl, branch };
+}
+
+function createRepositoryImportCheckoutDir(prefix, repoUrl, branch) {
   const cacheRoot = ensureDir(resolve(getBosunHomeDir(), ".cache", "imports"));
-  const checkoutDir = resolve(cacheRoot, `scan-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`);
+  const checkoutDir = resolve(cacheRoot, `${prefix}-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`);
   ensureDir(checkoutDir);
 
   const clone = spawnSync("git", ["clone", "--depth", "1", "--branch", branch, "--", repoUrl, checkoutDir], {
@@ -2617,167 +2093,231 @@ export function scanRepositoryForImport(options = {}) {
     timeout: 120_000,
   });
   const cloneStderr = String(clone.stderr || "").trim();
-  // Treat "clone succeeded, but checkout failed" (long paths on Windows) as OK
   const checkoutWarning = /clone succeeded.*checkout failed/i.test(cloneStderr);
-  if (clone.status !== 0 && !checkoutWarning) {
-    rmSync(checkoutDir, { recursive: true, force: true });
-    if (/repository not found/i.test(cloneStderr)) {
-      throw new Error(`Repository not found: ${repoUrl}`);
-    }
-    if (/could not read from remote/i.test(cloneStderr)) {
-      throw new Error(`Cannot access repository (may be private or require authentication): ${repoUrl}`);
-    }
-    if (/not found in upstream/i.test(cloneStderr) || /remote branch.*not found/i.test(cloneStderr)) {
-      throw new Error(`Branch "${branch}" not found in ${repoUrl}`);
-    }
-    if (clone.signal === "SIGTERM") {
-      throw new Error(`Clone timed out — repository may be too large: ${repoUrl}`);
-    }
-    throw new Error(`Failed to clone repository: ${cloneStderr || "unknown error"}`);
+  if (clone.status === 0 || checkoutWarning) return checkoutDir;
+
+  rmSync(checkoutDir, { recursive: true, force: true });
+  if (/repository not found/i.test(cloneStderr)) {
+    throw new Error(`Repository not found: ${repoUrl}`);
+  }
+  if (/could not read from remote/i.test(cloneStderr)) {
+    throw new Error(`Cannot access repository (may be private or require authentication): ${repoUrl}`);
+  }
+  if (/not found in upstream/i.test(cloneStderr) || /remote branch.*not found/i.test(cloneStderr)) {
+    throw new Error(`Branch "${branch}" not found in ${repoUrl}`);
+  }
+  if (clone.signal === "SIGTERM") {
+    throw new Error(`Clone timed out — repository may be too large: ${repoUrl}`);
   }
+  throw new Error(`Failed to clone repository: ${cloneStderr || "unknown error"}`);
+}
 
-  try {
-    const files = walkFilesRecursive(checkoutDir);
-    const candidates = files
+function buildImportedMarkdownCandidate(candidate) {
+  const { raw = "", attrs = {}, body = "", relPath = "", fileName = "", kind = null } = candidate || {};
+  if (!kind) return null;
+
+  const fileStem = basename(fileName, ".md");
+  const relSegments = relPath.split(/[\\/]/).filter(Boolean);
+  const parentSegment = relSegments.length > 1 ? relSegments[relSegments.length - 2] : "";
+  const fallbackNameBase = fileStem.toLowerCase() === "skill" && parentSegment ? parentSegment : fileStem;
+  const fallbackName = fallbackNameBase.replace(/\.agent$/i, "").replace(/\.skill$/i, "").replace(/\.prompt$/i, "");
+  const name = String(getFrontmatterValue(attrs, ["name", "title"]) || fallbackName.replace(/[-_.]+/g, " ")).trim();
+  const description = normalizeImportedDescription(getFrontmatterValue(attrs, ["description", "summary"]), body);
+
+  return {
+    ...candidate,
+    fileStem,
+    name,
+    description,
+  };
+}
+
+function sortImportedMarkdownCandidates(candidates = []) {
+  const rank = { agent: 0, prompt: 1, skill: 2 };
+  return candidates.sort((a, b) => {
+    const aRank = Number(rank[a.kind] ?? 99);
+    const bRank = Number(rank[b.kind] ?? 99);
+    if (aRank !== bRank) return aRank - bRank;
+    return String(a.relPath || "").localeCompare(String(b.relPath || ""));
+  });
+}
+
+function collectRepositoryImportMarkdownCandidates(checkoutDir, options = {}) {
+  const maxEntries = Math.max(
+    1,
+    Math.min(2000, Number.parseInt(String(options?.maxEntries ?? "500"), 10) || 500),
+  );
+
+  const files = walkFilesRecursive(checkoutDir);
+  const candidates = sortImportedMarkdownCandidates(
+    files
       .filter((fullPath) => /\.md$/i.test(fullPath))
       .map((fullPath) => {
         const relPath = fullPath.slice(checkoutDir.length + 1).replace(/\\/g, "/");
         const fileName = basename(fullPath);
+        let raw = "";
         let parsed = { attrs: {}, body: "" };
         try {
-          const raw = readFileSync(fullPath, "utf8");
+          raw = readFileSync(fullPath, "utf8");
           parsed = parseSimpleFrontmatter(raw);
-        } catch { /* skip unreadable */ }
+        } catch {
+          return null;
+        }
         const kind = inferImportedEntryKind(relPath, fileName, parsed.attrs);
-        if (!kind) return null;
-        const fileStem = basename(fileName, ".md");
-        const relSegments = relPath.split(/[\\/]/).filter(Boolean);
-        const parentSegment = relSegments.length > 1 ? relSegments[relSegments.length - 2] : "";
-        const fallbackNameBase = fileStem.toLowerCase() === "skill" && parentSegment ? parentSegment : fileStem;
-        const fallbackName = fallbackNameBase.replace(/\.agent$/i, "").replace(/\.skill$/i, "").replace(/\.prompt$/i, "");
-        const name = String(getFrontmatterValue(parsed.attrs, ["name", "title"]) || fallbackName.replace(/[-_.]+/g, " ")).trim();
-        const description = normalizeImportedDescription(getFrontmatterValue(parsed.attrs, ["description", "summary"]), parsed.body);
-        return { relPath, fileName, kind, name, description, selected: true };
-      })
-      .filter(Boolean)
-      .sort((a, b) => {
-        const rank = { agent: 0, prompt: 1, skill: 2 };
-        const aRank = Number(rank[a.kind] ?? 99);
-        const bRank = Number(rank[b.kind] ?? 99);
-        if (aRank !== bRank) return aRank - bRank;
-        return String(a.relPath || "").localeCompare(String(b.relPath || ""));
+        return buildImportedMarkdownCandidate({
+          fullPath,
+          relPath,
+          fileName,
+          raw,
+          attrs: parsed.attrs,
+          body: parsed.body,
+          kind,
+          selected: true,
+        });
       })
-      .slice(0, maxEntries);
+      .filter(Boolean),
+  ).slice(0, maxEntries);
 
-    const byType = { agent: 0, prompt: 0, skill: 0, mcp: 0 };
-    for (const c of candidates) byType[c.kind] = (byType[c.kind] || 0) + 1;
-
-    // Scan for MCP server definitions in known config files
-    const mcpConfigPaths = [
-      resolve(checkoutDir, ".codex", "config.toml"),
-      resolve(checkoutDir, ".mcp.json"),
-      resolve(checkoutDir, "mcp.json"),
-      resolve(checkoutDir, ".vscode", "mcp.json"),
-      resolve(checkoutDir, "claude_desktop_config.json"),
-    ];
-    for (const configPath of mcpConfigPaths) {
-      if (!existsSync(configPath)) continue;
-      let raw = "";
-      try { raw = readFileSync(configPath, "utf8"); } catch { continue; }
-      const relPath = relative(checkoutDir, configPath).replace(/\\/g, "/");
-      if (/\.toml$/i.test(configPath)) {
-        const discovered = parseMcpServersFromToml(raw, relPath);
-        for (const mcp of discovered) {
-          candidates.push({
-            relPath: `${relPath}#${mcp.id}`,
-            fileName: basename(configPath),
-            kind: "mcp",
-            name: mcp.name || mcp.id,
-            description: `${mcp.transport === "stdio" ? "stdio" : "url"} MCP server${mcp.command ? ": " + mcp.command : ""}`,
-            selected: true,
-          });
-          byType.mcp += 1;
-        }
-      } else {
-        const discovered = parseMcpServersFromJson(raw, relPath);
-        for (const mcp of discovered) {
-          candidates.push({
-            relPath: `${relPath}#${mcp.id}`,
-            fileName: basename(configPath),
-            kind: "mcp",
-            name: mcp.name || mcp.id,
-            description: `${mcp.transport === "stdio" ? "stdio" : "url"} MCP server${mcp.command ? ": " + mcp.command : ""}`,
-            selected: true,
-          });
-          byType.mcp += 1;
-        }
-      }
+  return { files, candidates };
+}
+
+function listRepositoryMcpConfigFiles(checkoutDir, { includeLegacy = false } = {}) {
+  const configFiles = [
+    { path: resolve(checkoutDir, ".codex", "config.toml"), format: "toml" },
+    { path: resolve(checkoutDir, ".mcp.json"), format: "json" },
+    { path: resolve(checkoutDir, ".vscode", "mcp.json"), format: "json" },
+  ];
+
+  if (includeLegacy) {
+    configFiles.splice(2, 0, { path: resolve(checkoutDir, "mcp.json"), format: "json" });
+    configFiles.push({ path: resolve(checkoutDir, "claude_desktop_config.json"), format: "json" });
+  }
+
+  return configFiles;
+}
+
+function discoverRepositoryMcpConfigs(checkoutDir, options = {}) {
+  const discovered = [];
+  for (const { path: configPath, format } of listRepositoryMcpConfigFiles(checkoutDir, options)) {
+    if (!existsSync(configPath)) continue;
+    let raw = "";
+    try {
+      raw = readFileSync(configPath, "utf8");
+    } catch {
+      continue;
     }
+    const relPath = relative(checkoutDir, configPath).replace(/\\/g, "/");
+    const entries = format === "toml"
+      ? parseMcpServersFromToml(raw, relPath)
+      : parseMcpServersFromJson(raw, relPath);
+    discovered.push(...entries.map((entry) => ({ ...entry, relPath, fileName: basename(configPath) })));
+  }
+  return discovered;
+}
 
-    // Discover MCP servers from package.json bin entries and pyproject.toml scripts
-    const mcpSeenIds = new Set(candidates.filter((c) => c.kind === "mcp").map((c) => c.name));
-    for (const fullPath of files) {
-      const fileName = basename(fullPath);
-      if (fileName !== "package.json" && fileName !== "pyproject.toml") continue;
-      const relPath = relative(checkoutDir, fullPath).replace(/\\/g, "/");
-      // Skip root-level package.json (monorepo manifest, not an MCP server)
-      if (relPath === "package.json") continue;
-      let raw = "";
-      try { raw = readFileSync(fullPath, "utf8"); } catch { continue; }
-
-      if (fileName === "package.json") {
-        let pkg;
-        try { pkg = JSON.parse(raw); } catch { continue; }
-        if (!pkg || typeof pkg !== "object") continue;
-        const bin = pkg.bin;
-        if (!bin || typeof bin !== "object") continue;
-        const mcpBins = Object.entries(bin).filter(([k]) => /^mcp[-_]?server/i.test(k) || /^mcp-/i.test(k));
-        if (mcpBins.length === 0) continue;
-        for (const [cmd] of mcpBins) {
-          const id = slugifyIdentifier(cmd);
-          if (mcpSeenIds.has(cmd) || mcpSeenIds.has(id)) continue;
-          mcpSeenIds.add(cmd);
-          const name = String(pkg.mcpName || pkg.name || cmd).trim();
-          const desc = String(pkg.description || "").trim();
-          candidates.push({
-            relPath: `${relPath}#${cmd}`,
-            fileName,
-            kind: "mcp",
-            name: name.startsWith("@") ? cmd : name,
-            description: desc || `stdio MCP server: ${cmd}`,
-            selected: true,
-          });
-          byType.mcp += 1;
-        }
-      } else if (fileName === "pyproject.toml") {
-        // Look for [project.scripts] entries matching mcp-server-*
-        const scriptMatch = raw.match(/\[project\.scripts\]([\s\S]*?)(?:\n\[|\n$)/);
-        if (!scriptMatch) continue;
-        const scriptBlock = scriptMatch[1];
-        const scriptLines = scriptBlock.split(/\r?\n/);
-        for (const line of scriptLines) {
-          const kv = line.match(/^\s*(mcp[-_]?server[-_]?\S*)\s*=/i);
-          if (!kv) continue;
-          const cmd = kv[1].trim();
-          if (mcpSeenIds.has(cmd)) continue;
-          mcpSeenIds.add(cmd);
-          // Try to get project name/description from TOML
-          const nameMatch = raw.match(/^\s*name\s*=\s*"([^"]+)"/m);
-          const descMatch = raw.match(/^\s*description\s*=\s*"([^"]+)"/m);
-          candidates.push({
-            relPath: `${relPath}#${cmd}`,
-            fileName,
-            kind: "mcp",
-            name: nameMatch ? nameMatch[1] : cmd,
-            description: descMatch ? descMatch[1] : `stdio MCP server: ${cmd}`,
-            selected: true,
-          });
-          byType.mcp += 1;
-        }
+function appendRepositoryMcpImportCandidates(candidates, files, checkoutDir, byType) {
+  for (const mcp of discoverRepositoryMcpConfigs(checkoutDir, { includeLegacy: true })) {
+    candidates.push({
+      relPath: `${mcp.relPath}#${mcp.id}`,
+      fileName: mcp.fileName,
+      kind: "mcp",
+      name: mcp.name || mcp.id,
+      description: `${mcp.transport === "stdio" ? "stdio" : "url"} MCP server${mcp.command ? ": " + mcp.command : ""}`,
+      selected: true,
+    });
+    byType.mcp += 1;
+  }
+
+  const mcpSeenIds = new Set(candidates.filter((candidate) => candidate.kind === "mcp").map((candidate) => candidate.name));
+  for (const fullPath of files) {
+    const fileName = basename(fullPath);
+    if (fileName !== "package.json" && fileName !== "pyproject.toml") continue;
+    const relPath = relative(checkoutDir, fullPath).replace(/\\/g, "/");
+    if (relPath === "package.json") continue;
+    let raw = "";
+    try {
+      raw = readFileSync(fullPath, "utf8");
+    } catch {
+      continue;
+    }
+
+    if (fileName === "package.json") {
+      let pkg;
+      try {
+        pkg = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (!pkg || typeof pkg !== "object") continue;
+      const bin = pkg.bin;
+      if (!bin || typeof bin !== "object") continue;
+      const mcpBins = Object.entries(bin).filter(([key]) => /^mcp[-_]?server/i.test(key) || /^mcp-/i.test(key));
+      if (mcpBins.length === 0) continue;
+      for (const [cmd] of mcpBins) {
+        const id = slugifyIdentifier(cmd);
+        if (mcpSeenIds.has(cmd) || mcpSeenIds.has(id)) continue;
+        mcpSeenIds.add(cmd);
+        const name = String(pkg.mcpName || pkg.name || cmd).trim();
+        const description = String(pkg.description || "").trim();
+        candidates.push({
+          relPath: `${relPath}#${cmd}`,
+          fileName,
+          kind: "mcp",
+          name: name.startsWith("@") ? cmd : name,
+          description: description || `stdio MCP server: ${cmd}`,
+          selected: true,
+        });
+        byType.mcp += 1;
       }
+      continue;
     }
 
-    // Duplicate detection against existing library entries
+    const scriptMatch = raw.match(/\[project\.scripts\]([\s\S]*?)(?:\n\[|\n$)/);
+    if (!scriptMatch) continue;
+    const scriptLines = scriptMatch[1].split(/\r?\n/);
+    for (const line of scriptLines) {
+      const kv = line.match(/^\s*(mcp[-_]?server[-_]?\S*)\s*=/i);
+      if (!kv) continue;
+      const cmd = kv[1].trim();
+      if (mcpSeenIds.has(cmd)) continue;
+      mcpSeenIds.add(cmd);
+      const nameMatch = raw.match(/^\s*name\s*=\s*"([^"]+)"/m);
+      const descMatch = raw.match(/^\s*description\s*=\s*"([^"]+)"/m);
+      candidates.push({
+        relPath: `${relPath}#${cmd}`,
+        fileName,
+        kind: "mcp",
+        name: nameMatch ? nameMatch[1] : cmd,
+        description: descMatch ? descMatch[1] : `stdio MCP server: ${cmd}`,
+        selected: true,
+      });
+      byType.mcp += 1;
+    }
+  }
+}
+
+export function scanRepositoryForImport(options = {}) {
+  const { sourceId, known, repoUrl, branch } = resolveRepositoryImportSource(options);
+  const maxEntries = Math.max(
+    1,
+    Math.min(
+      2000,
+      Number.parseInt(String(options?.maxEntries ?? "500"), 10) || 500,
+    ),
+  );
+
+  const checkoutDir = createRepositoryImportCheckoutDir("scan", repoUrl, branch);
+
+  try {
+    const { files, candidates } = collectRepositoryImportMarkdownCandidates(checkoutDir, { maxEntries });
+
+    const byType = { agent: 0, prompt: 0, skill: 0, mcp: 0 };
+    for (const candidate of candidates) {
+      byType[candidate.kind] = (byType[candidate.kind] || 0) + 1;
+    }
+
+    appendRepositoryMcpImportCandidates(candidates, files, checkoutDir, byType);
+
     const rootDir = options?.rootDir || null;
     let duplicateMap = {};
     let intraDuplicateMap = {};
@@ -2787,13 +2327,12 @@ export function scanRepositoryForImport(options = {}) {
         const extDups = detectImportDuplicates(candidates, existingEntries);
         for (const [relPath, info] of extDups) {
           duplicateMap[relPath] = info;
-          // Auto-deselect exact duplicates
           const cand = candidates.find((c) => c.relPath === relPath);
           if (cand && info.similarity >= 0.95) cand.selected = false;
         }
-      } catch { /* skip if library not accessible */ }
+      } catch {}
     }
-    // Intra-import duplicate detection
+
     const intraDups = detectIntraDuplicates(candidates);
     for (const [relPath, peers] of intraDups) {
       intraDuplicateMap[relPath] = peers;
@@ -2815,19 +2354,189 @@ export function scanRepositoryForImport(options = {}) {
   }
 }
 
-export function importAgentProfilesFromRepository(rootDir, options = {}) {
-  const sourceId = String(options?.sourceId || "").trim().toLowerCase();
-  const known = WELL_KNOWN_AGENT_SOURCES.find((source) => source.id === sourceId) || null;
-  const repoUrl = String(options?.repoUrl || known?.repoUrl || "").trim();
-  if (!repoUrl) throw new Error("Repository URL or source is required");
+function importRepositoryMarkdownCandidate(rootDir, candidate, context) {
+  const { known, repoUrl, branch, sourceId, importAgents, importSkills, importPrompts, takenIds, imported, importedByType } = context;
+  const { attrs, body, relPath, fileStem, kind, name, description, raw } = candidate;
+  const keywords = keywordTokens(`${name} ${description} ${relPath}`, { minLength: 4 }).slice(0, 10);
 
-  const branch = String(options?.branch || known?.defaultBranch || "main").trim() || "main";
-  if (!isSafeGitRepositorySource(repoUrl)) {
-    throw new Error("URL must be a valid http(s), ssh, or git repository address");
+  if (kind === "prompt") {
+    if (!importPrompts) return { needsAgentIndexRefresh: false, needsSkillIndexRefresh: false };
+    const baseId = slugify(`${sourceId || "imported"}-${name}`) || slugify(fileStem) || `imported-prompt-${imported.length + 1}`;
+    const id = ensureUniqueId(baseId, takenIds);
+    const promptContent = String(body || raw || "").trim();
+    if (!promptContent) return { needsAgentIndexRefresh: false, needsSkillIndexRefresh: false };
+    upsertEntry(rootDir, {
+      id,
+      type: "prompt",
+      name,
+      description: description || `Imported prompt from ${known?.name || repoUrl}`,
+      tags: uniqueStrings(["imported", "prompt", sourceId || "external", ...parseJsonishArray(getFrontmatterValue(attrs, ["tags"]))]),
+      meta: {
+        sourceId: sourceId || null,
+        repoUrl,
+        branch,
+        relPath,
+      },
+    }, promptContent);
+    imported.push({ id, name, relPath, type: "prompt", promptId: null });
+    importedByType.prompt += 1;
+    return { needsAgentIndexRefresh: false, needsSkillIndexRefresh: false };
+  }
+
+  if (kind === "skill") {
+    if (!importSkills) return { needsAgentIndexRefresh: false, needsSkillIndexRefresh: false };
+    const baseId = slugify(`${sourceId || "imported"}-${name}`) || slugify(fileStem) || `imported-skill-${imported.length + 1}`;
+    const id = ensureUniqueId(baseId, takenIds);
+    const skillContent = String(body || raw || "").trim();
+    if (!skillContent) return { needsAgentIndexRefresh: false, needsSkillIndexRefresh: false };
+    upsertEntry(rootDir, {
+      id,
+      type: "skill",
+      name,
+      description: description || "Imported skill",
+      tags: uniqueStrings(["imported", "skill", sourceId || "external", ...parseJsonishArray(getFrontmatterValue(attrs, ["tags"]))]),
+      meta: {
+        sourceId: sourceId || null,
+        repoUrl,
+        branch,
+        relPath,
+      },
+    }, skillContent, { skipIndexSync: true });
+    imported.push({ id, name, relPath, type: "skill", promptId: null });
+    importedByType.skill += 1;
+    return { needsAgentIndexRefresh: false, needsSkillIndexRefresh: true };
+  }
+
+  if (kind !== "agent" || !importAgents) {
+    return { needsAgentIndexRefresh: false, needsSkillIndexRefresh: false };
+  }
+
+  const baseId = slugify(`${sourceId || "imported"}-${name}`) || slugify(fileStem) || `imported-agent-${imported.length + 1}`;
+  const id = ensureUniqueId(baseId, takenIds);
+  const toolHints = parseJsonishArray(getFrontmatterValue(attrs, ["tools", "enabledTools"]));
+  const profileSkillHints = parseJsonishArray(getFrontmatterValue(attrs, ["skills"]));
+  const mcpHints = parseJsonishArray(getFrontmatterValue(attrs, ["enabledMcpServers", "mcpServers", "mcp"]));
+  const titlePatternHints = parseJsonishArray(getFrontmatterValue(attrs, ["titlePatterns", "title_patterns", "patterns"]));
+  const tags = uniqueStrings([
+    "imported",
+    sourceId || "external",
+    ...parseJsonishArray(getFrontmatterValue(attrs, ["tags"])),
+    ...keywords.slice(0, 4),
+  ]);
+  const pathScopes = uniqueStrings(
+    relPath
+      .split(/[\/]/)
+      .slice(0, -1)
+      .map((segment) => slugify(segment))
+      .filter((segment) => segment && segment !== "github" && segment !== "agents"),
+  ).slice(0, 6);
+  const explicitScopes = parseJsonishArray(getFrontmatterValue(attrs, ["scopes", "scope"]));
+  const scopes = uniqueStrings([...explicitScopes, ...pathScopes]).slice(0, 8);
+  const titlePatterns = uniqueStrings([
+    ...titlePatternHints,
+    ...keywordTokens(name, { minLength: 4 }).slice(0, 4).map((token) => `\\b${token.replace(/[.*+?^${}()|[\\]\\]/g, "")}\\b`),
+  ]);
+  const promptId = `${id}-prompt`;
+
+  if (importPrompts && body) {
+    upsertEntry(rootDir, {
+      id: promptId,
+      type: "prompt",
+      name: `${name} Prompt`,
+      description: `Imported prompt from ${known?.name || repoUrl}`,
+      tags: uniqueStrings(["imported", "agent-prompt", sourceId || "external"]),
+      meta: {
+        sourceId: sourceId || null,
+        repoUrl,
+        branch,
+        relPath,
+      },
+    }, body);
+    imported.push({ id: promptId, name: `${name} Prompt`, relPath, type: "prompt", promptId: null });
+    importedByType.prompt += 1;
   }
-  if (!isSafeGitRefName(branch)) {
-    throw new Error("Branch name contains invalid characters");
+
+  const explicitAgentType = String(getFrontmatterValue(attrs, ["agentType", "agent_type"]) || "").trim().toLowerCase();
+  const profile = {
+    id,
+    name,
+    description,
+    titlePatterns: titlePatterns.length ? titlePatterns : ["\\btask\\b"],
+    scopes,
+    sdk: null,
+    model: null,
+    promptOverride: importPrompts && body ? promptId : null,
+    skills: profileSkillHints,
+    hookProfile: null,
+    env: {},
+    enabledTools: toolHints.length ? toolHints : null,
+    enabledMcpServers: mcpHints,
+    tags,
+    agentType: explicitAgentType || (/voice|audio|realtime/i.test(`${name} ${description}`) ? "voice" : "task"),
+    importMeta: {
+      sourceId: sourceId || null,
+      repoUrl,
+      branch,
+      relPath,
+    },
+  };
+
+  upsertEntry(rootDir, {
+    id,
+    type: "agent",
+    name,
+    description,
+    tags: profile.tags,
+    meta: {
+      sourceId: sourceId || null,
+      repoUrl,
+      branch,
+      relPath,
+    },
+  }, profile, { skipIndexSync: true });
+
+  imported.push({ id, name, relPath, type: "agent", promptId: importPrompts && body ? promptId : null });
+  importedByType.agent += 1;
+  return { needsAgentIndexRefresh: true, needsSkillIndexRefresh: false };
+}
+
+function importRepositoryMcpEntries(rootDir, checkoutDir, context) {
+  const { sourceId, repoUrl, branch, takenIds, imported, importedByType } = context;
+  for (const mcp of discoverRepositoryMcpConfigs(checkoutDir)) {
+    const baseId = slugify(`${sourceId || "imported"}-${mcp.id}`) || slugify(mcp.id) || `imported-mcp-${imported.length + 1}`;
+    const id = ensureUniqueId(baseId, takenIds);
+    const content = {
+      id,
+      name: mcp.name,
+      description: "Imported MCP server definition from " + mcp.relPath,
+      transport: mcp.transport,
+      command: mcp.transport === "stdio" ? mcp.command : undefined,
+      args: mcp.transport === "stdio" ? mcp.args : undefined,
+      url: mcp.transport === "url" ? mcp.url : undefined,
+      env: Object.keys(mcp.env || {}).length ? mcp.env : undefined,
+      source: "imported",
+      tags: ["imported", "mcp", sourceId || "external"],
+    };
+    upsertEntry(rootDir, {
+      id,
+      type: "mcp",
+      name: mcp.name,
+      description: content.description,
+      tags: uniqueStrings(["imported", "mcp", sourceId || "external"]),
+      meta: {
+        sourceId: sourceId || null,
+        repoUrl,
+        branch,
+        relPath: mcp.relPath,
+      },
+    }, content);
+    imported.push({ id, name: mcp.name, relPath: mcp.relPath, type: "mcp", promptId: null });
+    importedByType.mcp += 1;
   }
+}
+
+export function importAgentProfilesFromRepository(rootDir, options = {}) {
+  const { sourceId, known, repoUrl, branch } = resolveRepositoryImportSource(options);
   const importAgents = options?.importAgents !== false;
   const importSkills = options?.importSkills !== false;
   const importPrompts = options?.importPrompts !== false;
@@ -2842,62 +2551,8 @@ export function importAgentProfilesFromRepository(rootDir, options = {}) {
     ),
   );
 
-  const cacheRoot = ensureDir(resolve(getBosunHomeDir(), ".cache", "imports"));
-  const checkoutDir = resolve(cacheRoot, `import-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`);
-  ensureDir(checkoutDir);
-
-  const clone = spawnSync("git", ["clone", "--depth", "1", "--branch", branch, "--", repoUrl, checkoutDir], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 120_000,
-  });
-  const cloneStderr = String(clone.stderr || "").trim();
-  const checkoutWarning = /clone succeeded.*checkout failed/i.test(cloneStderr);
-  if (clone.status !== 0 && !checkoutWarning) {
-    rmSync(checkoutDir, { recursive: true, force: true });
-    if (/repository not found/i.test(cloneStderr)) {
-      throw new Error(`Repository not found: ${repoUrl}`);
-    }
-    if (/could not read from remote/i.test(cloneStderr)) {
-      throw new Error(`Cannot access repository (may be private or require authentication): ${repoUrl}`);
-    }
-    if (/not found in upstream/i.test(cloneStderr) || /remote branch.*not found/i.test(cloneStderr)) {
-      throw new Error(`Branch "${branch}" not found in ${repoUrl}`);
-    }
-    if (clone.signal === "SIGTERM") {
-      throw new Error(`Clone timed out — repository may be too large: ${repoUrl}`);
-    }
-    throw new Error(`Failed to clone repository: ${cloneStderr || "unknown error"}`);
-  }
-
-  const files = walkFilesRecursive(checkoutDir);
-  const markdownCandidates = files
-    .filter((fullPath) => /\.md$/i.test(fullPath))
-    .map((fullPath) => {
-      const relPath = fullPath.slice(checkoutDir.length + 1).replace(/\\/g, "/");
-      const fileName = basename(fullPath);
-      const raw = readFileSync(fullPath, "utf8");
-      const parsed = parseSimpleFrontmatter(raw);
-      return {
-        fullPath,
-        relPath,
-        fileName,
-        raw,
-        attrs: parsed.attrs,
-        body: parsed.body,
-        kind: inferImportedEntryKind(relPath, fileName, parsed.attrs),
-      };
-    })
-    .filter((entry) => Boolean(entry.kind))
-    .sort((a, b) => {
-      const rank = { agent: 0, prompt: 1, skill: 2 };
-      const aRank = Number(rank[a.kind] ?? 99);
-      const bRank = Number(rank[b.kind] ?? 99);
-      if (aRank !== bRank) return aRank - bRank;
-      return String(a.relPath || "").localeCompare(String(b.relPath || ""));
-    });
-
-  const candidates = markdownCandidates.slice(0, maxProfiles);
+  const checkoutDir = createRepositoryImportCheckoutDir("import", repoUrl, branch);
+  const { candidates } = collectRepositoryImportMarkdownCandidates(checkoutDir, { maxEntries: maxProfiles });
 
   const takenIds = new Set(
     listEntries(rootDir).map((entry) => String(entry?.id || "").trim()).filter(Boolean),
@@ -2909,209 +2564,36 @@ export function importAgentProfilesFromRepository(rootDir, options = {}) {
 
   try {
     for (const candidate of candidates) {
-      const { attrs, body, relPath, fileName, kind } = candidate;
+      const { relPath } = candidate;
       if (includeEntries && !includeEntries.has(relPath)) continue;
-      const fileStem = basename(fileName, ".md");
-      const relSegments = relPath.split(/[\\/]/).filter(Boolean);
-      const parentSegment = relSegments.length > 1 ? relSegments[relSegments.length - 2] : "";
-      const fallbackNameBase = fileStem.toLowerCase() === "skill" && parentSegment ? parentSegment : fileStem;
-      const fallbackName = fallbackNameBase.replace(/\.agent$/i, "").replace(/\.skill$/i, "").replace(/\.prompt$/i, "");
-      const name = String(getFrontmatterValue(attrs, ["name", "title"]) || fallbackName.replace(/[-_.]+/g, " ")).trim();
-      const description = normalizeImportedDescription(getFrontmatterValue(attrs, ["description", "summary"]), body);
-      const keywords = keywordTokens(`${name} ${description} ${relPath}`, { minLength: 4 }).slice(0, 10);
-
-      if (kind === "prompt") {
-        if (!importPrompts) continue;
-        const baseId = slugify(`${sourceId || "imported"}-${name}`) || slugify(fileStem) || `imported-prompt-${imported.length + 1}`;
-        const id = ensureUniqueId(baseId, takenIds);
-        const promptContent = String(body || candidate.raw || "").trim();
-        if (!promptContent) continue;
-        upsertEntry(rootDir, {
-          id,
-          type: "prompt",
-          name,
-          description: description || `Imported prompt from ${known?.name || repoUrl}`,
-          tags: uniqueStrings(["imported", "prompt", sourceId || "external", ...parseJsonishArray(getFrontmatterValue(attrs, ["tags"]))]),
-          meta: {
-            sourceId: sourceId || null,
-            repoUrl,
-            branch,
-            relPath,
-          },
-        }, promptContent);
-        imported.push({ id, name, relPath, type: "prompt", promptId: null });
-        importedByType.prompt += 1;
-        continue;
-      }
-
-      if (kind === "skill") {
-        if (!importSkills) continue;
-        const baseId = slugify(`${sourceId || "imported"}-${name}`) || slugify(fileStem) || `imported-skill-${imported.length + 1}`;
-        const id = ensureUniqueId(baseId, takenIds);
-        const skillContent = String(body || candidate.raw || "").trim();
-        if (!skillContent) continue;
-        upsertEntry(rootDir, {
-          id,
-          type: "skill",
-          name,
-          description: description || "Imported skill",
-          tags: uniqueStrings(["imported", "skill", sourceId || "external", ...parseJsonishArray(getFrontmatterValue(attrs, ["tags"]))]),
-          meta: {
-            sourceId: sourceId || null,
-            repoUrl,
-            branch,
-            relPath,
-          },
-        }, skillContent, { skipIndexSync: true });
-        imported.push({ id, name, relPath, type: "skill", promptId: null });
-        importedByType.skill += 1;
-        needsSkillIndexRefresh = true;
-        continue;
-      }
-
-      if (kind !== "agent" || !importAgents) continue;
-
-      const baseId = slugify(`${sourceId || "imported"}-${name}`) || slugify(fileStem) || `imported-agent-${imported.length + 1}`;
-      const id = ensureUniqueId(baseId, takenIds);
-      const toolHints = parseJsonishArray(getFrontmatterValue(attrs, ["tools", "enabledTools"]));
-      const profileSkillHints = parseJsonishArray(getFrontmatterValue(attrs, ["skills"]));
-      const mcpHints = parseJsonishArray(getFrontmatterValue(attrs, ["enabledMcpServers", "mcpServers", "mcp"]));
-      const titlePatternHints = parseJsonishArray(getFrontmatterValue(attrs, ["titlePatterns", "title_patterns", "patterns"]));
-      const tags = uniqueStrings([
-        "imported",
-        sourceId || "external",
-        ...parseJsonishArray(getFrontmatterValue(attrs, ["tags"])),
-        ...keywords.slice(0, 4),
-      ]);
-      const pathScopes = uniqueStrings(
-        relPath
-          .split(/[\\/]/)
-          .slice(0, -1)
-          .map((segment) => slugify(segment))
-          .filter((segment) => segment && segment !== "github" && segment !== "agents"),
-      ).slice(0, 6);
-      const explicitScopes = parseJsonishArray(getFrontmatterValue(attrs, ["scopes", "scope"]));
-      const scopes = uniqueStrings([...explicitScopes, ...pathScopes]).slice(0, 8);
-      const titlePatterns = uniqueStrings([
-        ...titlePatternHints,
-        ...keywordTokens(name, { minLength: 4 }).slice(0, 4).map((token) => `\\b${token.replace(/[.*+?^${}()|[\\]\\]/g, "")}\\b`),
-      ]);
-      const promptId = `${id}-prompt`;
-
-      if (importPrompts && body) {
-        upsertEntry(rootDir, {
-          id: promptId,
-          type: "prompt",
-          name: `${name} Prompt`,
-          description: `Imported prompt from ${known?.name || repoUrl}`,
-          tags: uniqueStrings(["imported", "agent-prompt", sourceId || "external"]),
-          meta: {
-            sourceId: sourceId || null,
-            repoUrl,
-            branch,
-            relPath,
-          },
-        }, body);
-        imported.push({ id: promptId, name: `${name} Prompt`, relPath, type: "prompt", promptId: null });
-        importedByType.prompt += 1;
-      }
-
-      const explicitAgentType = String(getFrontmatterValue(attrs, ["agentType", "agent_type"]) || "").trim().toLowerCase();
-      const profile = {
-        id,
-        name,
-        description,
-        titlePatterns: titlePatterns.length ? titlePatterns : ["\\btask\\b"],
-        scopes,
-        sdk: null,
-        model: null,
-        promptOverride: importPrompts && body ? promptId : null,
-        skills: profileSkillHints,
-        hookProfile: null,
-        env: {},
-        enabledTools: toolHints.length ? toolHints : null,
-        enabledMcpServers: mcpHints,
-        tags,
-        agentType: explicitAgentType || (/voice|audio|realtime/i.test(`${name} ${description}`) ? "voice" : "task"),
-        importMeta: {
-          sourceId: sourceId || null,
-          repoUrl,
-          branch,
-          relPath,
-        },
-      };
-
-      upsertEntry(rootDir, {
-        id,
-        type: "agent",
-        name,
-        description,
-        tags: profile.tags,
-        meta: {
-          sourceId: sourceId || null,
-          repoUrl,
-          branch,
-          relPath,
-        },
-      }, profile, { skipIndexSync: true });
-
-      imported.push({ id, name, relPath, type: "agent", promptId: importPrompts && body ? promptId : null });
-      importedByType.agent += 1;
-      needsAgentIndexRefresh = true;
+      const result = importRepositoryMarkdownCandidate(rootDir, candidate, {
+        known,
+        repoUrl,
+        branch,
+        sourceId,
+        importAgents,
+        importSkills,
+        importPrompts,
+        takenIds,
+        imported,
+        importedByType,
+      });
+      needsAgentIndexRefresh = needsAgentIndexRefresh || result.needsAgentIndexRefresh;
+      needsSkillIndexRefresh = needsSkillIndexRefresh || result.needsSkillIndexRefresh;
     }
 
     if (importTools) {
-      const mcpConfigFiles = [
-        { path: resolve(checkoutDir, ".codex", "config.toml"), format: "toml" },
-        { path: resolve(checkoutDir, ".mcp.json"), format: "json" },
-        { path: resolve(checkoutDir, ".vscode", "mcp.json"), format: "json" },
-      ];
-      for (const { path: configPath, format } of mcpConfigFiles) {
-        if (!existsSync(configPath)) continue;
-        let raw = "";
-        try {
-          raw = readFileSync(configPath, "utf8");
-        } catch {
-          continue;
-        }
-        const relPath = relative(checkoutDir, configPath).replace(/\\/g, "/");
-        const discovered = format === "toml"
-          ? parseMcpServersFromToml(raw, relPath)
-          : parseMcpServersFromJson(raw, relPath);
-        for (const mcp of discovered) {
-          const baseId = slugify(`${sourceId || "imported"}-${mcp.id}`) || slugify(mcp.id) || `imported-mcp-${imported.length + 1}`;
-          const id = ensureUniqueId(baseId, takenIds);
-          const content = {
-            id,
-            name: mcp.name,
-            description: "Imported MCP server definition from " + relPath,
-            transport: mcp.transport,
-            command: mcp.transport === "stdio" ? mcp.command : undefined,
-            args: mcp.transport === "stdio" ? mcp.args : undefined,
-            url: mcp.transport === "url" ? mcp.url : undefined,
-            env: Object.keys(mcp.env || {}).length ? mcp.env : undefined,
-            source: "imported",
-            tags: ["imported", "mcp", sourceId || "external"],
-          };
-          upsertEntry(rootDir, {
-            id,
-            type: "mcp",
-            name: mcp.name,
-            description: content.description,
-            tags: uniqueStrings(["imported", "mcp", sourceId || "external"]),
-            meta: {
-              sourceId: sourceId || null,
-              repoUrl,
-              branch,
-              relPath,
-            },
-          }, content);
-          imported.push({ id, name: mcp.name, relPath, type: "mcp", promptId: null });
-          importedByType.mcp += 1;
-        }
-      }
+      importRepositoryMcpEntries(rootDir, checkoutDir, {
+        sourceId,
+        repoUrl,
+        branch,
+        takenIds,
+        imported,
+        importedByType,
+      });
     }
   } finally {
+
     rmSync(checkoutDir, { recursive: true, force: true });
   }