@vibe-forge/workspace-assets 3.2.2-alpha.2 → 3.3.0-rc.0

package/__tests__/bundle.spec.ts

@@ -7,7 +7,8 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 const skillsCliMocks = vi.hoisted(() => ({
   findSkillsCli: vi.fn(),
   installSkillsCliRefToTemp: vi.fn(),
-  installSkillsCliSkillToTemp: vi.fn()
+  installSkillsCliSkillToTemp: vi.fn(),
+  installSkillsCliSourceToTemp: vi.fn()
 }))
 
 vi.mock('@vibe-forge/utils/skills-cli', async () => {
@@ -16,11 +17,12 @@ vi.mock('@vibe-forge/utils/skills-cli', async () => {
     ...actual,
     findSkillsCli: skillsCliMocks.findSkillsCli,
     installSkillsCliRefToTemp: skillsCliMocks.installSkillsCliRefToTemp,
-    installSkillsCliSkillToTemp: skillsCliMocks.installSkillsCliSkillToTemp
+    installSkillsCliSkillToTemp: skillsCliMocks.installSkillsCliSkillToTemp,
+    installSkillsCliSourceToTemp: skillsCliMocks.installSkillsCliSourceToTemp
   }
 })
 
-import { buildAdapterAssetPlan, resolveWorkspaceAssetBundle } from '#~/index.js'
+import { resolveWorkspaceAssetBundle } from '#~/index.js'
 
 import { createWorkspace, installPluginPackage, writeDocument } from './test-helpers'
 
@@ -91,6 +93,47 @@ describe('resolveWorkspaceAssetBundle', () => {
     ]))
   })
 
