@vibe-forge/workspace-assets 2.0.0 → 2.0.1

package/src/adapter-asset-plan.ts

@@ -11,9 +11,10 @@ import type {
 } from '@vibe-forge/types'
 
 import { resolveNativeSkillDiagnosticReason, supportsNativeProjectSkills } from './adapter-capabilities'
-import { resolveSelectedMcpNames, resolveSelectedSkillAssets } from './selection-internal'
+import { resolveWorkspaceAssetSource } from './asset-source'
+import { resolveSelectedMcpNames, resolveSelectedSkillAssetsWithDependencies } from './selection-internal'
 
-export function buildAdapterAssetPlan(params: {
+export async function buildAdapterAssetPlan(params: {
   adapter: WorkspaceAssetAdapter
   bundle: WorkspaceAssetBundle
   options: {
@@ -21,17 +22,24 @@ export function buildAdapterAssetPlan(params: {
     skills?: WorkspaceSkillSelection
     promptAssetIds?: string[]
   }
-}): AdapterAssetPlan {
+}): Promise<AdapterAssetPlan> {
   const diagnostics: AssetDiagnostic[] = []
-
-  for (const assetId of params.options.promptAssetIds ?? []) {
-    const asset = params.bundle.assets.find(item => item.id === assetId)
-    if (asset == null || asset.kind === 'mcpServer') continue
+  const pushDiagnostic = (
+    asset: Parameters<typeof resolveWorkspaceAssetSource>[0] & {
+      id: string
+      packageId?: string
+      scope?: string
+      instancePath?: string
+      taskOverlaySource?: string
+    },
+    diagnostic: Pick<AssetDiagnostic, 'adapter' | 'status' | 'reason'>
+  ) => {
     diagnostics.push({
-      assetId,
-      adapter: params.adapter,
-      status: 'prompt',
-      reason: 'Mapped into the generated system prompt.',
+      assetId: asset.id,
+      adapter: diagnostic.adapter,
+      status: diagnostic.status,
+      reason: diagnostic.reason,
+      source: resolveWorkspaceAssetSource(asset),
       packageId: asset.packageId,
       scope: asset.scope,
       instancePath: asset.instancePath,
@@ -41,6 +49,16 @@ export function buildAdapterAssetPlan(params: {
     })
   }
 
+  for (const assetId of params.options.promptAssetIds ?? []) {
+    const asset = params.bundle.assets.find(item => item.id === assetId)
+    if (asset == null || asset.kind === 'mcpServer') continue
+    pushDiagnostic(asset, {
+      adapter: params.adapter,
+      status: 'prompt',
+      reason: 'Mapped into the generated system prompt.'
+    })
+  }
+
   const selectedMcpNames = resolveSelectedMcpNames(params.bundle, params.options.mcpServers)
   const mcpServers = Object.fromEntries(
     selectedMcpNames.map(name => [name, params.bundle.mcpServers[name].payload.config])
@@ -48,25 +66,17 @@ export function buildAdapterAssetPlan(params: {
 
   selectedMcpNames.forEach((name) => {
     const asset = params.bundle.mcpServers[name]
-    diagnostics.push({
-      assetId: asset.id,
+    pushDiagnostic(asset, {
       adapter: params.adapter,
       status: params.adapter === 'claude-code' ? 'native' : 'translated',
       reason: params.adapter === 'claude-code'
         ? 'Mapped into adapter MCP settings.'
-        : 'Translated into adapter-specific MCP configuration.',
-      packageId: asset.packageId,
-      scope: asset.scope,
-      instancePath: asset.instancePath,
-      origin: asset.origin,
-      resolvedBy: asset.resolvedBy,
-      taskOverlaySource: asset.taskOverlaySource
+        : 'Translated into adapter-specific MCP configuration.'
     })
   })
 
   params.bundle.hookPlugins.forEach((asset) => {
-    diagnostics.push({
-      assetId: asset.id,
+    pushDiagnostic(asset, {
       adapter: params.adapter,
       status: params.adapter === 'copilot' ? 'translated' : 'native',
       reason: params.adapter === 'claude-code'
@@ -79,80 +89,46 @@ export function buildAdapterAssetPlan(params: {
         ? 'Handled by the Vibe Forge task hook bridge.'
         : params.adapter === 'kimi'
         ? 'Mapped into the Kimi native hooks bridge.'
-        : 'Mapped into the OpenCode native hooks bridge.',
-      packageId: asset.packageId,
-      scope: asset.scope,
-      instancePath: asset.instancePath,
-      origin: asset.origin,
-      resolvedBy: asset.resolvedBy,
-      taskOverlaySource: asset.taskOverlaySource
+        : 'Mapped into the OpenCode native hooks bridge.'
     })
   })
 
-  const selectedSkillAssets = resolveSelectedSkillAssets(params.bundle.skills, params.options.skills)
+  const selectedSkillAssets = await resolveSelectedSkillAssetsWithDependencies(params.bundle, params.options.skills)
   if (supportsNativeProjectSkills(params.adapter)) {
     selectedSkillAssets.forEach((asset) => {
-      diagnostics.push({
-        assetId: asset.id,
+      pushDiagnostic(asset, {
         adapter: params.adapter,
         status: 'native',
-        reason: resolveNativeSkillDiagnosticReason(params.adapter),
-        packageId: asset.packageId,
-        scope: asset.scope,
-        instancePath: asset.instancePath,
-        origin: asset.origin,
-        resolvedBy: asset.resolvedBy,
-        taskOverlaySource: asset.taskOverlaySource
+        reason: resolveNativeSkillDiagnosticReason(params.adapter)
       })
     })
   }
   if (params.adapter === 'opencode') {
     params.bundle.opencodeOverlayAssets.forEach((asset) => {
-      diagnostics.push({
-        assetId: asset.id,
+      pushDiagnostic(asset, {
         adapter: params.adapter,
         status: 'native',
-        reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native OpenCode asset.',
-        packageId: asset.packageId,
-        scope: asset.scope,
-        instancePath: asset.instancePath,
-        origin: asset.origin,
-        resolvedBy: asset.resolvedBy,
-        taskOverlaySource: asset.taskOverlaySource
+        reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native OpenCode asset.'
       })
     })
   } else if (params.adapter === 'codex' || params.adapter === 'copilot' || params.adapter === 'kimi') {
     params.bundle.opencodeOverlayAssets.forEach((asset) => {
-      diagnostics.push({
-        assetId: asset.id,
+      pushDiagnostic(asset, {
         adapter: params.adapter,
         status: 'skipped',
         reason: params.adapter === 'codex'
           ? 'No stable native Codex mapping exists for this asset kind in V1.'
           : params.adapter === 'copilot'
           ? 'No stable native Copilot mapping exists for this asset kind in V1.'
-          : 'No stable native Kimi mapping exists for this asset kind in V1.',
-        packageId: asset.packageId,
-        scope: asset.scope,
-        instancePath: asset.instancePath,
-        origin: asset.origin,
-        resolvedBy: asset.resolvedBy,
-        taskOverlaySource: asset.taskOverlaySource
+          : 'No stable native Kimi mapping exists for this asset kind in V1.'
       })
     })
   } else if (params.adapter === 'gemini') {
     params.bundle.opencodeOverlayAssets.forEach((asset) => {
-      diagnostics.push({
-        assetId: asset.id,
+      pushDiagnostic(asset, {
         adapter: params.adapter,
         status: 'skipped',
-        reason: 'No stable native Gemini mapping exists for this asset kind in V1.',
-        packageId: asset.packageId,
-        scope: asset.scope,
-        instancePath: asset.instancePath,
-        origin: asset.origin,
-        resolvedBy: asset.resolvedBy,
-        taskOverlaySource: asset.taskOverlaySource
+        reason: 'No stable native Gemini mapping exists for this asset kind in V1.'
       })
     })
   }

package/src/asset-source.ts

@@ -0,0 +1,13 @@
+import type { DefinitionSource, WorkspaceAsset } from '@vibe-forge/types'
+
+import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
+
+export const resolveWorkspaceAssetSource = (
+  asset: Pick<WorkspaceAsset, 'origin' | 'resolvedBy'>
+): DefinitionSource => (
+  asset.resolvedBy === HOME_BRIDGE_RESOLVED_BY
+    ? 'home'
+    : asset.origin === 'plugin'
+    ? 'plugin'
+    : 'project'
+)

package/src/bundle-internal.ts

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises'
-import { basename, dirname, extname, resolve } from 'node:path'
+import { basename, dirname, extname, isAbsolute, resolve } from 'node:path'
 import process from 'node:process'
 
 import {
@@ -9,7 +9,12 @@ import {
   resolveDefaultVibeForgeMcpServerConfig
 } from '@vibe-forge/config'
 import type { Config, Definition, Entity, PluginConfig, WorkspaceAsset, WorkspaceAssetKind } from '@vibe-forge/types'
-import { resolveProjectAiBaseDir, resolveProjectAiEntitiesDir, resolveRelativePath } from '@vibe-forge/utils'
+import {
+  isLegacySkillsConfig,
+  resolveProjectAiBaseDir,
+  resolveProjectAiEntitiesDir,
+  resolveRelativePath
+} from '@vibe-forge/utils'
 import { listManagedPluginInstalls, toManagedPluginConfig } from '@vibe-forge/utils/managed-plugin'
 import {
   flattenPluginInstances,
@@ -28,10 +33,14 @@ import {
   resolveSkillIdentifier,
   resolveSpecIdentifier
 } from '@vibe-forge/definition-core'
+import { ensureConfiguredProjectSkills } from './configured-skills'
+import { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
+import { resolveConfiguredWorkspaceAssets } from './workspaces'
 
 type DocumentAssetKind = Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>
 type OpenCodeOverlayKind = Extract<WorkspaceAssetKind, 'agent' | 'command' | 'mode' | 'nativePlugin'>
 type OpenCodeOverlayAsset<TKind extends OpenCodeOverlayKind> = Extract<WorkspaceAsset, { kind: TKind }>
+type SkillAsset = Extract<WorkspaceAsset, { kind: 'skill' }>
 
 type DocumentAsset<TDefinition> = Extract<WorkspaceAsset, { kind: DocumentAssetKind }> & {
   payload: {
@@ -50,10 +59,147 @@ const isRecord = (value: unknown): value is Record<string, unknown> => (
   value != null && typeof value === 'object' && !Array.isArray(value)
 )
 
+const ENTITY_DIRECTORY_ENTRY_FILES = new Set(['readme.md', 'index.json'])
+const DEFAULT_HOME_SKILL_ROOTS = [
+  '~/.agents/skills',
+  '~/.claude/skills',
+  '~/.config/opencode/skills',
+  '~/.gemini/skills'
+] as const
+
+const DEFAULT_ENTITY_PROMPT_FILE_SECTIONS = [
+  {
+    heading: 'Introduction',
+    fileNames: ['INTRODUCTION.md', 'introduction.md', '介绍.md']
+  },
+  {
+    heading: 'Personality',
+    fileNames: ['PERSONALITY.md', 'personality.md', '人格.md']
+  },
+  {
+    heading: 'Memory',
+    fileNames: ['MEMORY.md', 'memory.md', '记忆.md']
+  }
+] as const
+
+const isMissingFileError = (error: unknown) => (
+  error != null &&
+  typeof error === 'object' &&
+  'code' in error &&
+  (error as { code?: unknown }).code === 'ENOENT'
+)
+
+const readOptionalMarkdownBody = async (path: string) => {
+  try {
+    const content = await readFile(path, 'utf-8')
+    return fm<Record<string, never>>(content).body.trim()
+  } catch (err) {
+    if (isMissingFileError(err)) return undefined
+    throw err
+  }
+}
+
+const loadDefaultEntityPromptSection = async (
+  entityDir: string,
+  section: (typeof DEFAULT_ENTITY_PROMPT_FILE_SECTIONS)[number]
+) => {
+  for (const fileName of section.fileNames) {
+    const body = await readOptionalMarkdownBody(resolve(entityDir, fileName))
+    if (body == null || body === '') continue
+
+    return `## ${section.heading}\n\n${body}`
+  }
+
+  return undefined
+}
+
+const appendDefaultEntityPromptFiles = async (path: string, body: string) => {
+  if (!ENTITY_DIRECTORY_ENTRY_FILES.has(basename(path).toLowerCase())) return body
+
+  const sections = await Promise.all(
+    DEFAULT_ENTITY_PROMPT_FILE_SECTIONS.map(section => loadDefaultEntityPromptSection(dirname(path), section))
+  )
+
+  return [
+    body.trim(),
+    ...sections
+  ]
+    .filter((section): section is string => section != null && section !== '')
+    .join('\n\n')
+}
+
 const resolveDisplayName = (name: string, scope?: string) => (
   scope != null && scope.trim() !== '' ? `${scope}/${name}` : name
 )
 
+const toStringList = (value: string | string[] | undefined) => {
+  if (typeof value === 'string' && value.trim() !== '') {
+    return [value.trim()]
+  }
+
+  if (!Array.isArray(value)) return [] as string[]
+
+  return value
+    .filter((item): item is string => typeof item === 'string' && item.trim() !== '')
+    .map(item => item.trim())
+}
+
+const resolveRealHomeDir = (env: NodeJS.ProcessEnv) => {
+  const value = env.__VF_PROJECT_REAL_HOME__?.trim() || env.HOME?.trim()
+  if (value == null || value === '') return undefined
+  return resolve(value)
+}
+
+const warnInvalidHomeSkillRoot = (root: string) => {
+  console.warn(
+    `[vibe-forge] Ignoring invalid skills.homeBridge root "${root}". ` +
+      'Use an absolute path or a path starting with "~".'
+  )
+}
+
+const resolveHomeBridgeConfig = (configs: [Config?, Config?]) => {
+  const [config, userConfig] = configs
+  const projectHomeBridge = isLegacySkillsConfig(config?.skills) ? config.skills.homeBridge : undefined
+  const userHomeBridge = isLegacySkillsConfig(userConfig?.skills) ? userConfig.skills.homeBridge : undefined
+
+  return {
+    enabled: userHomeBridge?.enabled ?? projectHomeBridge?.enabled ?? true,
+    roots: toStringList(userHomeBridge?.roots ?? projectHomeBridge?.roots)
+  }
+}
+
+const resolveHomeSkillRoots = (configs: [Config?, Config?], env: NodeJS.ProcessEnv = process.env) => {
+  const homeBridge = resolveHomeBridgeConfig(configs)
+  if (homeBridge.enabled === false) return [] as string[]
+
+  const realHome = resolveRealHomeDir(env)
+  if (realHome == null) return [] as string[]
+
+  const rawRoots = homeBridge.roots.length > 0 ? homeBridge.roots : Array.from(DEFAULT_HOME_SKILL_ROOTS)
+  const roots: string[] = []
+  const seen = new Set<string>()
+
+  for (const rawRoot of rawRoots) {
+    let resolvedRoot: string | undefined
+
+    if (rawRoot === '~') {
+      resolvedRoot = realHome
+    } else if (rawRoot.startsWith('~/')) {
+      resolvedRoot = resolve(realHome, rawRoot.slice(2))
+    } else if (isAbsolute(rawRoot)) {
+      resolvedRoot = resolve(rawRoot)
+    } else if (homeBridge.roots.length > 0) {
+      warnInvalidHomeSkillRoot(rawRoot)
+    }
+
+    if (resolvedRoot == null || seen.has(resolvedRoot)) continue
+    seen.add(resolvedRoot)
+    roots.push(resolvedRoot)
+  }
+
+  return roots
+}
+
 const loadWorkspaceConfig = async (cwd: string) => (
   loadConfig({
     cwd,
@@ -73,6 +219,15 @@ const parseFrontmatterDocument = async <TDefinition extends object>(
   }
 }
 
+const parseEntityMarkdownDocument = async (path: string): Promise<Definition<Entity>> => {
+  const definition = await parseFrontmatterDocument<Entity>(path)
+
+  return {
+    ...definition,
+    body: await appendDefaultEntityPromptFiles(path, definition.body)
+  }
+}
+
 const parseEntityIndexJson = async (path: string): Promise<Definition<Entity>> => {
   const raw = JSON.parse(await readFile(path, 'utf-8')) as Record<string, unknown>
   const promptPath = typeof raw.promptPath === 'string'
@@ -86,7 +241,7 @@ const parseEntityIndexJson = async (path: string): Promise<Definition<Entity>> =
 
   return {
     path,
-    body: prompt,
+    body: await appendDefaultEntityPromptFiles(path, prompt),
     attributes: raw as Entity
   }
 }
@@ -109,6 +264,7 @@ const createDocumentAsset = <
   origin: 'workspace' | 'plugin'
   scope?: string
   instance?: ResolvedPluginInstance
+  resolvedBy?: string
 }) => {
   const name = ({
     rule: resolveDocumentName,
@@ -130,7 +286,7 @@ const createDocumentAsset = <
     sourcePath: params.definition.path,
     instancePath: params.instance?.instancePath,
     packageId: params.instance?.packageId,
-    resolvedBy: params.instance?.resolvedBy,
+    resolvedBy: params.resolvedBy ?? params.instance?.resolvedBy,
     taskOverlaySource: params.instance?.overlaySource,
     payload: {
       definition: params.definition
@@ -238,6 +394,19 @@ const scanWorkspaceDocuments = async (cwd: string) => {
   }
 }
 
+const scanHomeSkillDocuments = async (configs: [Config?, Config?]) => {
+  const roots = resolveHomeSkillRoots(configs)
+  if (roots.length === 0) return [] as string[]
+
+  const scans = await Promise.all(
+    roots.map(async root => (
+      await glob(['*/SKILL.md'], { cwd: root, absolute: true }).catch(() => [] as string[])
+    ))
+  )
+
+  return scans.flatMap(paths => [...paths].sort((left, right) => left.localeCompare(right)))
+}
+
 const scanInstanceDocuments = async (instance: ResolvedPluginInstance) => {
   const assets = instance.manifest?.assets
   const resolveAssetRoot = (dir: string | undefined, fallback: string) => resolve(instance.rootDir, dir ?? fallback)
@@ -326,6 +495,24 @@ const assertNoDocumentConflicts = (
   }
 }
 
+const mergeSkillAssets = (assets: SkillAsset[]) => {
+  const directAssets = assets.filter(asset => asset.resolvedBy !== HOME_BRIDGE_RESOLVED_BY)
+  const bridgedAssets = assets.filter(asset => asset.resolvedBy === HOME_BRIDGE_RESOLVED_BY)
+
+  assertNoDocumentConflicts(directAssets)
+
+  const seen = new Set(directAssets.map(asset => asset.displayName))
+  const merged = [...directAssets]
+
+  for (const asset of bridgedAssets) {
+    if (seen.has(asset.displayName)) continue
+    seen.add(asset.displayName)
+    merged.push(asset)
+  }
+
+  return merged
+}
+
 const assertNoMcpConflicts = (
   assets: Array<Extract<WorkspaceAsset, { kind: 'mcpServer' }>>
 ) => {
@@ -345,9 +532,12 @@ export async function collectWorkspaceAssets(params: {
   plugins?: PluginConfig
   overlaySource?: string
   includeManagedPlugins?: boolean
+  syncConfiguredSkills?: boolean
+  updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
 }): Promise<{
   assets: WorkspaceAsset[]
+  configs: [Config?, Config?]
   defaultExcludeMcpServers: string[]
   defaultIncludeMcpServers: string[]
   entities: Array<Extract<WorkspaceAsset, { kind: 'entity' }>>
@@ -359,8 +549,16 @@ export async function collectWorkspaceAssets(params: {
   rules: Array<Extract<WorkspaceAsset, { kind: 'rule' }>>
   skills: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>
   specs: Array<Extract<WorkspaceAsset, { kind: 'spec' }>>
+  workspaces: Array<Extract<WorkspaceAsset, { kind: 'workspace' }>>
 }> {
   const [config, userConfig] = params.configs ?? await loadWorkspaceConfig(params.cwd)
+  if (params.syncConfiguredSkills === true) {
+    await ensureConfiguredProjectSkills({
+      configs: [config, userConfig],
+      updateInstalledSkills: params.updateConfiguredSkills,
+      workspaceFolder: params.cwd
+    })
+  }
   const managedPluginConfigs = params.includeManagedPlugins === false
     ? undefined
     : toManagedPluginConfig(await listManagedPluginInstalls(params.cwd))
@@ -374,7 +572,10 @@ export async function collectWorkspaceAssets(params: {
     overlaySource: params.overlaySource
   })
 
-  const localScan = await scanWorkspaceDocuments(params.cwd)
+  const [localScan, homeSkillPaths] = await Promise.all([
+    scanWorkspaceDocuments(params.cwd),
+    scanHomeSkillDocuments([config, userConfig])
+  ])
   const flattenedPluginInstances = flattenPluginInstances(pluginInstances)
   const pluginScans = await Promise.all(flattenedPluginInstances.map(instance => scanInstanceDocuments(instance)))
   const pluginOverlayScans = await Promise.all(
@@ -382,35 +583,43 @@ export async function collectWorkspaceAssets(params: {
   )
 
   const assets: WorkspaceAsset[] = []
+  const skillAssets: SkillAsset[] = []
 
   const pushDocumentAssets = async <TKind extends DocumentAssetKind>(
     kind: TKind,
     paths: string[],
     origin: 'workspace' | 'plugin',
     instance?: ResolvedPluginInstance,
-    parser?: (path: string) => Promise<any>
+    parser?: (path: string) => Promise<any>,
+    resolvedBy?: string
   ) => {
     const definitions = await Promise.all(paths.map(path => (
       parser != null ? parser(path) : parseFrontmatterDocument(path)
     )))
-    assets.push(
-      ...definitions.map(definition =>
-        createDocumentAsset({
-          cwd: params.cwd,
-          kind,
-          definition,
-          origin,
-          scope: instance?.scope,
-          instance
-        })
-      )
+    const createdAssets = definitions.map(definition =>
+      createDocumentAsset({
+        cwd: params.cwd,
+        kind,
+        definition,
+        origin,
+        scope: instance?.scope,
+        instance,
+        resolvedBy
+      })
     )
+
+    if (kind === 'skill') {
+      skillAssets.push(...createdAssets as SkillAsset[])
+      return
+    }
+
+    assets.push(...createdAssets)
   }
 
   await pushDocumentAssets('rule', localScan.rulePaths, 'workspace')
   await pushDocumentAssets('skill', localScan.skillPaths, 'workspace')
   await pushDocumentAssets('spec', localScan.specPaths, 'workspace')
-  await pushDocumentAssets('entity', localScan.entityDocPaths, 'workspace')
+  await pushDocumentAssets('entity', localScan.entityDocPaths, 'workspace', undefined, parseEntityMarkdownDocument)
   await pushDocumentAssets('entity', localScan.entityJsonPaths, 'workspace', undefined, parseEntityIndexJson)
 
   for (let index = 0; index < flattenedPluginInstances.length; index++) {
@@ -419,9 +628,13 @@ export async function collectWorkspaceAssets(params: {
     await pushDocumentAssets('rule', scan.rulePaths, 'plugin', instance)
     await pushDocumentAssets('skill', scan.skillPaths, 'plugin', instance)
     await pushDocumentAssets('spec', scan.specPaths, 'plugin', instance)
-    await pushDocumentAssets('entity', scan.entityDocPaths, 'plugin', instance)
+    await pushDocumentAssets('entity', scan.entityDocPaths, 'plugin', instance, parseEntityMarkdownDocument)
     await pushDocumentAssets('entity', scan.entityJsonPaths, 'plugin', instance, parseEntityIndexJson)
   }
+  await pushDocumentAssets('skill', homeSkillPaths, 'workspace', undefined, undefined, HOME_BRIDGE_RESOLVED_BY)
+
+  const skills = mergeSkillAssets(skillAssets)
+  assets.push(...skills)
 
   const mcpAssets = new Map<string, Extract<WorkspaceAsset, { kind: 'mcpServer' }>>()
   const addMcpAsset = (
@@ -507,6 +720,12 @@ export async function collectWorkspaceAssets(params: {
     .map(instance => createHookPluginAsset(instance))
   assets.push(...hookPlugins)
 
+  const workspaces = await resolveConfiguredWorkspaceAssets({
+    cwd: params.cwd,
+    configs: [config, userConfig]
+  })
+  assets.push(...workspaces)
+
   const opencodeOverlayAssets = flattenedPluginInstances.flatMap((instance, index) => (
     pluginOverlayScans[index].map((entry) =>
       createOpenCodeOverlayAsset({
@@ -528,13 +747,13 @@ export async function collectWorkspaceAssets(params: {
   const entities = assets.filter((asset): asset is Extract<WorkspaceAsset, { kind: 'entity' }> =>
     asset.kind === 'entity'
   )
-  const skills = assets.filter((asset): asset is Extract<WorkspaceAsset, { kind: 'skill' }> => asset.kind === 'skill')
 
-  assertNoDocumentConflicts([...rules, ...specs, ...entities, ...skills])
+  assertNoDocumentConflicts([...rules, ...specs, ...entities])
   assertNoMcpConflicts(Array.from(mcpAssets.values()))
 
   return {
     assets,
+    configs: [config, userConfig],
     defaultExcludeMcpServers: [
       ...(config?.defaultExcludeMcpServers ?? []),
       ...(userConfig?.defaultExcludeMcpServers ?? [])
@@ -551,6 +770,7 @@ export async function collectWorkspaceAssets(params: {
     pluginInstances,
     rules,
     skills,
-    specs
+    specs,
+    workspaces
   }
 }

package/src/bundle.ts

@@ -8,12 +8,15 @@ export async function resolveWorkspaceAssetBundle(params: {
   plugins?: PluginConfig
   overlaySource?: string
   includeManagedPlugins?: boolean
+  syncConfiguredSkills?: boolean
+  updateConfiguredSkills?: boolean
   useDefaultVibeForgeMcpServer?: boolean
 }): Promise<WorkspaceAssetBundle> {
   const collected = await collectWorkspaceAssets(params)
 
   return {
     cwd: params.cwd,
+    configs: collected.configs,
     pluginConfigs: collected.pluginConfigs,
     pluginInstances: collected.pluginInstances,
     assets: collected.assets,
@@ -21,6 +24,7 @@ export async function resolveWorkspaceAssetBundle(params: {
     specs: collected.specs,
     entities: collected.entities,
     skills: collected.skills,
+    workspaces: collected.workspaces,
     mcpServers: collected.mcpServers,
     hookPlugins: collected.hookPlugins,
     opencodeOverlayAssets: collected.opencodeOverlayAssets,