nuxt-skill-hub 0.0.1-beta.1

package/dist/module.mjs

@@ -0,0 +1,1912 @@
+import { promises, existsSync, lstatSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, basename, resolve, dirname, relative, isAbsolute } from 'pathe';
+import { useLogger, defineNuxtModule } from '@nuxt/kit';
+import { resolvePackageJSON, readPackageJSON } from 'pkg-types';
+import { createConsola } from 'consola';
+import { detectInstalledAgents, expandPath, detectCurrentAgent, getAgentIds, getAgentConfig } from 'unagent/env';
+import { homedir } from 'node:os';
+import matter from 'gray-matter';
+import { transform } from 'automd';
+import { fileURLToPath } from 'node:url';
+import { downloadTemplate } from 'giget';
+import { ofetch } from 'ofetch';
+
+const version = "0.0.1-beta.1";
+const packageJson = {
+	version: version};
+
+const metadata = packageJson;
+const PACKAGE_VERSION = metadata.version;
+
+function resolveSkillsDir(target, config) {
+  if (config?.skillsDir) {
+    return config.skillsDir;
+  }
+  if (target === "codex") {
+    return "skills";
+  }
+  return void 0;
+}
+function normalizeTarget(target) {
+  return target.trim();
+}
+function getRawTargetConfig(target) {
+  return getAgentConfig(target);
+}
+function getSupportedTargets() {
+  return getAgentIds().filter((target) => {
+    const config = getRawTargetConfig(target);
+    return Boolean(resolveSkillsDir(target, config));
+  }).sort((a, b) => a.localeCompare(b));
+}
+function resolveAgentTargetConfig(target) {
+  const normalized = normalizeTarget(target);
+  if (!normalized) {
+    return void 0;
+  }
+  const config = getRawTargetConfig(normalized);
+  const skillsDir = resolveSkillsDir(normalized, config);
+  if (!config || !skillsDir) {
+    return void 0;
+  }
+  return {
+    target: normalized,
+    configDir: expandPath(config.configDir),
+    skillsDir
+  };
+}
+function validateTargets(targets) {
+  const uniqueTargets = Array.from(new Set(targets.map(normalizeTarget).filter(Boolean)));
+  const valid = [];
+  const invalid = [];
+  for (const target of uniqueTargets) {
+    const config = getRawTargetConfig(target);
+    if (!config) {
+      invalid.push({
+        target,
+        reason: "unknown-target"
+      });
+      continue;
+    }
+    if (!resolveSkillsDir(target, config)) {
+      invalid.push({
+        target,
+        reason: "missing-skills-dir"
+      });
+      continue;
+    }
+    valid.push(target);
+  }
+  return { valid, invalid };
+}
+function detectCurrentTarget() {
+  const current = detectCurrentAgent();
+  if (!current) return void 0;
+  const skillsDir = resolveSkillsDir(current.id, current.config);
+  return skillsDir ? current.id : void 0;
+}
+function detectInstalledTargets(rootDir) {
+  return Array.from(new Set(
+    detectInstalledAgents().filter((agent) => agent.detected === "config" && resolveSkillsDir(agent.id, agent.config)).map((agent) => agent.id)
+  )).sort((a, b) => a.localeCompare(b));
+}
+
+const DEFAULT_NUXT_CONTENT_METADATA = {
+  id: "nuxt-best-practices",
+  version: PACKAGE_VERSION,
+  experimental: true,
+  description: "Nuxt-native decision packs and best-practice rule packs for AI execution. Complements docs, not a replacement.",
+  packIds: [
+    "abstraction-disambiguation",
+    "page-meta-head-layout",
+    "error-surfaces-recovery",
+    "verification-finish",
+    "data-fetching-ssr",
+    "hydration-consistency",
+    "architecture-boundaries",
+    "server-routes-runtime-config",
+    "nitro-h3-patterns",
+    "plugins",
+    "performance-rendering",
+    "module-authoring",
+    "migrations"
+  ],
+  packs: [
+    {
+      id: "abstraction-disambiguation",
+      title: "Abstraction Disambiguation",
+      focus: "Choose Nuxt-owned abstractions before generic Vue, raw HTML, or ad hoc glue code.",
+      triggers: ["A generic Vue or HTML fix looks plausible", "You need to decide whether Nuxt, Nuxt Content, or Nuxt UI already owns the surface"],
+      relativePath: "rules/abstraction-disambiguation.md"
+    },
+    {
+      id: "page-meta-head-layout",
+      title: "Page Meta, Head, and Layout",
+      focus: "Separate page behavior, document metadata, and layout structure before editing.",
+      triggers: ["Pages, layouts, middleware, or page options", "Title, meta tags, canonical URLs, or OG metadata"],
+      relativePath: "rules/page-meta-head-layout.md"
+    },
+    {
+      id: "error-surfaces-recovery",
+      title: "Error Surfaces and Recovery",
+      focus: "Cover both global and local error boundaries and use the right recovery utilities.",
+      triggers: ["Global error pages or local error boundaries", "Recovery flows, clearError, showError, or fallback UI"],
+      relativePath: "rules/error-surfaces-recovery.md"
+    },
+    {
+      id: "verification-finish",
+      title: "Verification and Finish",
+      focus: "Verify the intended framework behavior and re-check paired surfaces before concluding work.",
+      triggers: ["The fix spans more than one surface", "You are about to finish a Nuxt change and need to confirm the right abstraction"],
+      relativePath: "rules/verification-finish.md"
+    },
+    {
+      id: "data-fetching-ssr",
+      title: "Data Fetching and SSR",
+      focus: "Deduplication, payload correctness, and request-safe loading.",
+      triggers: ["Pages, layouts, or composables fetching initial data", "SSR-visible content or hydration-sensitive state"],
+      relativePath: "rules/data-fetching-ssr.md"
+    },
+    {
+      id: "hydration-consistency",
+      title: "Hydration and SSR Consistency",
+      focus: "SSR/CSR determinism, client-only boundaries, and mismatch prevention.",
+      triggers: ["Hydration warnings or client-only rendering", "State that differs between server and browser"],
+      relativePath: "rules/hydration-consistency.md"
+    },
+    {
+      id: "architecture-boundaries",
+      title: "Architecture Boundaries",
+      focus: "Server-only secrets, request isolation, and safe shared abstractions.",
+      triggers: ["Crossing server/client boundaries", "Composable or utility architecture changes"],
+      relativePath: "rules/architecture-boundaries.md"
+    },
+    {
+      id: "server-routes-runtime-config",
+      title: "Server Routes and Runtime Config",
+      focus: "Runtime config exposure, env handling, and route-level contracts.",
+      triggers: ["nuxt.config, runtime config, or env wiring", "Server route config and public/private config exposure"],
+      relativePath: "rules/server-routes-runtime-config.md"
+    },
+    {
+      id: "nitro-h3-patterns",
+      title: "Nitro and h3 Server Patterns",
+      focus: "Handler contracts, caching, and edge-safe server behavior.",
+      triggers: ["Server routes, middleware, Nitro plugins, or h3 handlers", "API behavior, caching, or edge runtime concerns"],
+      relativePath: "rules/nitro-h3-patterns.md"
+    },
+    {
+      id: "plugins",
+      title: "Plugins and Runtime Boot",
+      focus: "Plugin ordering, startup cost, and app/runtime initialization.",
+      triggers: ["Plugins, app boot logic, or injected runtime helpers", "Global runtime behavior changes"],
+      relativePath: "rules/plugins.md"
+    },
+    {
+      id: "performance-rendering",
+      title: "Performance and Rendering",
+      focus: "Rendering strategy, payload cost, and lazy loading tradeoffs.",
+      triggers: ["Performance regressions or rendering strategy changes", "Link, asset, and bundle cost decisions"],
+      relativePath: "rules/performance-rendering.md"
+    },
+    {
+      id: "module-authoring",
+      title: "Module Authoring Conventions",
+      focus: "Nuxt Kit patterns, module lifecycle, and ecosystem-safe authoring.",
+      triggers: ["Writing or refactoring a Nuxt module", "Module install/setup conventions"],
+      relativePath: "rules/module-authoring.md"
+    },
+    {
+      id: "migrations",
+      title: "Migrations and Compatibility",
+      focus: "Incremental upgrades, compatibility boundaries, and rollout safety.",
+      triggers: ["Upgrades, deprecations, or breaking behavior changes", "Compatibility fixes across Nuxt versions"],
+      relativePath: "rules/migrations.md"
+    }
+  ]
+};
+const EMPTY_MODULE_GUIDANCE_MARKDOWN = "_No module skills discovered. Use Nuxt guidance plus official module docs when module-specific guidance is missing._";
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+function getSourceLabel(sourceKind) {
+  switch (sourceKind) {
+    case "dist":
+      return "Installed package skill";
+    case "github":
+      return "Resolved module skill";
+    case "generated":
+      return "Metadata-routed skill";
+  }
+}
+function getTrustLevel(official) {
+  return official ? "official" : "community";
+}
+function formatCompactLinks(entry, labels) {
+  const links = [];
+  if (entry.docsUrl) {
+    links.push(`${labels.docs}: [${entry.docsUrl}](${entry.docsUrl})`);
+  }
+  if (entry.repoUrl) {
+    links.push(`${labels.repo}: [${entry.repoUrl}](${entry.repoUrl})`);
+  }
+  return links.join("\n");
+}
+function resolveMetadataRouterSkillName(packageName) {
+  if (packageName.startsWith("@")) {
+    const [scope, name] = packageName.split("/");
+    if (scope === "@nuxt" && name) {
+      return `nuxt-${name}`;
+    }
+    return (name || scope?.replace(/^@/, "") || "").trim();
+  }
+  return packageName.trim();
+}
+function createMetadataRouterSkillFiles(input) {
+  const description = input.description?.trim() || `Metadata-routed module skill for ${input.packageName}. Use it to reach the official docs and upstream source.`;
+  const linkLines = createCompactMetadataRouterContent(input).trim();
+  return {
+    "SKILL.md": `---
+name: ${yamlString(input.skillName)}
+description: ${yamlString(description)}
+---
+
+${linkLines || "Docs: unavailable\nSource code: unavailable"}
+`
+  };
+}
+function withDerivedModuleFields(entry) {
+  return {
+    ...entry,
+    sourceLabel: entry.sourceLabel || getSourceLabel(entry.sourceKind),
+    trustLevel: entry.trustLevel || getTrustLevel(entry.official)
+  };
+}
+function formatVersion(version) {
+  return version ? `v${version}` : void 0;
+}
+function relativeModuleLink(entry, prefix) {
+  const path = entry.entryPath || entry.wrapperPath;
+  if (!path) {
+    return "";
+  }
+  return `${prefix}${path.replace(/^references\/modules\//, "")}`;
+}
+function groupModuleEntries(entries) {
+  const officialUpstream = entries.filter((entry) => entry.sourceKind === "dist");
+  const githubResolved = entries.filter((entry) => entry.sourceKind === "github");
+  const metadataRouted = entries.filter((entry) => entry.sourceKind === "generated");
+  return { officialUpstream, githubResolved, metadataRouted };
+}
+function hasModuleGuidance(entries, skipped = []) {
+  return entries.length > 0 || skipped.length > 0;
+}
+function renderModuleGroup(title, entries, prefix) {
+  if (!entries.length) {
+    return "";
+  }
+  const lines = entries.map((rawEntry) => {
+    const entry = withDerivedModuleFields(rawEntry);
+    const wrapperLink = relativeModuleLink(entry, prefix);
+    const description = entry.description ? ` ${entry.description}` : "";
+    const version = formatVersion(entry.version);
+    const versionLabel = version ? ` \`${version}\`` : "";
+    return `- [${entry.packageName}](${wrapperLink})${versionLabel} - ${entry.sourceLabel}. Trust: \`${entry.trustLevel}\`.${description}`;
+  });
+  return `### ${title}
+${lines.join("\n")}
+`;
+}
+function renderSkippedEntries(skipped) {
+  if (!skipped.length) {
+    return "";
+  }
+  const lines = skipped.map((entry) => {
+    const base = `- **${entry.packageName}** / \`${entry.skillName}\``;
+    const source = entry.sourceKind ? ` (\`${entry.sourceKind}\`)` : "";
+    return `${base}${source}: ${entry.reason}. Use the relevant Nuxt pack plus the module's official docs.`;
+  });
+  return `### Skipped or unavailable
+${lines.join("\n")}
+`;
+}
+function findPack(metadata, id) {
+  return metadata.packs.find((pack) => pack.id === id) || metadata.packs[0];
+}
+function createPackSummary(metadata, packIds) {
+  return packIds.map((packId) => `\`${findPack(metadata, packId).title}\``).join(", ");
+}
+function getSkillRenderProfile(includeModuleAuthoring = false) {
+  if (includeModuleAuthoring) {
+    return {
+      includeModuleAuthoring,
+      packSummaryIds: [
+        "module-authoring",
+        "plugins",
+        "architecture-boundaries",
+        "nitro-h3-patterns",
+        "migrations"
+      ]
+    };
+  }
+  return {
+    includeModuleAuthoring: false,
+    packSummaryIds: [
+      "abstraction-disambiguation",
+      "page-meta-head-layout",
+      "error-surfaces-recovery",
+      "verification-finish",
+      "data-fetching-ssr"
+    ]
+  };
+}
+function packLink(metadata, id) {
+  const pack = findPack(metadata, id);
+  return `[${pack.title}](./references/nuxt/${pack.relativePath})`;
+}
+function createRoutingTable(metadata, includeModuleAuthoring = false) {
+  const rows = [
+    ...includeModuleAuthoring ? [{
+      symptom: "Writing, refactoring, or publishing a Nuxt module",
+      packId: "module-authoring",
+      why: "Start with Nuxt Kit-safe authoring patterns, lifecycle hooks, prefixed public APIs, and skill scope boundaries."
+    }] : [],
+    {
+      symptom: "SSR, initial page load, route params, or hydration-sensitive data",
+      packId: "data-fetching-ssr",
+      why: "Prefer `useFetch` or `useAsyncData` over setup-time `$fetch` or `onMounted` fetches."
+    },
+    {
+      symptom: "Page options, route middleware, layout selection, title, meta tags, or OG data",
+      packId: "page-meta-head-layout",
+      why: "Separate page behavior from document metadata and layout structure before editing."
+    },
+    {
+      symptom: "A generic Vue fix or raw HTML implementation looks tempting",
+      packId: "abstraction-disambiguation",
+      why: "Check whether Nuxt, Nuxt Content, or Nuxt UI already owns the abstraction."
+    },
+    {
+      symptom: "The remaining work is mostly `.vue` components, composables, reactivity, or SFC structure",
+      link: "[Vue Best Practices](./references/vue/SKILL.md)",
+      why: "Switch to Vue-specific guidance after the Nuxt ownership and routing decisions are already settled."
+    },
+    {
+      symptom: "Global errors, local fallback UI, `clearError`, `showError`, or recovery flows",
+      packId: "error-surfaces-recovery",
+      why: "Nuxt error handling often needs both global and local surfaces to be correct."
+    },
+    {
+      symptom: "Secrets, runtime config, privileged API calls, or server/client boundary confusion",
+      packId: "architecture-boundaries",
+      why: "Move sensitive logic server-side first, then pair with config and route rules as needed."
+    },
+    {
+      symptom: "Before finishing a fix that spans multiple files or surfaces",
+      packId: "verification-finish",
+      why: "Re-check paired surfaces and verify framework behavior, not only the visible output."
+    }
+  ];
+  return [
+    "| Task shape or symptom | Load first | Why |",
+    "| --- | --- | --- |",
+    ...rows.map((row) => `| ${row.symptom} | ${"link" in row ? row.link : packLink(metadata, row.packId)} | ${row.why} |`)
+  ].join("\n");
+}
+function createNuxtPackTable(metadata) {
+  const rows = metadata.packs.map(
+    (pack) => `| [${pack.title}](./references/nuxt/${pack.relativePath}) | ${pack.focus} | ${pack.triggers.join("<br>")} |`
+  );
+  return [
+    "| Pack | Focus | Typical triggers |",
+    "| --- | --- | --- |",
+    ...rows
+  ].join("\n");
+}
+function createVueGuidanceSection() {
+  return `## Vue guidance
+
+Use [Vue Best Practices](./references/vue/SKILL.md) when the task is mainly Vue component, composable, reactivity, props/emits, or SFC work and Nuxt no longer owns the abstraction.
+
+Start with these must-read Vue references:
+- [reactivity](./references/vue/references/reactivity.md)
+- [sfc](./references/vue/references/sfc.md)
+- [component-data-flow](./references/vue/references/component-data-flow.md)
+- [composables](./references/vue/references/composables.md)
+`;
+}
+function createSkillMapSections(metadata, entries, skipped = [], includeModuleAuthoring = false) {
+  const includeModuleSections = hasModuleGuidance(entries, skipped);
+  const grouped = groupModuleEntries(entries);
+  const moduleSections = [
+    renderModuleGroup("Official upstream skills", grouped.officialUpstream, "./references/modules/"),
+    renderModuleGroup("Resolved module skills", grouped.githubResolved, "./references/modules/"),
+    renderModuleGroup("Metadata-routed skills", grouped.metadataRouted, "./references/modules/"),
+    renderSkippedEntries(skipped)
+  ].filter(Boolean);
+  const moduleGuideContent = moduleSections.join("\n");
+  const audienceGuide = includeModuleAuthoring ? `
+## Module author focus
+
+This skill includes extra guidance for Nuxt module authors on top of the default app-oriented Nuxt packs.
+If the task touches \`defineNuxtModule\`, Nuxt Kit hooks, generated runtime files, prefixed public APIs, or release compatibility, start with ${packLink(metadata, "module-authoring")} before branching into the broader app-oriented packs.
+` : "";
+  const moduleWorkflowSteps = includeModuleSections ? `
+5. If an installed module is involved, open its entry under \`references/modules\`.
+6. Copied skills go straight to their \`SKILL.md\`; metadata-routed modules only expose docs and source links.` : "";
+  const moduleGuidesSection = includeModuleSections ? `
+## Module guides
+
+Open the linked module entry first. Copied skills link straight to their \`SKILL.md\`; metadata-routed modules use a small docs/source router when no copied skill exists.
+
+${moduleGuideContent}
+` : `
+## Module guides
+
+${EMPTY_MODULE_GUIDANCE_MARKDOWN}
+`;
+  return `## How to use this skill map
+1. Explore the current surface first: page, layout, component, server handler, content collection, or module-owned file.
+2. Load the first matching Nuxt pack from the routing table below.
+3. If the remaining work is mainly Vue component or composable implementation, switch to [Vue Best Practices](./references/vue/SKILL.md).
+4. Open deeper Nuxt packs only when the first pack points you there.
+${moduleWorkflowSteps}
+${audienceGuide}
+
+## Common forks in the road
+
+${createRoutingTable(metadata, includeModuleAuthoring)}
+
+${createVueGuidanceSection()}
+
+## All Nuxt packs
+
+${createNuxtPackTable(metadata)}
+${moduleGuidesSection}
+`;
+}
+function createSkillEntrypoint(skillName, metadata, monorepoScopePath, includeModuleAuthoring = false, entries = [], skipped = []) {
+  const profile = getSkillRenderProfile(includeModuleAuthoring);
+  const includeModuleSections = hasModuleGuidance(entries, skipped);
+  const description = "Always-on Nuxt disambiguation layer for this project. Use it to choose the right Nuxt pack first, then switch to Vue or module guidance only when Nuxt no longer owns the abstraction.";
+  const monorepoScopeSection = monorepoScopePath ? `
+## Monorepo Scope
+This skill applies only to the \`${monorepoScopePath}\` subtree of this monorepo.
+Treat files and tasks outside \`${monorepoScopePath}\` as out of scope unless the user explicitly redirects you there.
+` : "";
+  const audienceSection = profile.includeModuleAuthoring ? `
+
+## Module Author Focus
+This skill keeps the default Nuxt app guidance and adds an authoring layer for repositories that build Nuxt modules.
+Start with [Module Authoring Conventions](./references/nuxt/rules/module-authoring.md) for \`defineNuxtModule\`, lifecycle hooks, prefixed public APIs, and module-scoped skill boundaries, then fall back to the broader app packs when the task crosses into runtime behavior.
+` : "";
+  const activationFlow = `1. Explore the project first: inspect the real page, component, route, server handler, collection, or module surface you are changing.
+2. Use the routing sections in this file and load the smallest matching Nuxt pack.
+3. If the remaining work is mainly Vue component, composable, reactivity, or SFC work, open [Vue Best Practices](./references/vue/SKILL.md).
+4. If module authoring is part of the task, load [Module Authoring Conventions](./references/nuxt/rules/module-authoring.md) before changing \`defineNuxtModule\`, runtime extensions, hooks, or release scaffolding.${includeModuleSections ? `
+5. If an installed module owns the problem, open its entry under [references/modules](./references/modules).
+6. Apply module guidance as delta-only rules inside that module's APIs, config, runtime behavior, and owned files.` : ""}`;
+  const frequencyBullets = profile.includeModuleAuthoring ? `- If the task changes module boot or heavy setup work, prefer lightweight \`setup\` plus lifecycle hooks before adding blocking async work.
+- If the module exposes routes, composables, components, or config, prefix public surfaces with module identity before shipping generic names.
+- If the implementation relies on undocumented Nuxt internals, confirm there is not a public \`@nuxt/kit\` API or documented hook first.
+- If the task adds or edits a bundled module skill, keep it strictly scoped to the module's APIs, integration points, and caveats.
+- If runtime config, server handlers, or generated files are involved, pair module-author guidance with the relevant server, Nitro, plugin, or migration pack instead of improvising cross-boundary behavior.
+- If the work is version-sensitive, check compatibility constraints and migration boundaries before expanding the module surface.
+- If the task touches SSR, initial page load, or route-driven data, prefer \`useFetch\` or \`useAsyncData\` before \`onMounted\` plus \`$fetch\`.
+- If the task changes page options, layout selection, route middleware, or page-level behavior, check \`definePageMeta\` before adding ad hoc wiring.
+- If the task changes title, meta tags, canonical URLs, or OG data, check \`useHead\` or \`useSeoMeta\` before page-meta or template markup.
+- If content lives in JSON or YAML records, or the UI needs generated docs navigation, choose data collections and collection-navigation primitives before manual assembly.
+- If the UI surface is page chrome, a table, a form, a modal, a command palette, or a dropdown, prefer a Nuxt UI primitive before raw HTML or custom listeners.
+- If runtime config, tokens, secrets, or privileged API calls are involved, keep them server-side and expose only a server route or the minimum public config.
+- If hydration, browser-only APIs, time, randomness, or cookies are involved, use SSR-safe primitives first and isolate browser-only work behind \`ClientOnly\` or \`onMounted\`.
+- If the fix touches errors, fallback UI, or recovery flow, check both global and local surfaces before concluding the work is complete.
+- If the solution looks correct but uses generic Vue or hand-rolled HTML, confirm Nuxt, Nuxt Content, or Nuxt UI does not already own that abstraction.${includeModuleSections ? `
+- If the task is module-specific, use the module entry and keep module guidance scoped; do not replace broad Nuxt rules with module-specific rules.` : ""}` : `- If the task touches SSR, initial page load, or route-driven data, prefer \`useFetch\` or \`useAsyncData\` before \`onMounted\` plus \`$fetch\`.
+- If the task changes page options, layout selection, route middleware, or page-level behavior, check \`definePageMeta\` before adding ad hoc wiring.
+- If the task changes title, meta tags, canonical URLs, or OG data, check \`useHead\` or \`useSeoMeta\` before page-meta or template markup.
+- If content lives in JSON or YAML records, or the UI needs generated docs navigation, choose data collections and collection-navigation primitives before manual assembly.
+- If the UI surface is page chrome, a table, a form, a modal, a command palette, or a dropdown, prefer a Nuxt UI primitive before raw HTML or custom listeners.
+- If runtime config, tokens, secrets, or privileged API calls are involved, keep them server-side and expose only a server route or the minimum public config.
+- If hydration, browser-only APIs, time, randomness, or cookies are involved, use SSR-safe primitives first and isolate browser-only work behind \`ClientOnly\` or \`onMounted\`.
+- If the fix touches errors, fallback UI, or recovery flow, check both global and local surfaces before concluding the work is complete.
+- If the solution looks correct but uses generic Vue or hand-rolled HTML, confirm Nuxt, Nuxt Content, or Nuxt UI does not already own that abstraction.${includeModuleSections ? `
+- If the task is module-specific, use the module entry and keep module guidance scoped; do not replace broad Nuxt rules with module-specific rules.` : ""}`;
+  const beforeCompletion = profile.includeModuleAuthoring ? `- Did I start from Nuxt Kit and documented lifecycle hooks before reaching for private internals?
+- Did I keep public APIs collision-resistant and module-scoped?
+- Did I keep module skill guidance as a delta on top of Nuxt guidance instead of restating framework-global rules?
+- Did I verify compatibility, install/setup cost, and cross-boundary behavior before concluding the work is complete?
+- Did I still verify the relevant app/runtime surfaces when the module work crossed into SSR, Nitro, plugins, config, or UI behavior?` : `- Did I choose a Nuxt primitive where a generic Vue or raw HTML solution would be tempting?
+- Did I check whether the fix needs a second surface such as global or local, or server or client?
+- Did I choose the right concept pair: page meta vs head, data collection vs page collection, component primitive vs custom markup?
+- Did I verify the framework behavior that matters, not just the visible output?`;
+  return `---
+name: ${yamlString(skillName)}
+description: ${yamlString(description)}
+---
+
+# Nuxt Skill Index
+
+This file keeps the highest-frequency Nuxt decisions in context.
+Use it to avoid generic Vue fallbacks, then route into the right Nuxt pack, Vue guidance, or module delta skill.
+${monorepoScopeSection}
+${audienceSection}
+
+## Activation Flow
+${activationFlow}
+
+## High-Frequency Nuxt Decisions
+${frequencyBullets}
+
+## Precedence
+- Repository-global instructions and required workflows win first.
+- This file keeps the common Nuxt forks in context.
+- Nuxt packs provide deeper framework guidance.
+- Vue guidance covers component, composable, and SFC patterns after the Nuxt decision is settled.
+${includeModuleSections ? "- Module entries add delta-only guidance inside explicit module scope." : ""}
+
+${createSkillMapSections(metadata, entries, skipped, includeModuleAuthoring)}
+
+## Before Completion
+${beforeCompletion}
+
+## Primary Packs
+Start with ${createPackSummary(metadata, profile.packSummaryIds)} when the task matches one of those common routes.
+
+---
+
+_Generated by nuxt-skill-hub. Do not edit this file manually._
+`;
+}
+function createCompactMetadataRouterContent(entry) {
+  return `${formatCompactLinks(entry, {
+    docs: "Docs",
+    repo: "Source code"
+  })}
+`;
+}
+
+async function loadNuxtRuleFilesFromDir(nuxtContentDir) {
+  const entries = [];
+  for await (const relativePath of promises.glob("**/*", { cwd: nuxtContentDir })) {
+    const absolutePath = join(nuxtContentDir, relativePath);
+    if (relativePath === "index.template.md" || relativePath.split("/").some((segment) => segment.startsWith(".")) || basename(relativePath).startsWith("_") || !(await promises.lstat(absolutePath)).isFile()) {
+      continue;
+    }
+    entries.push([relativePath, await promises.readFile(absolutePath, "utf8")]);
+  }
+  entries.sort((a, b) => a[0].localeCompare(b[0]));
+  return Object.fromEntries(entries);
+}
+async function loadNuxtIndexTemplateFromDir(nuxtContentDir) {
+  return await promises.readFile(join(nuxtContentDir, "index.template.md"), "utf8");
+}
+async function loadNuxtMetadata$1() {
+  return DEFAULT_NUXT_CONTENT_METADATA;
+}
+
+const NUXT_CONTENT_SOURCE_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../nuxt-best-practices");
+async function loadNuxtRuleFiles() {
+  return await loadNuxtRuleFilesFromDir(NUXT_CONTENT_SOURCE_DIR);
+}
+async function loadNuxtIndexTemplate() {
+  return await loadNuxtIndexTemplateFromDir(NUXT_CONTENT_SOURCE_DIR);
+}
+async function loadNuxtMetadata() {
+  return await loadNuxtMetadata$1();
+}
+
+async function loadVueSkillFilesFromDir(vueContentDir) {
+  const entries = [];
+  for await (const relativePath of promises.glob("**/*", { cwd: vueContentDir })) {
+    const absolutePath = join(vueContentDir, relativePath);
+    if (relativePath.split("/").some((segment) => segment.startsWith(".")) || basename(relativePath).startsWith("_") || !(await promises.lstat(absolutePath)).isFile()) {
+      continue;
+    }
+    entries.push([relativePath, await promises.readFile(absolutePath, "utf8")]);
+  }
+  entries.sort((a, b) => a[0].localeCompare(b[0]));
+  return Object.fromEntries(entries);
+}
+
+const VUE_SKILLS_REPO = "vuejs-ai/skills";
+const VUE_SKILLS_PATH = "skills/vue-best-practices";
+const FALLBACK_DIR = resolve(dirname(fileURLToPath(import.meta.url)), "../vue-content");
+async function resolveVueContentDir(cacheRoot) {
+  const targetDir = resolve(cacheRoot, "vue-best-practices");
+  try {
+    await downloadTemplate(`gh:${VUE_SKILLS_REPO}/${VUE_SKILLS_PATH}`, {
+      dir: targetDir,
+      force: true,
+      forceClean: true,
+      registry: false,
+      silent: true
+    });
+    return targetDir;
+  } catch {
+    if (existsSync(FALLBACK_DIR)) return FALLBACK_DIR;
+    throw new Error("Failed to fetch Vue skill content and no local fallback found");
+  }
+}
+async function loadVueSkillFiles(cacheRoot) {
+  const dir = await resolveVueContentDir(cacheRoot);
+  return loadVueSkillFilesFromDir(dir);
+}
+
+const MANAGED_HINT_START = "<!-- nuxt-skill-hub:start -->";
+const MANAGED_HINT_END = "<!-- nuxt-skill-hub:end -->";
+const SKILL_NAME_MAX_LENGTH = 64;
+const SKILL_NAME_PATTERN = /^[a-z0-9-]+$/;
+async function pathExists(path) {
+  try {
+    await promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(path) {
+  await promises.mkdir(path, { recursive: true });
+}
+async function emptyDir(path) {
+  for (let attempt = 0; attempt < 4; attempt++) {
+    try {
+      await promises.rm(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+      break;
+    } catch (error) {
+      const code = error.code;
+      if ((code === "ENOTEMPTY" || code === "EBUSY") && attempt < 3) {
+        await new Promise((resolve2) => setTimeout(resolve2, 50));
+        continue;
+      }
+      throw error;
+    }
+  }
+  await ensureDir(path);
+}
+async function writeFileIfChanged(path, contents) {
+  const previous = await pathExists(path) ? await promises.readFile(path, "utf8") : null;
+  if (previous === contents) {
+    return;
+  }
+  await ensureDir(dirname(path));
+  await promises.writeFile(path, contents, "utf8");
+}
+async function hasWorkspacePackageConfig(path) {
+  const packageJsonPath = join(path, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const packageJson = JSON.parse(await promises.readFile(packageJsonPath, "utf8"));
+    return Array.isArray(packageJson.workspaces) || !!packageJson.workspaces && typeof packageJson.workspaces === "object";
+  } catch {
+    return false;
+  }
+}
+async function resolveExportRoot(rootDir) {
+  const appRoot = resolve(rootDir);
+  let current = appRoot;
+  while (true) {
+    if (await pathExists(join(current, "pnpm-workspace.yaml")) || await hasWorkspacePackageConfig(current)) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return appRoot;
+    }
+    current = parent;
+  }
+}
+function resolveMonorepoScopePath(rootDir, exportRoot) {
+  const appRoot = resolve(rootDir);
+  const resolvedExportRoot = resolve(exportRoot);
+  if (appRoot === resolvedExportRoot) {
+    return void 0;
+  }
+  const scopePath = relative(resolvedExportRoot, appRoot).replace(/\/+$/, "");
+  return scopePath || void 0;
+}
+function createValidationIssue(packageName, skillName, reason, sourceKind) {
+  return {
+    severity: "warning",
+    packageName,
+    skillName,
+    reason,
+    sourceKind
+  };
+}
+function isValidSkillName(name) {
+  if (!name || name.length > SKILL_NAME_MAX_LENGTH) {
+    return false;
+  }
+  if (!SKILL_NAME_PATTERN.test(name)) {
+    return false;
+  }
+  if (name.startsWith("-") || name.endsWith("-") || name.includes("--")) {
+    return false;
+  }
+  return true;
+}
+function parseAgentSkillDeclarations(pkg, packageName, sourceKind) {
+  const raw = pkg && typeof pkg === "object" ? pkg.agents?.skills : void 0;
+  if (!Array.isArray(raw)) {
+    return { skills: [], issues: [] };
+  }
+  const skills = [];
+  const issues = [];
+  for (const [index, entry] of raw.entries()) {
+    if (!entry || typeof entry !== "object") {
+      issues.push(createValidationIssue(packageName, `entry-${index + 1}`, "agents.skills entry must be an object", sourceKind));
+      continue;
+    }
+    const name = typeof entry.name === "string" ? entry.name.trim() : "";
+    const path = typeof entry.path === "string" ? entry.path.trim() : "";
+    if (!name) {
+      issues.push(createValidationIssue(packageName, `entry-${index + 1}`, 'agents.skills entry is missing a non-empty "name"', sourceKind));
+      continue;
+    }
+    if (!path) {
+      issues.push(createValidationIssue(packageName, name, 'agents.skills entry is missing a non-empty "path"', sourceKind));
+      continue;
+    }
+    if (!isValidSkillName(name)) {
+      issues.push(createValidationIssue(packageName, name, "skill name must be hyphen-case, lowercase, <=64 chars, and cannot contain consecutive hyphens", sourceKind));
+      continue;
+    }
+    skills.push({ name, path });
+  }
+  return { skills, issues };
+}
+function packageNameFromSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const [scope, name] = specifier.split("/");
+    return name ? `${scope}/${name}` : specifier;
+  }
+  return specifier.split("/")[0] || specifier;
+}
+function extractModuleSpecifier(moduleEntry) {
+  if (typeof moduleEntry === "string") {
+    return moduleEntry;
+  }
+  if (Array.isArray(moduleEntry) && typeof moduleEntry[0] === "string") {
+    return moduleEntry[0];
+  }
+  return null;
+}
+function isPackageSpecifier(specifier) {
+  if (!specifier) {
+    return false;
+  }
+  if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("file:")) {
+    return false;
+  }
+  return true;
+}
+function isSubPath(parent, child) {
+  const rel = relative(resolve(parent), resolve(child));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+function readRepositoryUrl(repository) {
+  if (typeof repository === "string") return repository;
+  if (repository && typeof repository.url === "string") return repository.url;
+  return void 0;
+}
+async function discoverInstalledPackageFromSpecifier(specifier, rootDir) {
+  if (!isPackageSpecifier(specifier)) {
+    return null;
+  }
+  let packageJsonPath;
+  try {
+    packageJsonPath = await resolvePackageJSON(specifier, { url: rootDir });
+  } catch {
+    const fallback = join(rootDir, "node_modules", packageNameFromSpecifier(specifier), "package.json");
+    if (!existsSync(fallback)) return null;
+    packageJsonPath = fallback;
+  }
+  return readInstalledPackageMetadata(packageJsonPath, specifier);
+}
+async function discoverInstalledPackageFromDirectory(directory) {
+  const packageJsonPath = join(directory, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return null;
+  }
+  return readInstalledPackageMetadata(packageJsonPath);
+}
+async function readInstalledPackageMetadata(packageJsonPath, fallbackSpecifier) {
+  const pkg = await readPackageJSON(packageJsonPath);
+  return {
+    packageName: pkg.name || (fallbackSpecifier ? packageNameFromSpecifier(fallbackSpecifier) : basename(dirname(packageJsonPath))),
+    version: pkg.version,
+    description: pkg.description,
+    packageRoot: dirname(packageJsonPath),
+    repository: readRepositoryUrl(pkg.repository),
+    homepage: pkg.homepage,
+    packageData: pkg
+  };
+}
+function discoverPackageSkillsFromInstalledPackage(installedPackage, sourceKind = "dist") {
+  const parsed = parseAgentSkillDeclarations(installedPackage.packageData, installedPackage.packageName, sourceKind);
+  const skills = parsed.skills;
+  if (!skills.length && !parsed.issues.length) {
+    return null;
+  }
+  return {
+    packageName: installedPackage.packageName,
+    version: installedPackage.version,
+    packageRoot: installedPackage.packageRoot,
+    skills,
+    issues: parsed.issues
+  };
+}
+async function discoverLocalPackageSkills(rootDir) {
+  const packageJsonPath = join(rootDir, "package.json");
+  if (!await pathExists(packageJsonPath)) {
+    return null;
+  }
+  const pkg = await readPackageJSON(packageJsonPath);
+  const packageName = pkg.name || "local-project";
+  const parsed = parseAgentSkillDeclarations(pkg, packageName, "dist");
+  if (!parsed.skills.length && !parsed.issues.length) {
+    return null;
+  }
+  return {
+    packageName,
+    version: pkg.version,
+    packageRoot: rootDir,
+    skills: parsed.skills,
+    issues: parsed.issues
+  };
+}
+function normalizeSkillName(rawSkillName, sourceDir) {
+  return rawSkillName?.trim() || basename(sourceDir).trim();
+}
+function normalizeContribution(contribution, sourceDir, sourceRoot) {
+  return {
+    packageName: contribution.packageName,
+    version: contribution.version,
+    sourceDir,
+    sourceRoot,
+    skillName: normalizeSkillName(contribution.skillName, sourceDir),
+    sourceKind: contribution.sourceKind || "dist",
+    description: contribution.description,
+    sourceRepo: contribution.sourceRepo,
+    sourceRef: contribution.sourceRef,
+    sourcePath: contribution.sourcePath,
+    repoUrl: contribution.repoUrl,
+    docsUrl: contribution.docsUrl,
+    official: contribution.official ?? true,
+    resolver: contribution.resolver || "agentsField",
+    forceIncludeScripts: contribution.forceIncludeScripts ?? false
+  };
+}
+async function validateContribution(contribution) {
+  const issues = [];
+  if (!isSubPath(contribution.sourceRoot, contribution.sourceDir)) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, "skill path must stay within package root", contribution.sourceKind));
+  }
+  if (!isValidSkillName(contribution.skillName)) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, "skill name must be hyphen-case, lowercase, <=64 chars, and cannot contain consecutive hyphens", contribution.sourceKind));
+  }
+  const sourceDirName = basename(contribution.sourceDir);
+  if (sourceDirName !== contribution.skillName) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, `skill directory name "${sourceDirName}" must match declared skill name`, contribution.sourceKind));
+  }
+  const skillFilePath = join(contribution.sourceDir, "SKILL.md");
+  if (!await pathExists(skillFilePath)) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, "SKILL.md is required at skill root", contribution.sourceKind));
+    return { contribution, issues };
+  }
+  const skillContents = await promises.readFile(skillFilePath, "utf8");
+  if (!matter.test(skillContents)) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, "SKILL.md must include YAML frontmatter", contribution.sourceKind));
+    return { contribution, issues };
+  }
+  let frontmatter;
+  try {
+    const parsed = matter(skillContents).data;
+    frontmatter = {
+      name: typeof parsed.name === "string" ? parsed.name.trim() : void 0,
+      description: typeof parsed.description === "string" ? parsed.description.trim() : void 0
+    };
+  } catch {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, "SKILL.md must include YAML frontmatter", contribution.sourceKind));
+    return { contribution, issues };
+  }
+  if (!frontmatter.name) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, 'SKILL.md frontmatter must include non-empty "name"', contribution.sourceKind));
+  } else if (frontmatter.name !== contribution.skillName) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, `SKILL.md frontmatter name "${frontmatter.name}" must match declared skill name`, contribution.sourceKind));
+  }
+  if (!frontmatter.description) {
+    issues.push(createValidationIssue(contribution.packageName, contribution.skillName, 'SKILL.md frontmatter must include non-empty "description"', contribution.sourceKind));
+  }
+  return {
+    contribution: {
+      ...contribution,
+      description: frontmatter.description || contribution.description
+    },
+    issues
+  };
+}
+async function validateResolvedContributions(contributions) {
+  const valid = [];
+  const issues = [];
+  for (const contribution of contributions) {
+    const validation = await validateContribution(contribution);
+    if (!validation.issues.length) {
+      valid.push(validation.contribution);
+      continue;
+    }
+    issues.push(...validation.issues);
+  }
+  return {
+    contributions: sortAndDedupeContributions(valid),
+    issues
+  };
+}
+async function resolveContributions(discoveries) {
+  const contributions = [];
+  const issues = [];
+  for (const discovery of discoveries) {
+    issues.push(...discovery.issues);
+    for (const skill of discovery.skills) {
+      const sourceDir = resolve(discovery.packageRoot, skill.path);
+      contributions.push(normalizeContribution({
+        packageName: discovery.packageName,
+        version: discovery.version,
+        skillName: skill.name
+      }, sourceDir, discovery.packageRoot));
+    }
+  }
+  const validated = await validateResolvedContributions(contributions);
+  return {
+    contributions: validated.contributions,
+    issues: [...issues, ...validated.issues]
+  };
+}
+function sortAndDedupeContributions(contributions) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const contribution of contributions) {
+    const key = [
+      contribution.packageName,
+      contribution.skillName,
+      contribution.sourceDir
+    ].join("::");
+    byKey.set(key, contribution);
+  }
+  return Array.from(byKey.values()).sort((a, b) => {
+    const left = `${a.packageName}::${a.skillName}::${a.sourceDir}`;
+    const right = `${b.packageName}::${b.skillName}::${b.sourceDir}`;
+    return left.localeCompare(right);
+  });
+}
+function sanitizeSegment(value) {
+  return value.replace(/[^\w.-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+async function copySkillTree(sourceDir, destinationDir, includeScripts) {
+  await ensureDir(destinationDir);
+  await promises.cp(sourceDir, destinationDir, {
+    recursive: true,
+    force: true,
+    filter: (source) => {
+      const relativePath = relative(sourceDir, source);
+      if (!relativePath || relativePath === "") {
+        return true;
+      }
+      if (relativePath.split("/").includes("..")) {
+        return false;
+      }
+      if (!includeScripts && (relativePath === "scripts" || relativePath.startsWith("scripts/"))) {
+        return false;
+      }
+      return !lstatSync(source).isSymbolicLink();
+    }
+  });
+}
+function resolveTargets(explicitTargets, rootDir) {
+  if (explicitTargets.length) {
+    const { valid, invalid } = validateTargets(explicitTargets);
+    return {
+      targets: valid,
+      invalidTargets: invalid
+    };
+  }
+  return {
+    targets: detectInstalledTargets(),
+    invalidTargets: []
+  };
+}
+async function buildNuxtTemplateFiles(nuxtDir) {
+  const nuxtRuleFiles = await loadNuxtRuleFiles();
+  const nuxtIndexTemplate = await loadNuxtIndexTemplate();
+  const files = Object.entries(nuxtRuleFiles).map(([name, contents]) => ({
+    path: join(nuxtDir, name),
+    contents
+  }));
+  files.push({
+    path: join(nuxtDir, "index.template.md"),
+    contents: nuxtIndexTemplate
+  });
+  return files;
+}
+async function buildVueTemplateFiles(vueDir, cacheRoot) {
+  const vueFiles = await loadVueSkillFiles(cacheRoot);
+  return Object.entries(vueFiles).map(([name, contents]) => ({
+    path: join(vueDir, name),
+    contents
+  }));
+}
+async function renderAutomdTemplate(contents, dir) {
+  const result = await transform(contents, { dir });
+  return result.contents;
+}
+function createModuleDestination(baseModulesDir, contribution) {
+  return join(
+    baseModulesDir,
+    sanitizeSegment(contribution.packageName),
+    sanitizeSegment(contribution.skillName || basename(contribution.sourceDir))
+  );
+}
+function getTargetSkillRoot(rootDir, target, skillName) {
+  const targetConfig = resolveAgentTargetConfig(target);
+  if (!targetConfig) {
+    throw new Error(`Target "${target}" could not be resolved from unagent.`);
+  }
+  const home = homedir();
+  const relativeConfigDir = relative(home, targetConfig.configDir);
+  const canMirrorConfigDir = !relativeConfigDir.startsWith("..") && !relativeConfigDir.includes("/../") && !isAbsolute(relativeConfigDir);
+  if (canMirrorConfigDir) {
+    const targetDir = resolve(rootDir, relativeConfigDir, targetConfig.skillsDir);
+    const skillRoot = join(targetDir, skillName);
+    return { targetDir, skillRoot };
+  }
+  throw new Error(`Target "${target}" configDir "${targetConfig.configDir}" is not under home "${home}".`);
+}
+
+function isCancelled(value) {
+  return value === null || typeof value === "symbol";
+}
+async function runInstallWizard(nuxt) {
+  const logger = useLogger("nuxt-skill-hub");
+  if (process.env.CI || !process.stdout.isTTY) {
+    logger.info("Non-interactive environment detected, skipping install wizard.");
+    return;
+  }
+  const consola = createConsola();
+  const rootDir = nuxt.options.rootDir;
+  const exportRoot = await resolveExportRoot(rootDir);
+  const pkg = await readPackageJSON(rootDir).catch(() => null);
+  const projectName = (pkg?.name || "").replace(/^@[^/]+\//, "").replace(/[^\w-]+/g, "-").replace(/^-+|-+$/g, "");
+  let skillName = projectName ? `nuxt-${projectName}` : "nuxt";
+  if (!isValidSkillName(skillName)) skillName = "nuxt";
+  const pendingWrites = [];
+  consola.box(
+    `nuxt-skill-hub \u2014 First-time setup
+Let's configure AI agent skills for your Nuxt project.`
+  );
+  const currentTarget = detectCurrentTarget();
+  let selectedTargets;
+  if (currentTarget) {
+    consola.info(`Running inside ${currentTarget}, auto-selecting it.`);
+    selectedTargets = [currentTarget];
+  } else {
+    const detectedTargets = detectInstalledTargets();
+    const allTargets = getSupportedTargets();
+    if (!detectedTargets.length && !allTargets.length) {
+      consola.warn("No AI agents detected. Skills will be generated when an agent is detected.");
+      consola.info("Supported agents are sourced from unagent.");
+      return;
+    }
+    consola.info(`Detected agents: ${detectedTargets.length ? detectedTargets.join(", ") : "none"}`);
+    selectedTargets = detectedTargets;
+    if (detectedTargets.length > 1) {
+      const keepAll = await consola.prompt("Generate skills for all detected agents?", {
+        type: "confirm",
+        initial: true,
+        cancel: "null"
+      });
+      if (isCancelled(keepAll)) {
+        consola.info("Setup cancelled.");
+        return;
+      }
+      if (!keepAll) {
+        const chosen = await consola.prompt("Select agents to generate skills for:", {
+          type: "multiselect",
+          options: detectedTargets.map((t) => ({ label: t, value: t })),
+          initial: detectedTargets,
+          required: true,
+          cancel: "null"
+        });
+        if (isCancelled(chosen)) {
+          consola.info("Setup cancelled.");
+          return;
+        }
+        selectedTargets = chosen.map((c) => c.value);
+      }
+    }
+  }
+  const moduleSpecifiers = (nuxt.options.modules || []).map((entry) => extractModuleSpecifier(entry)).filter((entry) => Boolean(entry));
+  const uniqueSpecifiers = Array.from(new Set(moduleSpecifiers));
+  const installedModulePackages = [];
+  for (const specifier of uniqueSpecifiers) {
+    const pkg2 = await discoverInstalledPackageFromSpecifier(specifier, rootDir);
+    if (!pkg2 || pkg2.packageName === "nuxt-skill-hub")
+      continue;
+    installedModulePackages.push(pkg2.packageName);
+  }
+  if (installedModulePackages.length) {
+    consola.info(`Detected ${installedModulePackages.length} installed module package(s):`);
+    for (const packageName of installedModulePackages) {
+      consola.log(`  ${packageName}`);
+    }
+    consola.info("Module skills and metadata routers are resolved automatically at build time.");
+  } else {
+    consola.info("No installed module entries were discovered.");
+  }
+  const gitignorePath = join(exportRoot, ".gitignore");
+  const gitignoreExists = existsSync(gitignorePath);
+  const currentGitignore = gitignoreExists ? readFileSync(gitignorePath, "utf8") : "";
+  const missingPatterns = [];
+  for (const target of selectedTargets) {
+    const { targetDir } = getTargetSkillRoot(exportRoot, target, skillName);
+    const pattern = relative(exportRoot, targetDir).replace(/\/?$/, "/");
+    if (!currentGitignore.includes(pattern)) {
+      missingPatterns.push(pattern);
+    }
+  }
+  if (missingPatterns.length) {
+    const addGitignore = await consola.prompt(
+      `Add generated skill directories to .gitignore?
+${missingPatterns.map((p) => `  ${p}`).join("\n")}`,
+      { type: "confirm", initial: true, cancel: "null" }
+    );
+    if (isCancelled(addGitignore)) {
+      consola.info("Setup cancelled.");
+      return;
+    }
+    if (addGitignore) {
+      const block = `
+# nuxt-skill-hub (generated skills)
+${missingPatterns.join("\n")}
+`;
+      const newContent = currentGitignore.trimEnd() + "\n" + block;
+      pendingWrites.push({
+        file: ".gitignore",
+        absPath: gitignorePath,
+        description: `Add ${missingPatterns.length} skill directory pattern(s)`,
+        content: newContent,
+        action: gitignoreExists ? "modify" : "create"
+      });
+    }
+  }
+  const hintBlock = `${MANAGED_HINT_START}
+Use the \`${skillName}\` skill as the first entrypoint for Nuxt tasks in this repository.
+${MANAGED_HINT_END}`;
+  const hintFileChoice = await consola.prompt("Add a skill hint to help agents discover the skill?", {
+    type: "select",
+    options: [
+      { label: "CLAUDE.md", value: "claude", hint: "Claude Code project instructions" },
+      { label: "AGENTS.md", value: "agents", hint: "Universal agent instructions" },
+      { label: "Both", value: "both" },
+      { label: "Skip", value: "skip" }
+    ],
+    cancel: "null"
+  });
+  if (isCancelled(hintFileChoice)) {
+    consola.info("Setup cancelled.");
+    return;
+  }
+  const addToFile = async (filename) => {
+    const filePath = join(exportRoot, filename);
+    const exists = await pathExists(filePath);
+    const current = exists ? readFileSync(filePath, "utf8") : "";
+    const regex = new RegExp(`${MANAGED_HINT_START}[\\s\\S]*?${MANAGED_HINT_END}`);
+    let newContent;
+    if (regex.test(current)) {
+      newContent = current.replace(regex, hintBlock);
+    } else if (current) {
+      newContent = `${current.trimEnd()}
+
+${hintBlock}
+`;
+    } else {
+      newContent = `${hintBlock}
+`;
+    }
+    pendingWrites.push({
+      file: filename,
+      absPath: filePath,
+      description: "Add skill hint block",
+      content: newContent,
+      action: exists ? "modify" : "create"
+    });
+  };
+  if (hintFileChoice === "claude" || hintFileChoice === "both") {
+    await addToFile("CLAUDE.md");
+  }
+  if (hintFileChoice === "agents" || hintFileChoice === "both") {
+    await addToFile("AGENTS.md");
+  }
+  if (!pendingWrites.length) {
+    consola.success("No file changes needed. Setup complete!");
+    consola.info("Run `nuxt dev` or `nuxt prepare` to generate skills.");
+    return;
+  }
+  consola.log("");
+  consola.info("Planned changes:");
+  for (const write of pendingWrites) {
+    const icon = write.action === "create" ? "+" : "~";
+    consola.log(`  ${icon} ${write.file} \u2014 ${write.description}`);
+  }
+  consola.log("");
+  const confirm = await consola.prompt("Apply these changes?", {
+    type: "confirm",
+    initial: true,
+    cancel: "null"
+  });
+  if (isCancelled(confirm) || !confirm) {
+    consola.info("Setup cancelled. No files were modified.");
+    return;
+  }
+  for (const write of pendingWrites) {
+    writeFileSync(write.absPath, write.content, "utf8");
+    const verb = write.action === "create" ? "Created" : "Updated";
+    consola.success(`${verb} ${write.file}`);
+  }
+  consola.log("");
+  consola.box(
+    `Setup complete!
+
+Run \`nuxt dev\` or \`nuxt prepare\` to generate skills.
+Configure \`skillHub.skillName\` or \`skillHub.targets\` in nuxt.config.ts if needed.`
+  );
+}
+
+const GITHUB_OVERRIDES = [
+  {
+    packageName: "@nuxt/ui",
+    repo: "nuxt/ui",
+    ref: "v4",
+    path: "skills/nuxt-ui",
+    skillName: "nuxt-ui"
+  },
+  {
+    packageName: "@vueuse/core",
+    repo: "vueuse/vueuse",
+    ref: "main",
+    path: "skills/vueuse-functions",
+    skillName: "vueuse-functions"
+  }
+];
+function findGitHubOverride(packageName) {
+  return GITHUB_OVERRIDES.find((entry) => entry.packageName === packageName);
+}
+
+const GITHUB_API_BASE = "https://api.github.com";
+const UNGH_API_BASE = "https://ungh.cc";
+function githubFetchOptions(timeoutMs) {
+  return {
+    timeout: timeoutMs,
+    headers: {
+      "Accept": "application/json",
+      "User-Agent": "nuxt-skill-hub"
+    }
+  };
+}
+function encodeGitHubPath(path) {
+  return path.split("/").filter(Boolean).map((segment) => encodeURIComponent(segment)).join("/");
+}
+function toRepoPath(value) {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  const direct = trimmed.replace(/^git\+/, "").replace(/^https?:\/\/github\.com\//, "").replace(/^git:\/\/github\.com\//, "").replace(/^git@github\.com:/, "").replace(/\/+$/, "").replace(/\.git$/, "");
+  if (/^[\w.-]+\/[\w.-]+$/.test(direct)) {
+    return direct;
+  }
+  try {
+    const url = new URL(trimmed.replace(/^git\+/, ""));
+    if (url.hostname !== "github.com") {
+      return null;
+    }
+    const pathname = url.pathname.replace(/^\/+|\/+$/g, "").replace(/\.git$/, "");
+    if (/^[\w.-]+\/[\w.-]+$/.test(pathname)) {
+      return pathname;
+    }
+  } catch {
+  }
+  return null;
+}
+function parseGitHubRepo(input) {
+  if (!input) {
+    return null;
+  }
+  return toRepoPath(input);
+}
+async function listGitHubDirectory(repo, ref, dirPath, timeoutMs) {
+  const repoPath = toRepoPath(repo);
+  if (!repoPath) {
+    return [];
+  }
+  const normalizedDirPath = dirPath.replace(/^\/+|\/+$/g, "");
+  const prefix = normalizedDirPath ? `${normalizedDirPath}/` : "";
+  try {
+    const data = await ofetch(
+      `${GITHUB_API_BASE}/repos/${repoPath}/git/trees/${encodeURIComponent(ref)}?recursive=1`,
+      githubFetchOptions(timeoutMs)
+    );
+    const entries = /* @__PURE__ */ new Set();
+    for (const entry of data.tree || []) {
+      if (entry.type !== "tree" || !entry.path.startsWith(prefix)) {
+        continue;
+      }
+      const remainder = entry.path.slice(prefix.length);
+      if (remainder && !remainder.includes("/")) {
+        entries.add(remainder);
+      }
+    }
+    return Array.from(entries).sort((a, b) => a.localeCompare(b));
+  } catch {
+    return [];
+  }
+}
+async function fetchGitHubDefaultBranch(repo, timeoutMs) {
+  const repoPath = toRepoPath(repo);
+  if (!repoPath) {
+    return null;
+  }
+  const [owner, name] = repoPath.split("/");
+  if (!owner || !name) {
+    return null;
+  }
+  try {
+    const data = await ofetch(
+      `${UNGH_API_BASE}/repos/${encodeURIComponent(owner)}/${encodeURIComponent(name)}`,
+      githubFetchOptions(timeoutMs)
+    );
+    return data.repo?.defaultBranch || null;
+  } catch {
+    return null;
+  }
+}
+async function fetchGitHubFileText(repo, ref, filePath, timeoutMs) {
+  const repoPath = toRepoPath(repo);
+  if (!repoPath) {
+    return { ok: false, error: "Invalid GitHub repository format" };
+  }
+  try {
+    const data = await ofetch(
+      `https://raw.githubusercontent.com/${repoPath}/${encodeURIComponent(ref)}/${encodeGitHubPath(filePath)}`,
+      {
+        ...githubFetchOptions(timeoutMs),
+        responseType: "text"
+      }
+    );
+    return { ok: true, data };
+  } catch (error) {
+    const status = typeof error === "object" && error && "status" in error ? Number(error.status) : void 0;
+    return {
+      ok: false,
+      status,
+      error: error.message
+    };
+  }
+}
+
+function makeSkip(packageName, skillName, reason, sourceKind) {
+  return {
+    packageName,
+    skillName,
+    reason,
+    sourceKind
+  };
+}
+function slugCandidates(packageName) {
+  const [scopeOrName, scopedName] = packageName.startsWith("@") ? packageName.split("/") : ["", packageName];
+  const base = (scopedName || scopeOrName || "").trim();
+  const candidates = /* @__PURE__ */ new Set();
+  if (base) {
+    candidates.add(base);
+  }
+  if (scopeOrName === "@nuxt" && base) {
+    candidates.add(`nuxt-${base}`);
+  }
+  if (scopeOrName === "@nuxthub" && base === "core") {
+    candidates.add("nuxthub");
+  }
+  if (scopeOrName === "@vueuse" && base === "core") {
+    candidates.add("vueuse");
+  }
+  return Array.from(candidates);
+}
+function dedupe(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const output = [];
+  for (const value of values) {
+    if (!value || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    output.push(value);
+  }
+  return output;
+}
+function normalizeHttpUrl(url) {
+  const trimmed = url?.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.toString() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function resolveRepositoryUrl(packageInfo) {
+  const sourceRepo = parseGitHubRepo(packageInfo.repository) || parseGitHubRepo(packageInfo.homepage);
+  if (sourceRepo) {
+    return {
+      sourceRepo,
+      repoUrl: `https://github.com/${sourceRepo}`
+    };
+  }
+  return {
+    repoUrl: normalizeHttpUrl(packageInfo.repository)
+  };
+}
+async function materializeCandidate(packageInfo, candidate, cacheRoot) {
+  const targetDir = join(
+    cacheRoot,
+    candidate.sourceKind,
+    sanitizeSegment(candidate.sourceRepo),
+    sanitizeSegment(candidate.sourceRef),
+    sanitizeSegment(packageInfo.packageName),
+    sanitizeSegment(candidate.skillName)
+  );
+  try {
+    await downloadTemplate(`gh:${candidate.sourceRepo}/${candidate.sourcePath}#${candidate.sourceRef}`, {
+      dir: targetDir,
+      force: true,
+      forceClean: true,
+      registry: false,
+      silent: true
+    });
+  } catch {
+    return null;
+  }
+  if (!await pathExists(join(targetDir, "SKILL.md"))) {
+    return null;
+  }
+  return normalizeContribution({
+    packageName: packageInfo.packageName,
+    version: packageInfo.version,
+    skillName: candidate.skillName,
+    sourceKind: candidate.sourceKind,
+    sourceRepo: candidate.sourceRepo,
+    sourceRef: candidate.sourceRef,
+    sourcePath: candidate.sourcePath,
+    official: candidate.official,
+    resolver: candidate.resolver,
+    forceIncludeScripts: true
+  }, targetDir, join(targetDir, ".."));
+}
+async function resolveViaGitHub(packageInfo, cacheRoot, timeoutMs) {
+  const issues = [];
+  const skipped = [];
+  const override = findGitHubOverride(packageInfo.packageName);
+  const repo = override?.repo || parseGitHubRepo(packageInfo.repository) || parseGitHubRepo(packageInfo.homepage);
+  if (!repo) {
+    return {
+      contributions: [],
+      issues,
+      skipped: [makeSkip(packageInfo.packageName, override?.skillName || packageInfo.packageName, "No GitHub repository metadata found", "github")]
+    };
+  }
+  const refs = dedupe([
+    override?.ref || "",
+    packageInfo.version ? `v${packageInfo.version}` : "",
+    packageInfo.version || "",
+    await fetchGitHubDefaultBranch(repo, timeoutMs) || "",
+    "main",
+    "master"
+  ]);
+  const candidates = dedupe([
+    override?.skillName || "",
+    ...slugCandidates(packageInfo.packageName)
+  ]);
+  const pathCandidates = dedupe([
+    override?.path || "",
+    ...candidates.flatMap((skillName) => {
+      return [
+        `skills/${skillName}`,
+        `.claude/skills/${skillName}`,
+        `.github/skills/${skillName}`
+      ];
+    })
+  ]);
+  for (const ref of refs) {
+    const packageJson = await fetchGitHubFileText(repo, ref, "package.json", timeoutMs);
+    if (packageJson.ok && packageJson.data) {
+      try {
+        const parsed = JSON.parse(packageJson.data);
+        const remoteSkills = parseAgentSkillDeclarations(parsed, packageInfo.packageName, "github");
+        issues.push(...remoteSkills.issues);
+        for (const skill of remoteSkills.skills) {
+          const resolved = await materializeCandidate(packageInfo, {
+            skillName: skill.name,
+            sourcePath: skill.path,
+            sourceKind: "github",
+            sourceRepo: repo,
+            sourceRef: ref,
+            official: true,
+            resolver: "agentsField"
+          }, cacheRoot);
+          if (resolved) {
+            return { contributions: [resolved], issues, skipped };
+          }
+        }
+      } catch {
+        issues.push(createValidationIssue(packageInfo.packageName, packageInfo.packageName, "Failed to parse remote package.json", "github"));
+      }
+    }
+    const skillsDirs = await listGitHubDirectory(repo, ref, "skills", timeoutMs);
+    if (skillsDirs.length) {
+      const contributions = [];
+      for (const skillName of skillsDirs) {
+        const resolved = await materializeCandidate(packageInfo, {
+          skillName,
+          sourcePath: `skills/${skillName}`,
+          sourceKind: "github",
+          sourceRepo: repo,
+          sourceRef: ref,
+          official: true,
+          resolver: "githubHeuristic"
+        }, cacheRoot);
+        if (resolved) {
+          contributions.push(resolved);
+        }
+      }
+      if (contributions.length) {
+        return { contributions, issues, skipped };
+      }
+    }
+    for (const path of pathCandidates) {
+      const candidateSkillName = override?.path && path === override.path ? override.skillName || path.split("/").pop() || packageInfo.packageName : path.split("/").pop() || packageInfo.packageName;
+      const resolved = await materializeCandidate(packageInfo, {
+        skillName: candidateSkillName,
+        sourcePath: path,
+        sourceKind: "github",
+        sourceRepo: repo,
+        sourceRef: ref,
+        official: true,
+        resolver: "githubHeuristic"
+      }, cacheRoot);
+      if (resolved) {
+        return { contributions: [resolved], issues, skipped };
+      }
+    }
+  }
+  skipped.push(makeSkip(packageInfo.packageName, override?.skillName || packageInfo.packageName, "No GitHub skill found using configured refs and path heuristics", "github"));
+  return {
+    contributions: [],
+    issues,
+    skipped
+  };
+}
+async function resolveViaMetadataRouter(packageInfo, cacheRoot) {
+  const { repoUrl, sourceRepo } = resolveRepositoryUrl(packageInfo);
+  const docsUrl = normalizeHttpUrl(packageInfo.homepage);
+  if (!repoUrl && !docsUrl) {
+    return {
+      contributions: [],
+      issues: [],
+      skipped: [makeSkip(packageInfo.packageName, packageInfo.packageName, "No package metadata was available to generate a metadata-routed skill", "generated")]
+    };
+  }
+  const skillName = resolveMetadataRouterSkillName(packageInfo.packageName);
+  const targetDir = join(
+    cacheRoot,
+    "generated",
+    "metadata-router",
+    sanitizeSegment(packageInfo.packageName),
+    sanitizeSegment(skillName)
+  );
+  const files = createMetadataRouterSkillFiles({
+    packageName: packageInfo.packageName,
+    skillName,
+    description: packageInfo.description,
+    repoUrl,
+    docsUrl
+  });
+  for (const [relativePath, contents] of Object.entries(files)) {
+    const destination = join(targetDir, relativePath);
+    await ensureDir(dirname(destination));
+    await promises.writeFile(destination, contents, "utf8");
+  }
+  return {
+    contributions: [
+      normalizeContribution({
+        packageName: packageInfo.packageName,
+        version: packageInfo.version,
+        skillName,
+        description: packageInfo.description,
+        sourceKind: "generated",
+        sourceRepo,
+        repoUrl,
+        docsUrl,
+        official: true,
+        resolver: "metadataRouter",
+        forceIncludeScripts: false
+      }, targetDir, join(targetDir, ".."))
+    ],
+    issues: [],
+    skipped: []
+  };
+}
+async function resolveRemoteContributionsForPackage(packageInfo, options) {
+  const githubResult = options.enableGithubLookup ? await resolveViaGitHub(packageInfo, options.cacheRoot, options.githubLookupTimeoutMs) : {
+    contributions: [],
+    issues: [],
+    skipped: []
+  };
+  if (githubResult.contributions.length) {
+    return githubResult;
+  }
+  const generatedResult = await resolveViaMetadataRouter(packageInfo, options.cacheRoot);
+  if (generatedResult.contributions.length) {
+    return {
+      contributions: generatedResult.contributions,
+      issues: [...githubResult.issues, ...generatedResult.issues],
+      skipped: generatedResult.skipped
+    };
+  }
+  return {
+    contributions: [],
+    issues: [...githubResult.issues, ...generatedResult.issues],
+    skipped: [...githubResult.skipped, ...generatedResult.skipped]
+  };
+}
+
+const GITHUB_LOOKUP_TIMEOUT_MS = 1500;
+async function resolveManualContribution(rootDir, contribution) {
+  const sourceDir = isAbsolute(contribution.sourceDir) ? contribution.sourceDir : resolve(rootDir, contribution.sourceDir);
+  return normalizeContribution(contribution, sourceDir, sourceDir);
+}
+function issuesToSkipped(issues) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const key = `${issue.packageName}::${issue.skillName}`;
+    const previous = byKey.get(key);
+    if (!previous) {
+      byKey.set(key, {
+        packageName: issue.packageName,
+        skillName: issue.skillName,
+        reason: issue.reason,
+        sourceKind: issue.sourceKind
+      });
+      continue;
+    }
+    const reasons = new Set(previous.reason.split("; ").filter(Boolean));
+    reasons.add(issue.reason);
+    previous.reason = Array.from(reasons).join("; ");
+  }
+  return Array.from(byKey.values()).sort((a, b) => `${a.packageName}::${a.skillName}`.localeCompare(`${b.packageName}::${b.skillName}`));
+}
+function mergeSkippedEntries(entries) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = `${entry.packageName}::${entry.skillName}::${entry.sourceKind || ""}`;
+    const previous = byKey.get(key);
+    if (!previous) {
+      byKey.set(key, { ...entry });
+      continue;
+    }
+    const reasons = new Set(previous.reason.split("; ").filter(Boolean));
+    reasons.add(entry.reason);
+    previous.reason = Array.from(reasons).join("; ");
+  }
+  return Array.from(byKey.values()).sort((a, b) => `${a.packageName}::${a.skillName}`.localeCompare(`${b.packageName}::${b.skillName}`));
+}
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "nuxt-skill-hub",
+    version: PACKAGE_VERSION,
+    configKey: "skillHub",
+    compatibility: {
+      nuxt: ">=4.3.0"
+    }
+  },
+  async onInstall(nuxt) {
+    await runInstallWizard(nuxt);
+  },
+  defaults: {
+    skillName: "",
+    targets: [],
+    moduleAuthoring: false
+  },
+  async setup(options, nuxt) {
+    const logger = useLogger("nuxt-skill-hub");
+    const configuredSkillName = options.skillName?.trim();
+    let resolvedSkillName;
+    if (configuredSkillName && isValidSkillName(configuredSkillName)) {
+      resolvedSkillName = configuredSkillName;
+    } else {
+      if (configuredSkillName) {
+        logger.warn(`Invalid skillHub.skillName "${configuredSkillName}". Deriving from package.json.`);
+      }
+      const pkg = await readPackageJSON(nuxt.options.rootDir).catch(() => null);
+      const projectName = (pkg?.name || "").replace(/^@[^/]+\//, "").replace(/[^\w-]+/g, "-").replace(/^-+|-+$/g, "");
+      resolvedSkillName = projectName ? `nuxt-${projectName}` : "nuxt";
+      if (!isValidSkillName(resolvedSkillName)) {
+        resolvedSkillName = "nuxt";
+      }
+    }
+    nuxt.hook("modules:done", async () => {
+      const exportRoot = await resolveExportRoot(nuxt.options.rootDir);
+      const monorepoScopePath = resolveMonorepoScopePath(nuxt.options.rootDir, exportRoot);
+      const manualContributions = [];
+      const contributionContext = {
+        add: (contribution) => {
+          manualContributions.push(contribution);
+        }
+      };
+      const callSkillContributeHook = nuxt.callHook;
+      await callSkillContributeHook("skill-hub:contribute", contributionContext);
+      const discoveries = [];
+      const installedPackages = [];
+      const seenPackageRoots = /* @__PURE__ */ new Set();
+      const addInstalledPackage = (installedPackage) => {
+        if (!installedPackage || seenPackageRoots.has(installedPackage.packageRoot)) {
+          return;
+        }
+        seenPackageRoots.add(installedPackage.packageRoot);
+        installedPackages.push(installedPackage);
+        const discovered = discoverPackageSkillsFromInstalledPackage(installedPackage, "dist");
+        if (discovered) {
+          discoveries.push(discovered);
+        }
+      };
+      const moduleSpecifiers = (nuxt.options.modules || []).map((entry) => extractModuleSpecifier(entry)).filter((entry) => Boolean(entry));
+      const seenSpecifiers = Array.from(new Set(moduleSpecifiers));
+      for (const specifier of seenSpecifiers) {
+        addInstalledPackage(await discoverInstalledPackageFromSpecifier(specifier, nuxt.options.rootDir));
+      }
+      const layerDirectories = Array.from(new Set(
+        nuxt.options._layers.map((layer) => resolve(layer.cwd || layer.config.rootDir || "")).filter((layerDir) => layerDir && layerDir !== resolve(nuxt.options.rootDir))
+      ));
+      for (const layerDirectory of layerDirectories) {
+        addInstalledPackage(await discoverInstalledPackageFromDirectory(layerDirectory));
+      }
+      const localPackageSkills = await discoverLocalPackageSkills(nuxt.options.rootDir);
+      if (localPackageSkills) {
+        discoveries.push(localPackageSkills);
+      }
+      const discoveredContributions = await resolveContributions(discoveries);
+      const distResolvedPackages = new Set(discoveredContributions.contributions.map((item) => item.packageName));
+      const remoteIssues = [];
+      const remoteSkipped = [];
+      const remoteContributions = [];
+      const remoteCacheRoot = join(nuxt.options.rootDir, ".nuxt", "skill-hub-cache");
+      await emptyDir(remoteCacheRoot);
+      for (const pkg of installedPackages) {
+        if (pkg.packageName === "nuxt-skill-hub") {
+          continue;
+        }
+        if (distResolvedPackages.has(pkg.packageName)) {
+          continue;
+        }
+        const remote = await resolveRemoteContributionsForPackage(pkg, {
+          cacheRoot: remoteCacheRoot,
+          githubLookupTimeoutMs: GITHUB_LOOKUP_TIMEOUT_MS,
+          enableGithubLookup: true
+        });
+        remoteIssues.push(...remote.issues);
+        remoteSkipped.push(...remote.skipped);
+        remoteContributions.push(...remote.contributions);
+      }
+      const validatedRemote = await validateResolvedContributions(sortAndDedupeContributions(remoteContributions));
+      const resolvedManual = await Promise.all(
+        manualContributions.map((contribution) => resolveManualContribution(nuxt.options.rootDir, contribution))
+      );
+      const validatedManual = await validateResolvedContributions(sortAndDedupeContributions(resolvedManual));
+      const contributions = sortAndDedupeContributions([
+        ...discoveredContributions.contributions,
+        ...validatedRemote.contributions,
+        ...validatedManual.contributions
+      ]);
+      const validationIssues = [
+        ...discoveredContributions.issues,
+        ...remoteIssues,
+        ...validatedRemote.issues,
+        ...validatedManual.issues
+      ];
+      const skipped = mergeSkippedEntries([
+        ...issuesToSkipped(validationIssues),
+        ...remoteSkipped
+      ]);
+      for (const issue of validationIssues) {
+        logger.warn(`[validation] ${issue.packageName}/${issue.skillName}: ${issue.reason}`);
+      }
+      const targetResolution = resolveTargets(
+        options.targets || [],
+        nuxt.options.rootDir
+      );
+      const targets = targetResolution.targets;
+      for (const invalidTarget of targetResolution.invalidTargets) {
+        if (invalidTarget.reason === "unknown-target") {
+          logger.warn(`Target "${invalidTarget.target}" is unknown in unagent and was skipped.`);
+          continue;
+        }
+        logger.warn(`Target "${invalidTarget.target}" has no skillsDir in unagent and was skipped.`);
+      }
+      if (!targets.length) {
+        logger.warn("No detected targets. Set skillHub.targets to force generation for specific agents.");
+        return;
+      }
+      const nuxtMetadata = await loadNuxtMetadata();
+      for (const target of targets) {
+        const { skillRoot } = getTargetSkillRoot(exportRoot, target, resolvedSkillName);
+        const referencesRoot = join(skillRoot, "references");
+        const nuxtRoot = join(referencesRoot, "nuxt");
+        const vueRoot = join(referencesRoot, "vue");
+        const modulesRoot = join(referencesRoot, "modules");
+        await emptyDir(skillRoot);
+        await ensureDir(nuxtRoot);
+        await ensureDir(vueRoot);
+        await ensureDir(modulesRoot);
+        const nuxtTemplateFiles = await buildNuxtTemplateFiles(nuxtRoot);
+        for (const file of nuxtTemplateFiles) {
+          await writeFileIfChanged(file.path, file.contents);
+        }
+        const nuxtIndexTemplatePath = join(nuxtRoot, "index.template.md");
+        const nuxtIndexTemplate = await pathExists(nuxtIndexTemplatePath) ? await promises.readFile(nuxtIndexTemplatePath, "utf8") : "";
+        const nuxtIndexContent = await renderAutomdTemplate(nuxtIndexTemplate, nuxtRoot);
+        await writeFileIfChanged(join(nuxtRoot, "index.md"), nuxtIndexContent);
+        const vueTemplateFiles = await buildVueTemplateFiles(vueRoot, remoteCacheRoot);
+        for (const file of vueTemplateFiles) {
+          await writeFileIfChanged(file.path, file.contents);
+        }
+        const generatedEntries = [];
+        for (const contribution of contributions) {
+          const includeScripts = contribution.forceIncludeScripts;
+          const destination = createModuleDestination(modulesRoot, contribution);
+          await copySkillTree(contribution.sourceDir, destination, includeScripts);
+          const entryPath = relative(skillRoot, join(destination, "SKILL.md"));
+          generatedEntries.push({
+            packageName: contribution.packageName,
+            version: contribution.version,
+            skillName: contribution.skillName,
+            entryPath,
+            sourceDir: contribution.sourceDir,
+            destination: relative(skillRoot, destination),
+            scriptsIncluded: includeScripts,
+            description: contribution.description,
+            sourceKind: contribution.sourceKind,
+            sourceLabel: getSourceLabel(contribution.sourceKind),
+            sourceRepo: contribution.sourceRepo,
+            sourceRef: contribution.sourceRef,
+            sourcePath: contribution.sourcePath,
+            repoUrl: contribution.repoUrl,
+            docsUrl: contribution.docsUrl,
+            official: contribution.official,
+            trustLevel: getTrustLevel(contribution.official),
+            resolver: contribution.resolver
+          });
+        }
+        await writeFileIfChanged(join(skillRoot, "SKILL.md"), createSkillEntrypoint(
+          resolvedSkillName,
+          nuxtMetadata,
+          monorepoScopePath,
+          Boolean(options.moduleAuthoring),
+          generatedEntries,
+          skipped
+        ));
+        logger.success(`Generated ${resolvedSkillName} skill at ${skillRoot}`);
+      }
+    });
+  }
+});
+
+export { module$1 as default };