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

package/__tests__/bundle.spec.ts

@@ -2,7 +2,6 @@
 import { join } from 'node:path'
 import process from 'node:process'
 
-import { readFile } from 'node:fs/promises'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 
 const skillsCliMocks = vi.hoisted(() => ({
@@ -27,6 +26,7 @@ import { createWorkspace, installPluginPackage, writeDocument } from './test-hel
 
 afterEach(() => {
   vi.clearAllMocks()
+  vi.restoreAllMocks()
   vi.unstubAllGlobals()
 })
 
@@ -291,7 +291,7 @@ describe('resolveWorkspaceAssetBundle', () => {
 
       expect(bundle.skills).toEqual([])
       expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Ignoring invalid skills.homeBridge root "./team-skills"')
+        expect.stringContaining('Ignoring invalid skillsMeta.homeBridge root "./team-skills"')
       )
     } finally {
       warnSpy.mockRestore()
@@ -386,22 +386,9 @@ describe('resolveWorkspaceAssetBundle', () => {
     }))
   })
 
-  it('installs configured project skills before bundle resolution and rewrites renamed skill names', async () => {
+  it('does not install configured project skills during bundle resolution and warns when requested', async () => {
     const workspace = await createWorkspace()
-    const tempInstallDir = join(workspace, '.tmp-configured-install')
-    const installedSkillDir = join(tempInstallDir, '.agents', 'skills', 'design-review')
-    await writeDocument(
-      join(installedSkillDir, 'SKILL.md'),
-      '---\nname: design-review\ndescription: Review design work\n---\nReview the UI implementation.\n'
-    )
-    skillsCliMocks.installSkillsCliSkillToTemp.mockResolvedValue({
-      tempDir: tempInstallDir,
-      installedSkill: {
-        dirName: 'design-review',
-        name: 'design-review',
-        sourcePath: installedSkillDir
-      }
-    })
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
 
     const bundle = await resolveWorkspaceAssetBundle({
       cwd: workspace,
@@ -414,22 +401,16 @@ describe('resolveWorkspaceAssetBundle', () => {
           }
         ]
       }, undefined],
-      syncConfiguredSkills: true,
+      warnMissingConfiguredSkills: true,
       useDefaultVibeForgeMcpServer: false
     })
 
-    expect(bundle.skills.map(asset => asset.name)).toContain('internal-review')
-    expect(skillsCliMocks.installSkillsCliSkillToTemp).toHaveBeenCalledWith({
-      config: undefined,
-      skill: 'design-review',
-      source: 'example-source/default/public'
-    })
-    await expect(readFile(join(workspace, '.ai/skills/internal-review/SKILL.md'), 'utf8')).resolves.toContain(
-      'name: internal-review'
-    )
+    expect(bundle.skills.map(asset => asset.name)).not.toContain('internal-review')
+    expect(skillsCliMocks.installSkillsCliSkillToTemp).not.toHaveBeenCalled()
+    expect(warn).toHaveBeenCalledWith(expect.stringContaining('Declared skills are not installed: internal-review'))
   })
 
-  it('skips configured skill reinstalls unless updateConfiguredSkills is enabled', async () => {
+  it('loads installed configured skills without attempting runtime updates', async () => {
     const workspace = await createWorkspace()
     await writeDocument(
       join(workspace, '.ai/skills/internal-review/SKILL.md'),
@@ -447,48 +428,12 @@ describe('resolveWorkspaceAssetBundle', () => {
           }
         ]
       }, undefined],
-      syncConfiguredSkills: true,
+      warnMissingConfiguredSkills: true,
       useDefaultVibeForgeMcpServer: false
     })
 
     expect(skippedBundle.skills.map(asset => asset.name)).toContain('internal-review')
     expect(skillsCliMocks.installSkillsCliSkillToTemp).not.toHaveBeenCalled()
-
-    const tempInstallDir = join(workspace, '.tmp-configured-update')
-    const installedSkillDir = join(tempInstallDir, '.agents', 'skills', 'design-review')
-    await writeDocument(
-      join(installedSkillDir, 'SKILL.md'),
-      '---\nname: design-review\ndescription: Updated skill\n---\nUpdated content.\n'
-    )
-    skillsCliMocks.installSkillsCliSkillToTemp.mockResolvedValueOnce({
-      tempDir: tempInstallDir,
-      installedSkill: {
-        dirName: 'design-review',
-        name: 'design-review',
-        sourcePath: installedSkillDir
-      }
-    })
-
-    await resolveWorkspaceAssetBundle({
-      cwd: workspace,
-      configs: [{
-        skills: [
-          {
-            name: 'design-review',
-            source: 'example-source/default/public',
-            rename: 'internal-review'
-          }
-        ]
-      }, undefined],
-      syncConfiguredSkills: true,
-      updateConfiguredSkills: true,
-      useDefaultVibeForgeMcpServer: false
-    })
-
-    expect(skillsCliMocks.installSkillsCliSkillToTemp).toHaveBeenCalledTimes(1)
-    await expect(readFile(join(workspace, '.ai/skills/internal-review/SKILL.md'), 'utf8')).resolves.toContain(
-      'Updated content.'
-    )
   })
 
   it('loads workspace entities from the env-configured entities dir', async () => {

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

@@ -64,6 +64,37 @@ describe('materialized skill dependency resolution', () => {
     expect(mocks.installSkillsCliSkillToTemp).not.toHaveBeenCalled()
   })
 
+  it('prompts install command when an explicitly selected configured skill is missing', async () => {
+    const workspace = await createWorkspace()
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [{
+        skills: [
+          {
+            name: 'design-review',
+            source: 'example-source/default/public',
+            rename: 'internal-review'
+          }
+        ]
+      }, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    await expect(buildAdapterAssetPlan({
+      adapter: 'opencode',
+      bundle,
+      options: {
+        skills: {
+          include: ['internal-review']
+        }
+      }
+    })).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('uses project-materialized dependencies from .ai/skills', async () => {
     const workspace = await createWorkspace()
     await writeDocument(

package/package.json

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

package/src/bundle-internal.ts

@@ -10,11 +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 {
@@ -34,7 +34,7 @@ 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'
@@ -154,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,
@@ -571,6 +571,7 @@ export async function collectWorkspaceAssets(params: {
   syncConfiguredSkills?: boolean
   updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
+  warnMissingConfiguredSkills?: boolean
 }): Promise<{
   assets: WorkspaceAsset[]
   configs: [Config?, Config?]
@@ -588,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
     })
   }

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/prompt-selection.ts

@@ -29,7 +29,7 @@ import {
   resolveEntityInheritance,
   resolveExcludedSkillRefs,
   resolveIncludedSkillRefs,
-  resolveNamedAssets,
+  resolveNamedSkillAssets,
   resolvePluginOverlay,
   resolveRuleSelection,
   resolveSelectedSkillAssetsWithDependencies,
@@ -158,10 +158,10 @@ export async function resolvePromptAssetSelection(params: {
     const includedAssets = skillSelection == null
       ? []
       : includedRefs != null
-      ? (includedRefs.length > 0 ? resolveNamedAssets(effectiveBundle.skills, includedRefs, targetInstancePath) : [])
+      ? (includedRefs.length > 0 ? resolveNamedSkillAssets(effectiveBundle, includedRefs, targetInstancePath) : [])
       : effectiveBundle.skills
     const excludedIds = new Set(
-      resolveNamedAssets(effectiveBundle.skills, excludedRefs, targetInstancePath).map(asset => asset.id)
+      resolveNamedSkillAssets(effectiveBundle, excludedRefs, targetInstancePath).map(asset => asset.id)
     )
 
     const expandedTargetSkills = await expandSkillAssetDependenciesWithRemoteResolution({

package/src/selection-internal.ts

@@ -15,7 +15,7 @@ import type {
   WorkspaceMcpSelection,
   WorkspaceSkillSelection
 } from '@vibe-forge/types'
-import { normalizePath } from '@vibe-forge/utils'
+import { matchesDeclaredSkillSelector, normalizePath } from '@vibe-forge/utils'
 import { mergePluginConfigs, normalizePluginConfig } from '@vibe-forge/utils/plugin-resolver'
 import { glob } from 'fast-glob'
 
@@ -26,6 +26,7 @@ import {
   isRemoteRuleReference,
   parseScopedReference
 } from '@vibe-forge/definition-core'
+import { resolveConfiguredProjectSkillInstalls } from './configured-skills'
 import { PLUGIN_SKILL_DEPENDENCY_RESOLVED_BY } from './plugin-skill-dependencies'
 import { expandSkillAssetDependencies, expandSkillAssetDependenciesWithRemoteResolution } from './skill-dependencies'
 
@@ -516,6 +517,38 @@ export const resolveExcludedSkillRefs = (selection: string[] | SkillSelection |
   return selection.type === 'exclude' ? selection.list : undefined
 }
 
+const createMissingConfiguredSkillMessage = (
+  bundle: WorkspaceAssetBundle,
+  refs: string[] | undefined
+) => {
+  const configs = bundle.configs ?? [undefined, undefined]
+  const declared = resolveConfiguredProjectSkillInstalls(configs)
+
+  for (const ref of refs ?? []) {
+    const match = declared.find(skill => matchesDeclaredSkillSelector(ref, skill))
+    if (match == null) continue
+
+    return `Skill ${ref} is declared in config but is not installed. ` +
+      `Run \`vf skills install ${match.targetName}\` or \`vf skills install\` before selecting it.`
+  }
+
+  return undefined
+}
+
+export const resolveNamedSkillAssets = (
+  bundle: WorkspaceAssetBundle,
+  refs: string[] | undefined,
+  currentInstancePath?: string
+) => {
+  try {
+    return resolveNamedAssets(bundle.skills, refs, currentInstancePath)
+  } catch (error) {
+    const message = createMissingConfiguredSkillMessage(bundle, refs)
+    if (message != null) throw new Error(message)
+    throw error
+  }
+}
+
 export const resolveSelectedSkillAssets = (
   assets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>,
   selection?: WorkspaceSkillSelection
@@ -540,10 +573,10 @@ export const resolveSelectedSkillAssetsWithDependencies = async (
 ): Promise<Array<Extract<WorkspaceAsset, { kind: 'skill' }>>> => {
   const rootAssets = bundle.skills.filter(asset => !isPluginSkillDependencyAsset(asset))
   const included = selection?.include != null && selection.include.length > 0
-    ? resolveNamedAssets(bundle.skills, selection.include)
+    ? resolveNamedSkillAssets(bundle, selection.include)
     : rootAssets
   const excluded = new Set(
-    resolveNamedAssets(bundle.skills, selection?.exclude).map(asset => asset.id)
+    resolveNamedSkillAssets(bundle, selection?.exclude).map(asset => asset.id)
   )
   return await expandSkillAssetDependenciesWithRemoteResolution({
     allAssets: bundle.assets,