+  it('skips invalid plugin MCP files and keeps resolving other plugin assets', async () => {
+    const workspace = await createWorkspace()
+    const invalidMcpPath = join(
+      workspace,
+      'node_modules/@vibe-forge/plugin-demo/mcp/broken.yaml'
+    )
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    try {
+      await installPluginPackage(workspace, '@vibe-forge/plugin-demo', {
+        'package.json': JSON.stringify(
+          {
+            name: '@vibe-forge/plugin-demo',
+            version: '1.0.0'
+          },
+          null,
+          2
+        ),
+        'mcp/browser.json': JSON.stringify({ command: 'npx', args: ['browser-server'] }, null, 2),
+        'mcp/broken.yaml': 'command: npx\nargs: [broken\n'
+      })
+
+      const bundle = await resolveWorkspaceAssetBundle({
+        cwd: workspace,
+        configs: [{
+          plugins: [
+            { id: 'demo', scope: 'demo' }
+          ]
+        }, undefined],
+        useDefaultVibeForgeMcpServer: false
+      })
+
+      expect(Object.keys(bundle.mcpServers)).toEqual(['demo/browser'])
+      expect(warnSpy.mock.calls.map(([message]) => String(message))).toEqual(expect.arrayContaining([
+        expect.stringContaining(`Ignoring invalid mcpServer asset "${invalidMcpPath}"`)
+      ]))
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
   it('loads workspace assets from the env-configured ai base dir', async () => {
     const workspace = await createWorkspace()
     const previousBaseDir = process.env.__VF_PROJECT_AI_BASE_DIR__
@@ -185,6 +228,40 @@ describe('resolveWorkspaceAssetBundle', () => {
     }))
   })
 
+  it('skips invalid home-bridged skill frontmatter and keeps resolving other skills', async () => {
+    const workspace = await createWorkspace()
+    const realHome = process.env.__VF_PROJECT_REAL_HOME__
+    const invalidSkillPath = join(realHome!, '.agents/skills/broken/SKILL.md')
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    try {
+      await writeDocument(
+        invalidSkillPath,
+        '---\ndescription: Use minimal writing principles: understand the reader\n---\nBroken skill body'
+      )
+      await writeDocument(
+        join(realHome!, '.agents/skills/research/SKILL.md'),
+        '---\ndescription: Valid skill\n---\nValid skill body'
+      )
+
+      const bundle = await resolveWorkspaceAssetBundle({
+        cwd: workspace,
+        configs: [undefined, undefined],
+        useDefaultVibeForgeMcpServer: false
+      })
+
+      expect(bundle.skills.map(asset => asset.displayName)).toEqual(['research'])
+      expect(warnSpy.mock.calls.map(([message]) => String(message))).toEqual(expect.arrayContaining([
+        expect.stringContaining(`Ignoring invalid skill asset "${invalidSkillPath}"`)
+      ]))
+      expect(warnSpy.mock.calls.map(([message]) => String(message))).toEqual(expect.arrayContaining([
+        expect.stringContaining('quote plain strings containing ": "')
+      ]))
+    } finally {
+      warnSpy.mockRestore()
+    }
+  })
+
   it('can disable the home skill bridge entirely', async () => {
     const workspace = await createWorkspace()
     const realHome = process.env.__VF_PROJECT_REAL_HOME__
@@ -410,6 +487,72 @@ describe('resolveWorkspaceAssetBundle', () => {
     expect(warn).toHaveBeenCalledWith(expect.stringContaining('Declared skills are not installed: internal-review'))
   })
 
+  it('warns when a configured skill source collection is missing', async () => {
+    const workspace = await createWorkspace()
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [{
+        skills: [
+          {
+            include: ['*'],
+            source: 'example-source/default/public'
+          }
+        ]
+      }, undefined],
+      warnMissingConfiguredSkills: true,
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(bundle.skills.map(asset => asset.name)).toEqual([])
+    expect(skillsCliMocks.installSkillsCliSourceToTemp).not.toHaveBeenCalled()
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining('Declared skill sources are not installed: example-source/default/public')
+    )
+  })
+
+  it('does not warn for installed configured skill source collections', async () => {
+    const workspace = await createWorkspace()
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+
+    await writeDocument(
+      join(workspace, '.ai/skills/source-review/SKILL.md'),
+      '---\nname: source-review\ndescription: Existing skill\n---\nExisting content.\n'
+    )
+    await writeDocument(
+      join(workspace, '.ai/skills.lock.yaml'),
+      [
+        'version: 1',
+        'skills:',
+        '  source-review:',
+        '    name: source-review',
+        '    requested: true',
+        '    installPath: .ai/skills/source-review',
+        '    source: example-source/default/public',
+        '    hash: sha256:test',
+        '    installedAt: "2026-05-14T00:00:00.000Z"'
+      ].join('\n')
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [{
+        skills: [
+          {
+            include: ['*'],
+            source: 'example-source/default/public'
+          }
+        ]
+      }, undefined],
+      warnMissingConfiguredSkills: true,
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(bundle.skills.map(asset => asset.name)).toContain('source-review')
+    expect(warn).not.toHaveBeenCalled()
+  })
+
   it('loads installed configured skills without attempting runtime updates', async () => {
     const workspace = await createWorkspace()
     await writeDocument(

package/__tests__/prompt-selection.spec.ts

@@ -2,11 +2,53 @@ import { join } from 'node:path'
 
 import { describe, expect, it } from 'vitest'
 
+import { writeProjectSkillsLockfile } from '@vibe-forge/utils'
+
 import { resolvePromptAssetSelection, resolveWorkspaceAssetBundle } from '#~/index.js'
 
 import { createWorkspace, installPluginPackage, writeDocument } from './test-helpers'
 
 describe('resolvePromptAssetSelection', () => {
+  it('loads nested project skills through the project skills lockfile', async () => {
+    const workspace = await createWorkspace()
+    const skillPath = join(workspace, '.ai/skills/.extends/base-skills/larksuite-cli/lark-doc/SKILL.md')
+    await writeDocument(
+      skillPath,
+      [
+        '---',
+        'name: lark-doc',
+        'description: Lark docs',
+        '---',
+        'Read docs.'
+      ].join('\n')
+    )
+    await writeProjectSkillsLockfile(workspace, {
+      version: 1,
+      skills: {
+        'lark-doc': {
+          hash: 'sha256:test',
+          installedAt: '2026-01-01T00:00:00.000Z',
+          installPath: '.ai/skills/.extends/base-skills/larksuite-cli/lark-doc',
+          name: 'lark-doc',
+          requested: true,
+          source: 'larksuite/cli'
+        }
+      }
+    })
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(bundle.skills).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        name: 'lark-doc',
+        sourcePath: skillPath
+      })
+    ]))
+  })
+
   it('embeds only alwaysApply rules and keeps optional rules as summaries', async () => {
     const workspace = await createWorkspace()
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/workspace-assets",
-  "version": "3.2.2-alpha.2",
+  "version": "3.3.0-rc.0",
   "description": "Workspace asset resolution and adapter asset planning for Vibe Forge",
   "imports": {
     "#~/*.js": {
@@ -29,10 +29,10 @@
     "fast-glob": "^3.3.3",
     "front-matter": "^4.0.2",
     "js-yaml": "^4.1.1",
-    "@vibe-forge/config": "3.2.3-alpha.2",
-    "@vibe-forge/definition-core": "3.2.0",
-    "@vibe-forge/types": "3.2.3-alpha.1",
-    "@vibe-forge/utils": "3.2.3-alpha.2"
+    "@vibe-forge/config": "3.3.0-rc.0",
+    "@vibe-forge/utils": "3.3.0-rc.0",
+    "@vibe-forge/types": "3.3.0-rc.0",
+    "@vibe-forge/definition-core": "3.3.0-rc.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9"

package/src/bundle-internal.ts

@@ -159,6 +159,20 @@ const warnInvalidHomeSkillRoot = (root: string) => {
   )
 }
 
+const formatErrorMessage = (error: unknown) => (
+  (error instanceof Error ? error.message : String(error))
+    .split(/\r?\n/u)[0]
+    ?.trim() ?? 'Unknown error'
+)
+
+const warnInvalidWorkspaceAsset = (kind: WorkspaceAssetKind, path: string, error: unknown) => {
+  console.warn(
+    `[vibe-forge] Ignoring invalid ${kind} asset "${path}". ` +
+      `${formatErrorMessage(error)}. ` +
+      'Check the asset frontmatter or structured config syntax; quote plain strings containing ": ".'
+  )
+}
+
 const resolveHomeBridgeConfig = (configs: [Config?, Config?]) => {
   const [config, userConfig] = configs
   const projectHomeBridge = resolveSkillsHomeBridge(config)
@@ -221,6 +235,19 @@ const parseFrontmatterDocument = async <TDefinition extends object>(
   }
 }
 
+const parseOptionalDocument = async <TDefinition extends object>(
+  kind: DocumentAssetKind,
+  path: string,
+  parser: (path: string) => Promise<Definition<TDefinition>>
+) => {
+  try {
+    return await parser(path)
+  } catch (error) {
+    warnInvalidWorkspaceAsset(kind, path, error)
+    return undefined
+  }
+}
+
 const parseEntityMarkdownDocument = async (path: string): Promise<Definition<Entity>> => {
   const definition = await parseFrontmatterDocument<Entity>(path)
 
@@ -256,6 +283,15 @@ const parseStructuredMcpFile = async (path: string) => {
     : JSON.parse(raw)
 }
 
+const parseOptionalStructuredMcpFile = async (path: string) => {
+  try {
+    return await parseStructuredMcpFile(path)
+  } catch (error) {
+    warnInvalidWorkspaceAsset('mcpServer', path, error)
+    return undefined
+  }
+}
+
 const createDocumentAsset = <
   TKind extends DocumentAssetKind,
   TDefinition extends { path: string; attributes: { name?: string } },
@@ -377,9 +413,18 @@ const createOpenCodeOverlayAsset = <TKind extends OpenCodeOverlayKind>(params: {
 const scanWorkspaceDocuments = async (cwd: string) => {
   const aiBaseDir = resolveProjectAiBaseDir(cwd, process.env)
   const entitiesDir = resolveProjectAiEntitiesDir(cwd, process.env)
-  const [rulePaths, skillPaths, specPaths, entityDocPaths, entityJsonPaths, mcpPaths] = await Promise.all([
+  const [
+    rulePaths,
+    directSkillPaths,
+    lockedSkillPaths,
+    specPaths,
+    entityDocPaths,
+    entityJsonPaths,
+    mcpPaths
+  ] = await Promise.all([
     glob(['rules/*.md'], { cwd: aiBaseDir, absolute: true }),
     glob(['skills/*/SKILL.md'], { cwd: aiBaseDir, absolute: true }),
+    scanProjectSkillLockfileDocuments(cwd),
     glob(['specs/*.md', 'specs/*/index.md'], { cwd: aiBaseDir, absolute: true }),
     glob(['*.md', '*/README.md'], { cwd: entitiesDir, absolute: true }),
     glob(['*/index.json'], { cwd: entitiesDir, absolute: true }),
@@ -388,7 +433,7 @@ const scanWorkspaceDocuments = async (cwd: string) => {
 
   return {
     rulePaths,
-    skillPaths,
+    skillPaths: Array.from(new Set([...directSkillPaths, ...lockedSkillPaths])),
     specPaths,
     entityDocPaths,
     entityJsonPaths,
@@ -451,6 +496,19 @@ const pathExists = async (path: string) => {
   }
 }
 
+const scanProjectSkillLockfileDocuments = async (cwd: string) => {
+  const lockfile = await readProjectSkillsLockfile(cwd)
+  const skillPaths: string[] = []
+  for (const entry of Object.values(lockfile.skills ?? {})) {
+    const skillPath = resolve(cwd, entry.installPath, 'SKILL.md')
+    if (await pathExists(skillPath)) {
+      skillPaths.push(skillPath)
+    }
+  }
+
+  return skillPaths
+}
+
 const scanPluginDependencySkillDocuments = async (
   cwd: string,
   instances: ResolvedPluginInstance[]
@@ -637,10 +695,12 @@ export async function collectWorkspaceAssets(params: {
     resolvedBy?: string
   ) => {
     const definitions = await Promise.all(paths.map(path => (
-      parser != null ? parser(path) : parseFrontmatterDocument(path)
+      parseOptionalDocument(kind, path, parser != null ? parser : parseFrontmatterDocument)
     )))
-    const createdAssets = definitions.map(definition =>
-      createDocumentAsset({
+    const createdAssets = definitions.flatMap((definition) => {
+      if (definition == null) return []
+
+      return [createDocumentAsset({
         cwd: params.cwd,
         kind,
         definition,
@@ -648,8 +708,8 @@ export async function collectWorkspaceAssets(params: {
         scope: instance?.scope,
         instance,
         resolvedBy
-      })
-    )
+      })]
+    })
 
     if (kind === 'skill') {
       skillAssets.push(...createdAssets as SkillAsset[])
@@ -748,7 +808,7 @@ export async function collectWorkspaceAssets(params: {
     const instance = flattenedPluginInstances[index]
     const scan = pluginScans[index]
     for (const path of scan.mcpPaths) {
-      const parsed = await parseStructuredMcpFile(path)
+      const parsed = await parseOptionalStructuredMcpFile(path)
       if (!isRecord(parsed)) continue
       const fileName = basename(path, extname(path))
       const name = typeof parsed.name === 'string' && parsed.name.trim() !== ''

package/src/configured-skills.ts

@@ -1,23 +1,69 @@
+/* eslint-disable max-lines -- configured skill resolution keeps matching, warnings, and CLI sync policy together. */
 import { access } from 'node:fs/promises'
+import { isAbsolute, join, resolve as resolvePath } from 'node:path'
 import process from 'node:process'
 
-import type { Config, ConfiguredSkillInstallConfig } from '@vibe-forge/types'
+import type {
+  Config,
+  ConfiguredSkillCollectionConfig,
+  ConfiguredSkillIncludeConfig,
+  ConfiguredSkillInstallConfig
+} from '@vibe-forge/types'
 import {
+  isConfiguredSkillCollectionInstall,
+  isWildcardSkillInclude,
   normalizeProjectSkillInstall,
+  readProjectSkillsLockfile,
   resolveConfiguredSkillInstalls as resolveDeclaredConfiguredSkillInstalls,
-  resolveProjectAiPath
+  resolveProjectAiPath,
+  toSkillSlug
 } from '@vibe-forge/utils'
-import type { NormalizedProjectSkillInstall } from '@vibe-forge/utils'
+import type { NormalizedProjectSkillInstall, ProjectSkillLockEntry } from '@vibe-forge/utils'
+
+interface NormalizedConfiguredSkillCollection {
+  include?: ConfiguredSkillCollectionConfig['include']
+  registry?: string
+  source: string
+  version?: string
+}
+
+interface MissingConfiguredProjectSkillCollection extends NormalizedConfiguredSkillCollection {
+  missingTargets?: string[]
+}
+
+const normalizeNonEmptyString = (value: unknown) => (
+  typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined
+)
+
+const resolveConfiguredProjectSkillDeclarations = (configs: [Config?, Config?]) => [
+  ...resolveDeclaredConfiguredSkillInstalls(configs[0]?.skills),
+  ...resolveDeclaredConfiguredSkillInstalls(configs[1]?.skills)
+]
 
 export const resolveConfiguredProjectSkillInstalls = (configs: [Config?, Config?]) => (
-  [
-    ...resolveDeclaredConfiguredSkillInstalls(configs[0]?.skills),
-    ...resolveDeclaredConfiguredSkillInstalls(configs[1]?.skills)
-  ]
+  resolveConfiguredProjectSkillDeclarations(configs)
     .map((item) => normalizeProjectSkillInstall(item as string | ConfiguredSkillInstallConfig))
     .filter((item): item is NormalizedProjectSkillInstall => item != null)
 )
 
+export const resolveConfiguredProjectSkillCollections = (configs: [Config?, Config?]) => (
+  resolveConfiguredProjectSkillDeclarations(configs)
+    .map((item) => {
+      if (!isConfiguredSkillCollectionInstall(item)) return undefined
+      const source = normalizeNonEmptyString(item.source)
+      if (source == null) return undefined
+      const registry = normalizeNonEmptyString(item.registry)
+      const version = normalizeNonEmptyString(item.version)
+      return {
+        ...(item.include == null ? {} : { include: item.include }),
+        ...(registry == null ? {} : { registry }),
+        source,
+        ...(version == null ? {} : { version })
+      }
+    })
+    .filter((item): item is NormalizedConfiguredSkillCollection => item != null)
+)
+
 const pathExists = async (targetPath: string) => {
   try {
     await access(targetPath)
@@ -27,6 +73,77 @@ const pathExists = async (targetPath: string) => {
   }
 }
 
+const isWildcardCollection = (collection: NormalizedConfiguredSkillCollection) => (
+  collection.include == null ||
+  collection.include.length === 0 ||
+  collection.include.some(isWildcardSkillInclude)
+)
+
+const normalizeCollectionTarget = (
+  include: ConfiguredSkillIncludeConfig
+) => {
+  if (isWildcardSkillInclude(include)) return undefined
+
+  const name = normalizeNonEmptyString(typeof include === 'string' ? include : include.name)
+  if (name == null) return undefined
+  const rename = typeof include === 'string' ? undefined : normalizeNonEmptyString(include.rename)
+  const targetName = rename ?? name
+  const targetDirName = toSkillSlug(targetName)
+  if (targetDirName === '') return undefined
+
+  return {
+    targetDirName,
+    targetName
+  }
+}
+
+const lockEntryMatchesCollection = (
+  entry: ProjectSkillLockEntry,
+  collection: NormalizedConfiguredSkillCollection
+) => (
+  entry.source === collection.source &&
+  (collection.registry == null || entry.registry === collection.registry) &&
+  (collection.version == null || entry.version === collection.version)
+)
+
+const resolveLockEntrySkillPath = (workspaceFolder: string, entry: ProjectSkillLockEntry) => {
+  const installDir = isAbsolute(entry.installPath)
+    ? entry.installPath
+    : resolvePath(workspaceFolder, entry.installPath)
+  return join(installDir, 'SKILL.md')
+}
+
+const hasInstalledCollectionLockEntry = async (params: {
+  collection: NormalizedConfiguredSkillCollection
+  entries: Record<string, ProjectSkillLockEntry>
+  workspaceFolder: string
+}) => {
+  for (const entry of Object.values(params.entries)) {
+    if (!lockEntryMatchesCollection(entry, params.collection)) continue
+    if (await pathExists(resolveLockEntrySkillPath(params.workspaceFolder, entry))) return true
+  }
+
+  return false
+}
+
+const hasInstalledSkillTarget = async (params: {
+  entries: Record<string, ProjectSkillLockEntry>
+  targetDirName: string
+  workspaceFolder: string
+}) => {
+  const entry = params.entries[params.targetDirName]
+  if (entry != null && await pathExists(resolveLockEntrySkillPath(params.workspaceFolder, entry))) return true
+
+  const skillPath = resolveProjectAiPath(
+    params.workspaceFolder,
+    process.env,
+    'skills',
+    params.targetDirName,
+    'SKILL.md'
+  )
+  return pathExists(skillPath)
+}
+
 export const ensureUniqueConfiguredSkillTargets = (skills: NormalizedProjectSkillInstall[]) => {
   const seen = new Map<string, string>()
 
@@ -52,32 +169,117 @@ export const findMissingConfiguredProjectSkills = async (params: {
 
   ensureUniqueConfiguredSkillTargets(installs)
 
+  const lockfile = await readProjectSkillsLockfile(params.workspaceFolder)
   const missing: NormalizedProjectSkillInstall[] = []
   for (const skill of installs) {
-    const skillPath = resolveProjectAiPath(
-      params.workspaceFolder,
-      process.env,
-      'skills',
-      skill.targetDirName,
-      'SKILL.md'
-    )
-    if (!await pathExists(skillPath)) missing.push(skill)
+    if (
+      !await hasInstalledSkillTarget({
+        entries: lockfile.skills ?? {},
+        targetDirName: skill.targetDirName,
+        workspaceFolder: params.workspaceFolder
+      })
+    ) {
+      missing.push(skill)
+    }
+  }
+
+  return missing
+}
+
+export const findMissingConfiguredProjectSkillCollections = async (params: {
+  configs: [Config?, Config?]
+  workspaceFolder: string
+}) => {
+  const collections = resolveConfiguredProjectSkillCollections(params.configs)
+  if (collections.length === 0) return []
+
+  const lockfile = await readProjectSkillsLockfile(params.workspaceFolder)
+  const missing: MissingConfiguredProjectSkillCollection[] = []
+  const seen = new Set<string>()
+
+  const addMissing = (collection: MissingConfiguredProjectSkillCollection) => {
+    const key = [
+      collection.source,
+      collection.registry ?? '',
+      collection.version ?? '',
+      collection.missingTargets?.join('|') ?? '*'
+    ].join('\0')
+    if (seen.has(key)) return
+    seen.add(key)
+    missing.push(collection)
+  }
+
+  for (const collection of collections) {
+    if (isWildcardCollection(collection)) {
+      if (
+        !await hasInstalledCollectionLockEntry({
+          collection,
+          entries: lockfile.skills ?? {},
+          workspaceFolder: params.workspaceFolder
+        })
+      ) {
+        addMissing(collection)
+      }
+      continue
+    }
+
+    const missingTargets: string[] = []
+    for (const include of collection.include ?? []) {
+      const target = normalizeCollectionTarget(include)
+      if (target == null) continue
+      if (
+        !await hasInstalledSkillTarget({
+          entries: lockfile.skills ?? {},
+          targetDirName: target.targetDirName,
+          workspaceFolder: params.workspaceFolder
+        })
+      ) {
+        missingTargets.push(target.targetName)
+      }
+    }
+
+    if (missingTargets.length > 0) {
+      addMissing({
+        ...collection,
+        missingTargets
+      })
+    }
   }
 
   return missing
 }
 
+const formatMissingCollectionLabel = (collection: MissingConfiguredProjectSkillCollection) => {
+  const sourceLabel = collection.version == null
+    ? collection.source
+    : `${collection.source}@${collection.version}`
+  if (collection.missingTargets == null || collection.missingTargets.length === 0) return sourceLabel
+  return `${sourceLabel} (${collection.missingTargets.join(', ')})`
+}
+
 export const warnMissingConfiguredProjectSkills = async (params: {
   configs: [Config?, Config?]
   workspaceFolder: string
 }) => {
   const missing = await findMissingConfiguredProjectSkills(params)
-  if (missing.length === 0) return []
+  const missingCollections = await findMissingConfiguredProjectSkillCollections(params)
+  if (missing.length === 0 && missingCollections.length === 0) return []
+
+  if (missing.length > 0) {
+    const names = missing.map(skill => skill.targetName).join(', ')
+    console.warn(
+      `[vibe-forge] Declared skills are not installed: ${names}. ` +
+        'Run `vf skills install` to install all declared skills, or `vf skills install <name>` for one skill.'
+    )
+  }
+
+  if (missingCollections.length > 0) {
+    const sources = missingCollections.map(formatMissingCollectionLabel).join(', ')
+    console.warn(
+      `[vibe-forge] Declared skill sources are not installed: ${sources}. ` +
+        'Run `vf skills install` to install all declared skills.'
+    )
+  }
 
-  const names = missing.map(skill => skill.targetName).join(', ')
-  console.warn(
-    `[vibe-forge] Declared skills are not installed: ${names}. ` +
-      'Run `vf skills install` to install all declared skills, or `vf skills install <name>` for one skill.'
-  )
   return missing
 }