@vibe-forge/workspace-assets 2.0.0 → 2.0.2

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 {
@@ -28,10 +28,13 @@ import {
   resolveSkillIdentifier,
   resolveSpecIdentifier
 } from '@vibe-forge/definition-core'
+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 +53,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 = config?.skills?.homeBridge
+  const userHomeBridge = userConfig?.skills?.homeBridge
+
+  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 +213,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 +235,7 @@ const parseEntityIndexJson = async (path: string): Promise<Definition<Entity>> =
 
   return {
     path,
-    body: prompt,
+    body: await appendDefaultEntityPromptFiles(path, prompt),
     attributes: raw as Entity
   }
 }
@@ -109,6 +258,7 @@ const createDocumentAsset = <
   origin: 'workspace' | 'plugin'
   scope?: string
   instance?: ResolvedPluginInstance
+  resolvedBy?: string
 }) => {
   const name = ({
     rule: resolveDocumentName,
@@ -130,7 +280,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 +388,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 +489,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' }>>
 ) => {
@@ -348,6 +529,7 @@ export async function collectWorkspaceAssets(params: {
   useDefaultVibeForgeMcpServer?: boolean
 }): Promise<{
   assets: WorkspaceAsset[]
+  configs: [Config?, Config?]
   defaultExcludeMcpServers: string[]
   defaultIncludeMcpServers: string[]
   entities: Array<Extract<WorkspaceAsset, { kind: 'entity' }>>
@@ -359,6 +541,7 @@ 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)
   const managedPluginConfigs = params.includeManagedPlugins === false
@@ -374,7 +557,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 +568,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 +613,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 +705,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 +732,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 +755,7 @@ export async function collectWorkspaceAssets(params: {
     pluginInstances,
     rules,
     skills,
-    specs
+    specs,
+    workspaces
   }
 }

package/src/bundle.ts

@@ -14,6 +14,7 @@ export async function resolveWorkspaceAssetBundle(params: {
 
   return {
     cwd: params.cwd,
+    configs: collected.configs,
     pluginConfigs: collected.pluginConfigs,
     pluginInstances: collected.pluginInstances,
     assets: collected.assets,
@@ -21,6 +22,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,

package/src/home-bridge.ts

@@ -0,0 +1 @@
+export const HOME_BRIDGE_RESOLVED_BY = 'home-bridge'

package/src/index.ts

@@ -1,3 +1,6 @@
 export { buildAdapterAssetPlan } from './adapter-asset-plan'
+export { resolveWorkspaceAssetSource } from './asset-source'
 export { resolveWorkspaceAssetBundle } from './bundle'
+export { HOME_BRIDGE_RESOLVED_BY } from './home-bridge'
 export { resolvePromptAssetSelection } from './prompt-selection'
+export { findWorkspaceAsset, resolveConfiguredWorkspaceAssets } from './workspaces'

package/src/prompt-builders.ts

@@ -7,6 +7,8 @@ import {
 import type { Definition, Entity, Rule, Skill, Spec } from '@vibe-forge/types'
 import { CANONICAL_VIBE_FORGE_MCP_SERVER_NAME, resolvePromptPath } from '@vibe-forge/utils'
 
+import { buildManagedTaskToolGuidance } from './task-tool-guidance'
+
 const toMarkdownBlockquote = (content: string) => (
   content
     .trim()
@@ -165,6 +167,7 @@ export const generateSpecRoutePrompt = (
 }
 
 export const generateEntitiesRoutePrompt = (entities: Definition<Entity>[]) => {
+  const taskToolGuidance = buildManagedTaskToolGuidance(CANONICAL_VIBE_FORGE_MCP_SERVER_NAME)
   return (
     '<system-prompt>\n' +
     'The project includes the following entities:\n' +
@@ -179,6 +182,7 @@ export const generateEntitiesRoutePrompt = (entities: Definition<Entity>[]) => {
         .join('')
     }\n` +
     `When solving user problems, you may specify entities through \`${CANONICAL_VIBE_FORGE_MCP_SERVER_NAME}.StartTasks\` as needed and have them coordinate multiple entity types to complete the work; use \`${CANONICAL_VIBE_FORGE_MCP_SERVER_NAME}.GetTaskInfo\` and \`wait\` to track progress.\n` +
+    `${taskToolGuidance}\n` +
     '</system-prompt>\n'
   )
 }

package/src/prompt-selection.ts

@@ -1,10 +1,13 @@
+/* eslint-disable max-lines -- prompt asset selection coordinates routing, overlays, and dependency expansion */
 import type {
   Definition,
+  Entity,
   Filter,
   PluginOverlayConfig,
   Rule,
   RuleReference,
   SkillSelection,
+  Spec,
   WorkspaceAsset,
   WorkspaceAssetBundle,
   WorkspaceMcpSelection,
@@ -23,14 +26,17 @@ import {
 import {
   definitionWithResolvedName,
   pickDocumentAsset,
+  resolveEntityInheritance,
   resolveExcludedSkillRefs,
   resolveIncludedSkillRefs,
   resolveNamedAssets,
   resolvePluginOverlay,
   resolveRuleSelection,
-  resolveSelectedSkillAssets,
+  resolveSelectedSkillAssetsWithDependencies,
   toDocumentDefinitions
 } from './selection-internal'
+import { expandSkillAssetDependenciesWithRegistry } from './skill-dependencies'
+import { generateWorkspaceRoutePrompt } from './workspace-prompt'
 
 export async function resolvePromptAssetSelection(params: {
   bundle: WorkspaceAssetBundle
@@ -57,6 +63,8 @@ export async function resolvePromptAssetSelection(params: {
   let targetToolsFilter: Filter | undefined
   let targetMcpServersFilter: Filter | undefined
   let targetInstancePath: string | undefined
+  let targetAssetIds: string[] = []
+  let targetDefinition: Definition<Entity | Spec> | undefined
 
   if (params.type && params.name) {
     const baseTarget = params.type === 'spec'
@@ -77,18 +85,30 @@ export async function resolvePromptAssetSelection(params: {
     }
 
     pinnedTargetAsset = baseTarget
-    targetBody = baseTarget.payload.definition.body
-    targetToolsFilter = baseTarget.payload.definition.attributes.tools
-    targetMcpServersFilter = baseTarget.payload.definition.attributes.mcpServers
+    if (params.type === 'entity') {
+      const resolvedEntity = resolveEntityInheritance(
+        effectiveBundle,
+        baseTarget as Extract<WorkspaceAsset, { kind: 'entity' }>
+      )
+      targetDefinition = resolvedEntity.definition
+      targetAssetIds = resolvedEntity.assetIds
+    } else {
+      targetDefinition = baseTarget.payload.definition
+      targetAssetIds = [baseTarget.id]
+    }
+    targetBody = targetDefinition.body
+    targetToolsFilter = targetDefinition.attributes.tools
+    targetMcpServersFilter = targetDefinition.attributes.mcpServers
     targetInstancePath = baseTarget.instancePath
     options.assetBundle = effectiveBundle
   }
 
-  const selectedSkillAssets = resolveSelectedSkillAssets(effectiveBundle.skills, params.input?.skills)
+  const selectedSkillAssets = await resolveSelectedSkillAssetsWithDependencies(effectiveBundle, params.input?.skills)
   const useNativeProjectSkills = supportsNativeProjectSkills(params.adapter)
   const promptAssetIds = new Set<string>([
     ...effectiveBundle.rules.map(asset => asset.id),
     ...effectiveBundle.specs.map(asset => asset.id),
+    ...effectiveBundle.workspaces.map(asset => asset.id),
     ...(useNativeProjectSkills ? [] : selectedSkillAssets.map(asset => asset.id)),
     ...(params.type !== 'entity' ? effectiveBundle.entities.map(asset => asset.id) : [])
   ])
@@ -101,8 +121,8 @@ export async function resolvePromptAssetSelection(params: {
   const targetSkillsAssets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>> = []
 
   if (pinnedTargetAsset != null) {
-    promptAssetIds.add(pinnedTargetAsset.id)
-    const attributes = pinnedTargetAsset.payload.definition.attributes
+    targetAssetIds.forEach(assetId => promptAssetIds.add(assetId))
+    const attributes = targetDefinition?.attributes ?? pinnedTargetAsset.payload.definition.attributes
 
     if (attributes.rules != null) {
       const selection = await resolveRuleSelection(
@@ -144,12 +164,18 @@ export async function resolvePromptAssetSelection(params: {
       resolveNamedAssets(effectiveBundle.skills, excludedRefs, targetInstancePath).map(asset => asset.id)
     )
 
-    includedAssets
-      .filter(asset => !excludedIds.has(asset.id))
-      .forEach((asset) => {
-        targetSkillsAssets.push(asset)
-        promptAssetIds.add(asset.id)
-      })
+    const expandedTargetSkills = await expandSkillAssetDependenciesWithRegistry({
+      allAssets: effectiveBundle.assets,
+      configs: effectiveBundle.configs ?? [undefined, undefined],
+      cwd: effectiveBundle.cwd,
+      excludedIds,
+      selectedAssets: includedAssets,
+      skillAssets: effectiveBundle.skills
+    })
+    expandedTargetSkills.forEach((asset) => {
+      targetSkillsAssets.push(asset)
+      promptAssetIds.add(asset.id)
+    })
   }
 
   const rules = Array.from(ruleDefinitions.values())
@@ -162,11 +188,13 @@ export async function resolvePromptAssetSelection(params: {
     : []
   const skills = toDocumentDefinitions(selectedSkillAssets)
   const specs = toDocumentDefinitions(effectiveBundle.specs)
+  const workspaces = effectiveBundle.workspaces.map(asset => asset.payload)
 
   options.systemPrompt = [
     generateRulesPrompt(effectiveBundle.cwd, rules),
     generateSkillsPrompt(effectiveBundle.cwd, targetSkills),
     generateEntitiesRoutePrompt(entities),
+    generateWorkspaceRoutePrompt(effectiveBundle.cwd, workspaces),
     useNativeProjectSkills ? '' : generateSkillsRoutePrompt(effectiveBundle.cwd, routedSkills),
     generateSpecRoutePrompt(specs, { active: params.type === 'spec' }),
     targetBody
@@ -174,12 +202,8 @@ export async function resolvePromptAssetSelection(params: {
     .filter(section => section !== '')
     .join('\n\n')
 
-  if (targetToolsFilter != null) {
-    options.tools = targetToolsFilter
-  }
-  if (targetMcpServersFilter != null) {
-    options.mcpServers = targetMcpServersFilter
-  }
+  if (targetToolsFilter != null) options.tools = targetToolsFilter
+  if (targetMcpServersFilter != null) options.mcpServers = targetMcpServersFilter
   options.promptAssetIds = Array.from(promptAssetIds)
 
   return [
@@ -189,6 +213,7 @@ export async function resolvePromptAssetSelection(params: {
       entities,
       skills,
       specs,
+      workspaces,
       targetBody,
       promptAssetIds: Array.from(promptAssetIds)
     },