@vibe-forge/workspace-assets 3.2.1 → 3.2.2-alpha.1

package/__tests__/skill-dependencies-cli.spec.ts

@@ -1,9 +1,7 @@
 /* eslint-disable import/first -- hoisted vitest mocks must be declared before importing the bundle entrypoint */
-import { access, mkdir, mkdtemp, rm, utimes, writeFile } from 'node:fs/promises'
-import os from 'node:os'
-import path, { join } from 'node:path'
+import { join } from 'node:path'
 
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const mocks = vi.hoisted(() => ({
   findSkillsCli: vi.fn(),
@@ -23,54 +21,15 @@ vi.mock('@vibe-forge/utils/skills-cli', async () => {
 
 import { buildAdapterAssetPlan, resolveWorkspaceAssetBundle } from '#~/index.js'
 
-import { createWorkspace, writeDocument } from './test-helpers'
+import { createWorkspace, installPluginPackage, writeDocument } from './test-helpers'
 
-describe('skills CLI dependency resolution', () => {
-  let installWorkspace: string
-
-  const pathExists = async (targetPath: string) => {
-    try {
-      await access(targetPath)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  beforeEach(async () => {
-    installWorkspace = await mkdtemp(path.join(os.tmpdir(), 'vf-skills-cli-dependency-'))
+describe('materialized skill dependency resolution', () => {
+  beforeEach(() => {
     vi.clearAllMocks()
   })
 
-  afterEach(async () => {
-    await rm(installWorkspace, { recursive: true, force: true })
-  })
-
-  it('installs missing bare-name dependencies through skills CLI by default', async () => {
+  it('fails missing dependencies without downloading during runtime preparation', async () => {
     const workspace = await createWorkspace()
-    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'frontend-design')
-    await mkdir(installedSkillDir, { recursive: true })
-    await writeFile(
-      join(installedSkillDir, 'SKILL.md'),
-      '---\nname: frontend-design\ndescription: UI design guidance\n---\nUse strong visual hierarchy.\n'
-    )
-
-    mocks.findSkillsCli.mockResolvedValue([
-      {
-        installRef: 'anthropics/skills@frontend-design',
-        source: 'anthropics/skills',
-        skill: 'frontend-design'
-      }
-    ])
-    mocks.installSkillsCliRefToTemp.mockResolvedValue({
-      tempDir: installWorkspace,
-      installedSkill: {
-        dirName: 'frontend-design',
-        name: 'frontend-design',
-        sourcePath: installedSkillDir
-      }
-    })
-
     await writeDocument(
       join(workspace, '.ai/skills/app-builder/SKILL.md'),
       [
@@ -90,57 +49,6 @@ describe('skills CLI dependency resolution', () => {
       useDefaultVibeForgeMcpServer: false
     })
 
-    await buildAdapterAssetPlan({
-      adapter: 'opencode',
-      bundle,
-      options: {
-        skills: {
-          include: ['app-builder']
-        }
-      }
-    })
-
-    const dependency = bundle.skills.find(asset => asset.name === 'frontend-design')
-    expect(bundle.skills.map(asset => asset.name).sort()).toEqual(['app-builder', 'frontend-design'])
-    expect(dependency?.sourcePath).toContain(
-      '/.ai/caches/skill-dependencies/skills-cli/skills/latest/default/anthropics/skills/latest/frontend-design/'
-    )
-    expect(mocks.findSkillsCli).toHaveBeenCalledWith({
-      query: 'frontend-design'
-    })
-    expect(mocks.installSkillsCliRefToTemp).toHaveBeenCalledWith({
-      installRef: 'anthropics/skills@frontend-design'
-    })
-  })
-
-  it('blocks missing dependency installs when auto downloads are disabled', async () => {
-    const workspace = await createWorkspace()
-
-    await writeDocument(
-      join(workspace, '.ai/skills/app-builder/SKILL.md'),
-      [
-        '---',
-        'name: app-builder',
-        'description: Build apps',
-        'dependencies:',
-        '  - name: frontend-design',
-        '    source: anthropics/skills',
-        '    registry: https://dependency-registry.example.test',
-        '---',
-        'Build the app.'
-      ].join('\n')
-    )
-
-    const bundle = await resolveWorkspaceAssetBundle({
-      cwd: workspace,
-      configs: [{
-        skills: {
-          autoDownloadDependencies: false
-        }
-      }, undefined],
-      useDefaultVibeForgeMcpServer: false
-    })
-
     await expect(buildAdapterAssetPlan({
       adapter: 'opencode',
       bundle,
@@ -149,36 +57,25 @@ describe('skills CLI dependency resolution', () => {
           include: ['app-builder']
         }
       }
-    })).rejects.toThrow('Skill dependency automatic downloads are disabled; cache not found')
+    })).rejects.toThrow('Run vf skills install or vf skills update')
 
     expect(mocks.findSkillsCli).not.toHaveBeenCalled()
     expect(mocks.installSkillsCliRefToTemp).not.toHaveBeenCalled()
     expect(mocks.installSkillsCliSkillToTemp).not.toHaveBeenCalled()
-    expect(bundle.skills.map(asset => asset.name)).toEqual(['app-builder'])
   })
 
-  it('blocks bare-name dependency searches when auto downloads are disabled', async () => {
+  it('prompts install command when an explicitly selected configured skill is missing', async () => {
     const workspace = await createWorkspace()
-
-    await writeDocument(
-      join(workspace, '.ai/skills/app-builder/SKILL.md'),
-      [
-        '---',
-        'name: app-builder',
-        'description: Build apps',
-        'dependencies:',
-        '  - frontend-design',
-        '---',
-        'Build the app.'
-      ].join('\n')
-    )
-
     const bundle = await resolveWorkspaceAssetBundle({
       cwd: workspace,
       configs: [{
-        skills: {
-          autoDownloadDependencies: false
-        }
+        skills: [
+          {
+            name: 'design-review',
+            source: 'example-source/default/public',
+            rename: 'internal-review'
+          }
+        ]
       }, undefined],
       useDefaultVibeForgeMcpServer: false
     })
@@ -188,27 +85,18 @@ describe('skills CLI dependency resolution', () => {
       bundle,
       options: {
         skills: {
-          include: ['app-builder']
+          include: ['internal-review']
         }
       }
-    })).rejects.toThrow(
-      'Skill dependency automatic downloads are disabled; cannot resolve frontend-design without a source'
-    )
+    })).rejects.toThrow('Run `vf skills install internal-review` or `vf skills install`')
 
     expect(mocks.findSkillsCli).not.toHaveBeenCalled()
     expect(mocks.installSkillsCliRefToTemp).not.toHaveBeenCalled()
     expect(mocks.installSkillsCliSkillToTemp).not.toHaveBeenCalled()
   })
 
-  it('reuses source-qualified dependency caches when auto downloads are disabled', async () => {
+  it('uses project-materialized dependencies from .ai/skills', async () => {
     const workspace = await createWorkspace()
-    await writeDocument(
-      join(
-        workspace,
-        '.ai/caches/skill-dependencies/skills-cli/skills/latest/default/anthropics/skills/latest/frontend-design/SKILL.md'
-      ),
-      '---\nname: frontend-design\ndescription: Cached UI guidance\n---\nUse the cached dependency.\n'
-    )
     await writeDocument(
       join(workspace, '.ai/skills/app-builder/SKILL.md'),
       [
@@ -216,23 +104,22 @@ describe('skills CLI dependency resolution', () => {
         'name: app-builder',
         'description: Build apps',
         'dependencies:',
-        '  - anthropics/skills@frontend-design',
+        '  - frontend-design',
         '---',
         'Build the app.'
       ].join('\n')
     )
+    await writeDocument(
+      join(workspace, '.ai/skills/frontend-design/SKILL.md'),
+      '---\nname: frontend-design\ndescription: UI design guidance\n---\nUse strong visual hierarchy.\n'
+    )
 
     const bundle = await resolveWorkspaceAssetBundle({
       cwd: workspace,
-      configs: [{
-        skills: {
-          autoDownloadDependencies: false
-        }
-      }, undefined],
+      configs: [undefined, undefined],
       useDefaultVibeForgeMcpServer: false
     })
-
-    await buildAdapterAssetPlan({
+    const plan = await buildAdapterAssetPlan({
       adapter: 'opencode',
       bundle,
       options: {
@@ -242,128 +129,79 @@ describe('skills CLI dependency resolution', () => {
       }
     })
 
+    expect(plan.overlays.filter(entry => entry.kind === 'skill').map(entry => entry.targetPath).sort()).toEqual([
+      'skills/app-builder',
+      'skills/frontend-design'
+    ])
     expect(mocks.findSkillsCli).not.toHaveBeenCalled()
-    expect(mocks.installSkillsCliRefToTemp).not.toHaveBeenCalled()
-    expect(mocks.installSkillsCliSkillToTemp).not.toHaveBeenCalled()
-    expect(bundle.skills.map(asset => asset.name).sort()).toEqual(['app-builder', 'frontend-design'])
   })
 
-  it('parses registry and version from dependency specs', async () => {
+  it('loads plugin dependencies from .ai/skills/.plugins through the lockfile', async () => {
     const workspace = await createWorkspace()
-    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'frontend-design')
-    await mkdir(installedSkillDir, { recursive: true })
-    await writeFile(
-      join(installedSkillDir, 'SKILL.md'),
-      '---\nname: frontend-design\ndescription: UI design guidance\n---\nUse internal design system.\n'
-    )
-
-    mocks.installSkillsCliSkillToTemp.mockResolvedValue({
-      tempDir: installWorkspace,
-      installedSkill: {
-        dirName: 'frontend-design',
-        name: 'frontend-design',
-        sourcePath: installedSkillDir
-      }
-    })
-
-    await writeDocument(
-      join(workspace, '.ai/skills/app-builder/SKILL.md'),
-      [
+    await installPluginPackage(workspace, '@vibe-forge/plugin-review', {
+      'package.json': JSON.stringify({ name: '@vibe-forge/plugin-review', version: '1.0.0' }, null, 2),
+      'skills/review-helper/SKILL.md': [
         '---',
-        'name: app-builder',
-        'description: Build apps',
+        'name: review-helper',
+        'description: Review helper',
         'dependencies:',
-        '  - https://registry.example.com@example-source/default/public@frontend-design@1.0.3',
+        '  - shared-runtime',
         '---',
-        'Build the app.'
+        'Review code.'
       ].join('\n')
-    )
-
-    const bundle = await resolveWorkspaceAssetBundle({
-      cwd: workspace,
-      configs: [undefined, undefined],
-      useDefaultVibeForgeMcpServer: false
     })
-
-    await buildAdapterAssetPlan({
-      adapter: 'opencode',
-      bundle,
-      options: {
-        skills: {
-          include: ['app-builder']
-        }
-      }
-    })
-
-    expect(mocks.installSkillsCliSkillToTemp).toHaveBeenCalledWith({
-      registry: 'https://registry.example.com',
-      skill: 'frontend-design',
-      source: 'example-source/default/public',
-      version: '1.0.3'
-    })
-  })
-
-  it('clears stale dependency install locks before retrying a direct startup install', async () => {
-    const workspace = await createWorkspace()
-    const installedSkillDir = join(installWorkspace, '.agents', 'skills', 'lynx-cat')
-    await mkdir(installedSkillDir, { recursive: true })
-    await writeFile(
-      join(installedSkillDir, 'SKILL.md'),
-      '---\nname: lynx-cat\ndescription: Lynx helper\n---\nDebug Lynx apps.\n'
+    await writeDocument(
+      join(workspace, '.ai/skills/.plugins/review/shared-runtime/SKILL.md'),
+      '---\nname: shared-runtime\ndescription: Shared runtime\n---\nShared plugin dependency.\n'
     )
-
-    mocks.installSkillsCliSkillToTemp.mockResolvedValue({
-      tempDir: installWorkspace,
-      installedSkill: {
-        dirName: 'lynx-cat',
-        name: 'lynx-cat',
-        sourcePath: installedSkillDir
-      }
-    })
-
     await writeDocument(
-      join(workspace, '.ai/skills/lynx-miniapp/SKILL.md'),
+      join(workspace, '.ai/skills.lock.yaml'),
       [
-        '---',
-        'name: lynx-miniapp',
-        'description: lynx 调试使用',
-        'dependencies:',
-        '  - https://registry.example.com@example-source/lynx/skills@lynx-cat@latest',
-        '---',
-        '这是一个测试的 lynx 调试技能'
+        'version: 1',
+        'pluginSkills:',
+        '  review/shared-runtime:',
+        '    name: shared-runtime',
+        '    requested: false',
+        '    pluginInstance: review',
+        '    pluginInstancePath: "0"',
+        '    installPath: .ai/skills/.plugins/review/shared-runtime',
+        '    dependencyOf:',
+        '      - plugin:review/review-helper',
+        '    source: vendor/shared-skills',
+        '    version: 1.0.0',
+        '    hash: sha256:test',
+        '    installedAt: "2026-05-13T00:00:00.000Z"'
       ].join('\n')
     )
 
-    const lockDir = join(
-      workspace,
-      '.ai/caches/skill-dependencies/skills-cli/skills/latest/https-registry.example.com/example-source/lynx/skills/latest/lynx-cat.lock'
-    )
-    await mkdir(lockDir, { recursive: true })
-    await utimes(lockDir, new Date(Date.now() - 120_000), new Date(Date.now() - 120_000))
-
     const bundle = await resolveWorkspaceAssetBundle({
       cwd: workspace,
-      configs: [undefined, undefined],
+      configs: [{
+        plugins: [{
+          id: '@vibe-forge/plugin-review',
+          scope: 'review'
+        }]
+      }, undefined],
       useDefaultVibeForgeMcpServer: false
     })
-
-    await buildAdapterAssetPlan({
+    const plan = await buildAdapterAssetPlan({
       adapter: 'opencode',
       bundle,
       options: {
         skills: {
-          include: ['lynx-miniapp']
+          include: ['review/review-helper']
         }
       }
     })
 
-    expect(mocks.installSkillsCliSkillToTemp).toHaveBeenCalledWith({
-      registry: 'https://registry.example.com',
-      skill: 'lynx-cat',
-      source: 'example-source/lynx/skills',
-      version: 'latest'
-    })
-    await expect(pathExists(lockDir)).resolves.toBe(false)
-    expect(bundle.skills.map(asset => asset.name).sort()).toEqual(['lynx-cat', 'lynx-miniapp'])
+    expect(bundle.skills.map(asset => asset.displayName).sort()).toEqual([
+      'review/review-helper',
+      'review/shared-runtime'
+    ])
+    expect(plan.overlays.filter(entry => entry.kind === 'skill').map(entry => entry.targetPath).sort()).toEqual([
+      'skills/review__review-helper',
+      'skills/review__shared-runtime'
+    ])
+    expect(mocks.installSkillsCliSkillToTemp).not.toHaveBeenCalled()
   })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-forge/workspace-assets",
-  "version": "3.2.1",
+  "version": "3.2.2-alpha.1",
   "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/definition-core": "3.2.0",
-    "@vibe-forge/config": "3.2.2",
-    "@vibe-forge/types": "3.2.2",
-    "@vibe-forge/utils": "3.2.2"
+    "@vibe-forge/config": "3.2.3-alpha.1",
+    "@vibe-forge/utils": "3.2.3-alpha.1",
+    "@vibe-forge/types": "3.2.3-alpha.1",
+    "@vibe-forge/definition-core": "3.2.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9"

package/src/bundle-internal.ts

@@ -1,4 +1,4 @@
-import { readFile } from 'node:fs/promises'
+import { access, readFile } from 'node:fs/promises'
 import { basename, dirname, extname, isAbsolute, resolve } from 'node:path'
 import process from 'node:process'
 
@@ -10,10 +10,11 @@ import {
 } from '@vibe-forge/config'
 import type { Config, Definition, Entity, PluginConfig, WorkspaceAsset, WorkspaceAssetKind } from '@vibe-forge/types'
 import {
-  isObjectSkillsConfig,
+  readProjectSkillsLockfile,
   resolveProjectAiBaseDir,
   resolveProjectAiEntitiesDir,
-  resolveRelativePath
+  resolveRelativePath,
+  resolveSkillsHomeBridge
 } from '@vibe-forge/utils'
 import { listManagedPluginInstalls, toManagedPluginConfig } from '@vibe-forge/utils/managed-plugin'
 import {
@@ -33,8 +34,9 @@ import {
   resolveSkillIdentifier,
   resolveSpecIdentifier
 } from '@vibe-forge/definition-core'
-import { ensureConfiguredProjectSkills } from './configured-skills'
+import { warnMissingConfiguredProjectSkills } from './configured-skills'
 import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
+import { PLUGIN_SKILL_DEPENDENCY_RESOLVED_BY } from './plugin-skill-dependencies'
 import { resolveConfiguredWorkspaceAssets } from './workspaces'
 
 type DocumentAssetKind = Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>
@@ -152,15 +154,15 @@ const resolveRealHomeDir = (env: NodeJS.ProcessEnv) => {
 
 const warnInvalidHomeSkillRoot = (root: string) => {
   console.warn(
-    `[vibe-forge] Ignoring invalid skills.homeBridge root "${root}". ` +
+    `[vibe-forge] Ignoring invalid skillsMeta.homeBridge root "${root}". ` +
       'Use an absolute path or a path starting with "~".'
   )
 }
 
 const resolveHomeBridgeConfig = (configs: [Config?, Config?]) => {
   const [config, userConfig] = configs
-  const projectHomeBridge = isObjectSkillsConfig(config?.skills) ? config.skills.homeBridge : undefined
-  const userHomeBridge = isObjectSkillsConfig(userConfig?.skills) ? userConfig.skills.homeBridge : undefined
+  const projectHomeBridge = resolveSkillsHomeBridge(config)
+  const userHomeBridge = resolveSkillsHomeBridge(userConfig)
 
   return {
     enabled: userHomeBridge?.enabled ?? projectHomeBridge?.enabled ?? true,
@@ -440,6 +442,40 @@ const scanInstanceDocuments = async (instance: ResolvedPluginInstance) => {
   }
 }
 
+const pathExists = async (path: string) => {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+const scanPluginDependencySkillDocuments = async (
+  cwd: string,
+  instances: ResolvedPluginInstance[]
+) => {
+  const lockfile = await readProjectSkillsLockfile(cwd)
+  const documents: Array<{ instance: ResolvedPluginInstance; path: string }> = []
+  for (const entry of Object.values(lockfile.pluginSkills ?? {})) {
+    const instance = instances.find(candidate => (
+      candidate.instancePath === entry.pluginInstancePath ||
+      candidate.scope === entry.pluginInstance
+    ))
+    if (instance == null) continue
+
+    const skillPath = resolve(cwd, entry.installPath, 'SKILL.md')
+    if (await pathExists(skillPath)) {
+      documents.push({
+        instance,
+        path: skillPath
+      })
+    }
+  }
+
+  return documents
+}
+
 const toOpenCodeOverlayEntries = (
   kind: OpenCodeOverlayKind,
   targetDir: 'agents' | 'commands' | 'modes' | 'plugins',
@@ -535,6 +571,7 @@ export async function collectWorkspaceAssets(params: {
   syncConfiguredSkills?: boolean
   updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
+  warnMissingConfiguredSkills?: boolean
 }): Promise<{
   assets: WorkspaceAsset[]
   configs: [Config?, Config?]
@@ -552,10 +589,15 @@ export async function collectWorkspaceAssets(params: {
   workspaces: Array<Extract<WorkspaceAsset, { kind: 'workspace' }>>
 }> {
   const [config, userConfig] = params.configs ?? await loadWorkspaceConfig(params.cwd)
-  if (params.syncConfiguredSkills === true) {
-    await ensureConfiguredProjectSkills({
+  if (params.syncConfiguredSkills === true || params.updateConfiguredSkills === true) {
+    console.warn(
+      '[vibe-forge] Runtime skill install/update is disabled. ' +
+        'Run `vf skills install` or `vf skills update` before starting the session.'
+    )
+  }
+  if (params.warnMissingConfiguredSkills === true) {
+    await warnMissingConfiguredProjectSkills({
       configs: [config, userConfig],
-      updateInstalledSkills: params.updateConfiguredSkills,
       workspaceFolder: params.cwd
     })
   }
@@ -578,6 +620,7 @@ export async function collectWorkspaceAssets(params: {
   ])
   const flattenedPluginInstances = flattenPluginInstances(pluginInstances)
   const pluginScans = await Promise.all(flattenedPluginInstances.map(instance => scanInstanceDocuments(instance)))
+  const pluginDependencySkillDocs = await scanPluginDependencySkillDocuments(params.cwd, flattenedPluginInstances)
   const pluginOverlayScans = await Promise.all(
     flattenedPluginInstances.map(instance => scanInstanceOpenCodeOverlays(instance))
   )
@@ -631,6 +674,16 @@ export async function collectWorkspaceAssets(params: {
     await pushDocumentAssets('entity', scan.entityDocPaths, 'plugin', instance, parseEntityMarkdownDocument)
     await pushDocumentAssets('entity', scan.entityJsonPaths, 'plugin', instance, parseEntityIndexJson)
   }
+  for (const entry of pluginDependencySkillDocs) {
+    await pushDocumentAssets(
+      'skill',
+      [entry.path],
+      'plugin',
+      entry.instance,
+      undefined,
+      PLUGIN_SKILL_DEPENDENCY_RESOLVED_BY
+    )
+  }
   await pushDocumentAssets('skill', homeSkillPaths, 'workspace', undefined, undefined, HOME_BRIDGE_RESOLVED_BY)
 
   const skills = mergeSkillAssets(skillAssets)

package/src/bundle.ts

@@ -11,6 +11,7 @@ export async function resolveWorkspaceAssetBundle(params: {
   syncConfiguredSkills?: boolean
   updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
+  warnMissingConfiguredSkills?: boolean
 }): Promise<WorkspaceAssetBundle> {
   const collected = await collectWorkspaceAssets(params)
 

package/src/configured-skills.ts

@@ -3,15 +3,13 @@ import process from 'node:process'
 
 import type { Config, ConfiguredSkillInstallConfig } from '@vibe-forge/types'
 import {
-  installProjectSkill,
   normalizeProjectSkillInstall,
   resolveConfiguredSkillInstalls as resolveDeclaredConfiguredSkillInstalls,
-  resolveProjectAiPath,
-  resolveSkillsRegistry
+  resolveProjectAiPath
 } from '@vibe-forge/utils'
 import type { NormalizedProjectSkillInstall } from '@vibe-forge/utils'
 
-const resolveConfiguredSkillInstalls = (configs: [Config?, Config?]) => (
+export const resolveConfiguredProjectSkillInstalls = (configs: [Config?, Config?]) => (
   [
     ...resolveDeclaredConfiguredSkillInstalls(configs[0]?.skills),
     ...resolveDeclaredConfiguredSkillInstalls(configs[1]?.skills)
@@ -29,7 +27,7 @@ const pathExists = async (targetPath: string) => {
   }
 }
 
-const ensureUniqueTargets = (skills: NormalizedProjectSkillInstall[]) => {
+export const ensureUniqueConfiguredSkillTargets = (skills: NormalizedProjectSkillInstall[]) => {
   const seen = new Map<string, string>()
 
   for (const skill of skills) {
@@ -43,22 +41,18 @@ const ensureUniqueTargets = (skills: NormalizedProjectSkillInstall[]) => {
   }
 }
 
-export const ensureConfiguredProjectSkills = async (params: {
+export const findMissingConfiguredProjectSkills = async (params: {
   configs: [Config?, Config?]
-  updateInstalledSkills?: boolean
   workspaceFolder: string
 }) => {
-  const defaultRegistry = resolveSkillsRegistry(params.configs[1]?.skills) ??
-    resolveSkillsRegistry(params.configs[0]?.skills)
-  const installs = resolveConfiguredSkillInstalls(params.configs)
+  const installs = resolveConfiguredProjectSkillInstalls(params.configs)
   if (installs.length === 0) {
     return []
   }
 
-  ensureUniqueTargets(installs)
-
-  const ensured: Array<{ dirName: string; skillPath: string }> = []
+  ensureUniqueConfiguredSkillTargets(installs)
 
+  const missing: NormalizedProjectSkillInstall[] = []
   for (const skill of installs) {
     const skillPath = resolveProjectAiPath(
       params.workspaceFolder,
@@ -67,23 +61,23 @@ export const ensureConfiguredProjectSkills = async (params: {
       skill.targetDirName,
       'SKILL.md'
     )
-    if (params.updateInstalledSkills !== true && await pathExists(skillPath)) {
-      ensured.push({
-        dirName: skill.targetDirName,
-        skillPath
-      })
-      continue
-    }
-
-    ensured.push(
-      await installProjectSkill({
-        force: true,
-        registry: defaultRegistry,
-        skill,
-        workspaceFolder: params.workspaceFolder
-      })
-    )
+    if (!await pathExists(skillPath)) missing.push(skill)
   }
 
-  return ensured
+  return missing
+}
+
+export const warnMissingConfiguredProjectSkills = async (params: {
+  configs: [Config?, Config?]
+  workspaceFolder: string
+}) => {
+  const missing = await findMissingConfiguredProjectSkills(params)
+  if (missing.length === 0) return []
+
+  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
 }

package/src/plugin-skill-dependencies.ts

@@ -0,0 +1 @@
+export const PLUGIN_SKILL_DEPENDENCY_RESOLVED_BY = 'plugin-skill-dependency-lock'