@vibe-forge/workspace-assets 0.8.0

package/AGENTS.md

@@ -0,0 +1,38 @@
+# Workspace Assets 包说明
+
+`@vibe-forge/workspace-assets` 承载 workspace asset bundle 发现、prompt asset 选择与 adapter asset plan 组装。
+
+## 什么时候先看这里
+
+- `.ai/rules`、`.ai/specs`、`.ai/entities`、`.ai/skills` 没有被正确投影到 workspace bundle
+- 默认/显式 MCP server 选择结果不对
+- promptAssetIds、system prompt 资产选择不对
+- adapter native asset plan 或 opencode overlay 异常
+
+## 入口
+
+- `src/bundle.ts`
+  - `resolveWorkspaceAssetBundle()`
+- `src/prompt-selection.ts`
+  - `resolvePromptAssetSelection()`
+- `src/adapter-asset-plan.ts`
+  - `buildAdapterAssetPlan()`
+- `__tests__/workspace-assets.spec.ts`
+
+## 当前边界
+
+- 本包负责：
+  - workspace asset bundle 组装
+  - prompt asset 选择
+  - adapter asset plan 组装
+- 本包不负责：
+  - 定义文档发现与解析
+  - cache 存储
+  - task 生命周期编排
+
+## 维护约定
+
+- 只维护 workspace asset 领域逻辑；定义文档读取留在 `@vibe-forge/definition-loader`，cache 留在 `@vibe-forge/utils`。
+- 文档路径规范化与命名规则复用 `@vibe-forge/utils/document-path`，不要在本包重复维护。
+- 共享 contract 继续依赖 `@vibe-forge/types`，不要把 task / hooks / mcp 逻辑反向塞进来。
+- 新增 asset 类型、prompt 选择规则或 adapter 投影时，先补 `__tests__/workspace-assets.spec.ts`。

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Vibe-Forge.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__tests__/workspace-assets.spec.ts

@@ -0,0 +1,279 @@
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import process from 'node:process'
+
+import { afterEach, describe, expect, it } from 'vitest'
+
+import {
+  buildAdapterAssetPlan,
+  resolvePromptAssetSelection,
+  resolveWorkspaceAssetBundle
+} from '#~/index.js'
+
+const tempDirs: string[] = []
+
+const createWorkspace = async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'workspace-assets-'))
+  tempDirs.push(dir)
+  return dir
+}
+
+const writeDocument = async (filePath: string, content: string) => {
+  await mkdir(dirname(filePath), { recursive: true })
+  await writeFile(filePath, content)
+}
+
+afterEach(async () => {
+  await Promise.all(tempDirs.splice(0).map(dir => rm(dir, { recursive: true, force: true })))
+})
+
+describe('workspace assets', () => {
+  it('prefers project prompt assets over plugin assets with the same identifier', async () => {
+    const workspace = await createWorkspace()
+
+    await writeDocument(
+      join(workspace, '.ai/specs/release.md'),
+      '---\ndescription: 项目发布流程\n---\n执行项目发布'
+    )
+    await writeDocument(
+      join(workspace, '.ai/plugins/demo/specs/release/index.md'),
+      '---\ndescription: 插件发布流程\n---\n执行插件发布'
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+    const [data, resolvedOptions] = await resolvePromptAssetSelection({
+      bundle,
+      type: 'spec',
+      name: 'release'
+    })
+
+    expect(data.targetBody).toContain('执行项目发布')
+    expect(data.targetBody).not.toContain('执行插件发布')
+    expect(data.specs).toHaveLength(1)
+    expect(resolvedOptions.systemPrompt).toContain('项目发布流程')
+    expect(resolvedOptions.systemPrompt).not.toContain('插件发布流程')
+    expect(resolvedOptions.promptAssetIds).toEqual(
+      expect.arrayContaining([
+        'spec:.ai/specs/release.md'
+      ])
+    )
+  })
+
+  it('treats enabledPlugins as a global asset switch', async () => {
+    const workspace = await createWorkspace()
+
+    await writeDocument(
+      join(workspace, '.ai.config.json'),
+      JSON.stringify({
+        plugins: {
+          logger: {}
+        },
+        enabledPlugins: {
+          logger: false,
+          demo: false
+        }
+      })
+    )
+    await writeDocument(
+      join(workspace, '.ai/plugins/demo/skills/research/SKILL.md'),
+      '---\ndescription: 检索资料\n---\n阅读 README.md'
+    )
+    await writeDocument(
+      join(workspace, '.ai/plugins/demo/rules/review.md'),
+      '---\ndescription: 评审规则\n---\n必须检查风险'
+    )
+    await writeDocument(
+      join(workspace, '.ai/plugins/demo/mcp/browser.json'),
+      JSON.stringify({ command: 'npx', args: ['browser-server'] })
+    )
+    await writeDocument(
+      join(workspace, '.ai/plugins/demo/opencode/commands/review.md'),
+      '# review'
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [{
+        plugins: {
+          logger: {}
+        },
+        enabledPlugins: {
+          logger: false,
+          demo: false
+        }
+      }, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(bundle.skills).toHaveLength(0)
+    expect(bundle.rules).toHaveLength(0)
+    expect(Object.keys(bundle.mcpServers)).toHaveLength(0)
+    expect(bundle.hookPlugins).toHaveLength(0)
+    expect(bundle.assets.some((asset: (typeof bundle.assets)[number]) => asset.pluginId === 'demo' && asset.enabled))
+      .toBe(false)
+  })
+
+  it('builds codex diagnostics for prompt, mcp, native hooks, and unsupported claude native plugins', async () => {
+    const workspace = await createWorkspace()
+
+    await writeDocument(
+      join(workspace, '.ai.config.json'),
+      JSON.stringify({
+        plugins: {
+          logger: {}
+        },
+        enabledPlugins: {
+          logger: true
+        },
+        mcpServers: {
+          docs: {
+            command: 'npx',
+            args: ['docs-server']
+          }
+        }
+      })
+    )
+    await writeDocument(
+      join(workspace, '.ai/skills/research/SKILL.md'),
+      '---\ndescription: 检索资料\n---\n阅读 README.md'
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [{
+        plugins: {
+          logger: {}
+        },
+        enabledPlugins: {
+          logger: true
+        },
+        mcpServers: {
+          docs: {
+            command: 'npx',
+            args: ['docs-server']
+          }
+        }
+      }, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+    const [, resolvedOptions] = await resolvePromptAssetSelection({
+      bundle,
+      type: undefined,
+      name: undefined,
+      input: {
+        skills: {
+          include: ['research']
+        }
+      }
+    })
+    const plan = buildAdapterAssetPlan({
+      adapter: 'codex',
+      bundle,
+      options: {
+        promptAssetIds: resolvedOptions.promptAssetIds,
+        mcpServers: resolvedOptions.mcpServers,
+        skills: {
+          include: ['research']
+        }
+      }
+    })
+
+    expect(plan.mcpServers).toHaveProperty('docs')
+    expect(plan.native.codexHooks?.supportedEvents).toEqual([
+      'SessionStart',
+      'UserPromptSubmit',
+      'PreToolUse',
+      'PostToolUse',
+      'Stop'
+    ])
+    expect(plan.diagnostics).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        adapter: 'codex',
+        status: 'prompt'
+      }),
+      expect.objectContaining({
+        adapter: 'codex',
+        status: 'native',
+        assetId: 'hookPlugin:project:logger'
+      }),
+      expect.objectContaining({
+        adapter: 'codex',
+        status: 'translated',
+        assetId: 'mcpServer:project:docs'
+      }),
+      expect.objectContaining({
+        adapter: 'codex',
+        status: 'skipped',
+        assetId: 'nativePlugin:claude-code:logger'
+      })
+    ]))
+  })
+
+  it('builds opencode overlays for skills and native commands', async () => {
+    const workspace = await createWorkspace()
+
+    await writeDocument(
+      join(workspace, '.ai/skills/research/SKILL.md'),
+      '---\ndescription: 检索资料\n---\n阅读 README.md'
+    )
+    await writeDocument(
+      join(workspace, '.ai/plugins/demo/opencode/commands/review.md'),
+      '# review'
+    )
+
+    const bundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+    const plan = buildAdapterAssetPlan({
+      adapter: 'opencode',
+      bundle,
+      options: {
+        skills: {
+          include: ['research']
+        }
+      }
+    })
+
+    expect(plan.overlays).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        kind: 'skill',
+        targetPath: 'skills/research'
+      }),
+      expect.objectContaining({
+        kind: 'command',
+        targetPath: 'commands/review.md'
+      })
+    ]))
+  })
+
+  it('adds the built-in Vibe Forge MCP server when enabled and omits it when disabled', async () => {
+    const workspace = await createWorkspace()
+
+    const enabledBundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: true
+    })
+
+    expect(enabledBundle.mcpServers).toHaveProperty('vibe-forge')
+    expect(enabledBundle.mcpServers['vibe-forge']?.payload.config).toEqual(expect.objectContaining({
+      command: process.execPath,
+      args: [expect.stringMatching(/packages\/mcp\/cli\.js$/)]
+    }))
+
+    const disabledBundle = await resolveWorkspaceAssetBundle({
+      cwd: workspace,
+      configs: [undefined, undefined],
+      useDefaultVibeForgeMcpServer: false
+    })
+
+    expect(disabledBundle.mcpServers).not.toHaveProperty('vibe-forge')
+  })
+})

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@vibe-forge/workspace-assets",
+  "version": "0.8.0",
+  "description": "Workspace asset resolution and adapter asset planning for Vibe Forge",
+  "imports": {
+    "#~/*.js": {
+      "__vibe-forge__": {
+        "default": "./src/*.ts"
+      },
+      "default": {
+        "import": "./dist/*.mjs",
+        "require": "./dist/*.js"
+      }
+    }
+  },
+  "exports": {
+    ".": {
+      "__vibe-forge__": {
+        "default": "./src/index.ts"
+      },
+      "default": {
+        "import": "./dist/index.mjs",
+        "require": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.3",
+    "js-yaml": "^4.1.1",
+    "@vibe-forge/config": "^0.8.0",
+    "@vibe-forge/definition-loader": "^0.8.0",
+    "@vibe-forge/utils": "^0.8.0",
+    "@vibe-forge/types": "^0.8.0"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9"
+  },
+  "scripts": {
+    "test": "pnpm -C ../.. exec vitest run --workspace vitest.workspace.ts --project bundler packages/workspace-assets/__tests__"
+  }
+}

package/src/adapter-asset-plan.ts

@@ -0,0 +1,174 @@
+import { basename, dirname } from 'node:path'
+
+import type {
+  AdapterAssetPlan,
+  AssetDiagnostic,
+  WorkspaceAssetAdapter,
+  WorkspaceAssetBundle,
+  WorkspaceMcpSelection,
+  WorkspaceSkillSelection
+} from '@vibe-forge/types'
+
+import { filterSkillAssets } from './document-assets'
+import { isOpenCodeOverlayAsset } from './internal-types'
+
+const resolveMcpServerSelection = (
+  bundle: WorkspaceAssetBundle,
+  selection: WorkspaceMcpSelection | undefined
+) => {
+  const include = selection?.include ?? (
+    bundle.defaultIncludeMcpServers.length > 0 ? bundle.defaultIncludeMcpServers : undefined
+  )
+  const exclude = selection?.exclude ?? (
+    bundle.defaultExcludeMcpServers.length > 0 ? bundle.defaultExcludeMcpServers : undefined
+  )
+
+  return {
+    include,
+    exclude
+  }
+}
+
+export function buildAdapterAssetPlan(params: {
+  adapter: WorkspaceAssetAdapter
+  bundle: WorkspaceAssetBundle
+  options: {
+    mcpServers?: WorkspaceMcpSelection
+    skills?: WorkspaceSkillSelection
+    promptAssetIds?: string[]
+  }
+}): AdapterAssetPlan {
+  const diagnostics: AssetDiagnostic[] = []
+  const promptAssetIdSet = new Set(params.options.promptAssetIds ?? [])
+  const mcpSelection = resolveMcpServerSelection(params.bundle, params.options.mcpServers)
+  const selectedMcpServerNames = Object.keys(params.bundle.mcpServers).filter((name) => {
+    if (mcpSelection.include != null && !mcpSelection.include.includes(name)) return false
+    if (mcpSelection.exclude?.includes(name)) return false
+    return true
+  })
+  const mcpServers = Object.fromEntries(
+    selectedMcpServerNames.map((name) => [name, params.bundle.mcpServers[name].payload.config])
+  )
+
+  for (const assetId of promptAssetIdSet) {
+    diagnostics.push({
+      assetId,
+      adapter: params.adapter,
+      status: 'prompt',
+      reason: 'Mapped into the generated system prompt.'
+    })
+  }
+
+  for (const name of selectedMcpServerNames) {
+    diagnostics.push({
+      assetId: params.bundle.mcpServers[name].id,
+      adapter: params.adapter,
+      status: params.adapter === 'claude-code' ? 'native' : 'translated',
+      reason: params.adapter === 'claude-code'
+        ? 'Mapped into native MCP settings.'
+        : 'Translated into adapter-specific MCP configuration.'
+    })
+  }
+
+  for (const hookPlugin of params.bundle.hookPlugins) {
+    const nativeHookReason = params.adapter === 'claude-code'
+      ? 'Mapped into the isolated Claude Code native hooks bridge under .ai/.mock/.claude/settings.json.'
+      : params.adapter === 'codex'
+        ? 'Mapped into the isolated Codex native hooks bridge for SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, and Stop.'
+        : 'Mapped into the isolated OpenCode native hook plugin bridge under .ai/.mock/.config/opencode/plugins.'
+    diagnostics.push({
+      assetId: hookPlugin.id,
+      adapter: params.adapter,
+      status: 'native',
+      reason: nativeHookReason
+    })
+  }
+
+  const overlays: AdapterAssetPlan['overlays'] = []
+  if (params.adapter === 'opencode') {
+    const skillAssets = filterSkillAssets(params.bundle.skills, params.options.skills)
+    for (const skillAsset of skillAssets) {
+      overlays.push({
+        assetId: skillAsset.id,
+        kind: 'skill',
+        sourcePath: dirname(skillAsset.payload.definition.path),
+        targetPath: `skills/${basename(dirname(skillAsset.payload.definition.path))}`
+      })
+      diagnostics.push({
+        assetId: skillAsset.id,
+        adapter: 'opencode',
+        status: 'native',
+        reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native skill.'
+      })
+    }
+
+    for (const asset of params.bundle.assets) {
+      if (!isOpenCodeOverlayAsset(asset)) continue
+      if (!asset.targets.includes('opencode')) continue
+
+      overlays.push({
+        assetId: asset.id,
+        kind: asset.kind,
+        sourcePath: asset.payload.sourcePath,
+        targetPath: asset.payload.targetSubpath
+      })
+      diagnostics.push({
+        assetId: asset.id,
+        adapter: 'opencode',
+        status: 'native',
+        reason: 'Mirrored into OPENCODE_CONFIG_DIR as a native OpenCode asset.'
+      })
+    }
+  }
+
+  if (params.adapter !== 'claude-code') {
+    for (const asset of params.bundle.assets) {
+      if (asset.kind !== 'nativePlugin' || !asset.enabled || !asset.targets.includes('claude-code')) continue
+      diagnostics.push({
+        assetId: asset.id,
+        adapter: params.adapter,
+        status: 'skipped',
+        reason: 'Claude marketplace plugin settings do not have a native mapping for this adapter.'
+      })
+    }
+  }
+
+  if (params.adapter === 'codex') {
+    for (const asset of params.bundle.assets) {
+      if (!['nativePlugin', 'agent', 'command', 'mode'].includes(asset.kind)) continue
+      if (asset.targets.includes('codex')) continue
+      if (asset.kind === 'nativePlugin' && asset.targets.includes('claude-code')) continue
+      diagnostics.push({
+        assetId: asset.id,
+        adapter: 'codex',
+        status: 'skipped',
+        reason: 'No stable native Codex mapping exists for this asset kind in V1.'
+      })
+    }
+  }
+
+  return {
+    adapter: params.adapter,
+    diagnostics,
+    mcpServers,
+    overlays,
+    native: params.adapter === 'claude-code'
+      ? {
+          enabledPlugins: params.bundle.enabledPlugins,
+          extraKnownMarketplaces: params.bundle.extraKnownMarketplaces
+        }
+      : params.adapter === 'codex' && params.bundle.hookPlugins.length > 0
+        ? {
+            codexHooks: {
+              supportedEvents: [
+                'SessionStart',
+                'UserPromptSubmit',
+                'PreToolUse',
+                'PostToolUse',
+                'Stop'
+              ]
+            }
+          }
+        : {}
+  }
+}

package/src/bundle.ts

@@ -0,0 +1,185 @@
+import process from 'node:process'
+
+import {
+  buildConfigJsonVariables,
+  DEFAULT_VIBE_FORGE_MCP_SERVER_NAME,
+  loadConfig,
+  resolveDefaultVibeForgeMcpServerConfig
+} from '@vibe-forge/config'
+import { DefinitionLoader } from '@vibe-forge/definition-loader'
+import type {
+  Config,
+  WorkspaceAsset,
+  WorkspaceAssetBundle
+} from '@vibe-forge/types'
+import {
+  resolveDocumentName,
+  resolveSpecIdentifier
+} from '@vibe-forge/utils'
+
+import {
+  createDocumentAsset,
+  dedupeDocumentAssets,
+  dedupeDocumentAssetsByIdentifier,
+  resolveRuleIdentifier,
+  resolveSkillIdentifier
+} from './document-assets'
+import { mergeRecord, uniqueValues } from './helpers'
+import {
+  createClaudeNativePluginAssets,
+  createHookPluginAssets,
+  loadOpenCodeOverlayAssets,
+  loadPluginMcpAssets
+} from './plugin-assets'
+
+const readConfigForWorkspace = async (cwd: string) => {
+  return loadConfig<Config>({
+    cwd,
+    jsonVariables: buildConfigJsonVariables(cwd, process.env)
+  })
+}
+
+export async function resolveWorkspaceAssetBundle(params: {
+  cwd: string
+  configs?: [Config?, Config?]
+  useDefaultVibeForgeMcpServer?: boolean
+}): Promise<WorkspaceAssetBundle> {
+  const [config, userConfig] = params.configs ?? await readConfigForWorkspace(params.cwd)
+  const enabledPlugins = mergeRecord(config?.enabledPlugins, userConfig?.enabledPlugins)
+  const extraKnownMarketplaces = mergeRecord(config?.extraKnownMarketplaces, userConfig?.extraKnownMarketplaces)
+  const loader = new DefinitionLoader(params.cwd)
+
+  const [
+    rawRules,
+    rawSpecs,
+    rawEntities,
+    rawSkills,
+    pluginMcpAssets,
+    openCodeOverlayAssets
+  ] = await Promise.all([
+    loader.loadDefaultRules(),
+    loader.loadDefaultSpecs(),
+    loader.loadDefaultEntities(),
+    loader.loadDefaultSkills(),
+    loadPluginMcpAssets(params.cwd, enabledPlugins),
+    loadOpenCodeOverlayAssets(params.cwd, enabledPlugins)
+  ])
+
+  const assets: WorkspaceAsset[] = []
+
+  const rules = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawRules.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'rule', definition })),
+      enabledPlugins
+    ),
+    asset => resolveRuleIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name)
+  )
+  const specs = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawSpecs.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'spec', definition })),
+      enabledPlugins
+    ),
+    asset => resolveSpecIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name)
+  )
+  const entities = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawEntities.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'entity', definition })),
+      enabledPlugins
+    ),
+    asset =>
+      resolveDocumentName(
+        asset.payload.definition.path,
+        asset.payload.definition.attributes.name,
+        ['readme.md', 'index.json']
+      )
+  )
+  const skills = dedupeDocumentAssetsByIdentifier(
+    dedupeDocumentAssets(
+      rawSkills.map((definition) => createDocumentAsset({ cwd: params.cwd, kind: 'skill', definition })),
+      enabledPlugins
+    ),
+    asset => resolveSkillIdentifier(asset.payload.definition.path, asset.payload.definition.attributes.name)
+  )
+
+  assets.push(...rules, ...specs, ...entities, ...skills)
+
+  const mcpServers = new Map<string, Extract<WorkspaceAsset, { kind: 'mcpServer' }>>()
+  if (params.useDefaultVibeForgeMcpServer !== false) {
+    const defaultVibeForgeMcpServer = resolveDefaultVibeForgeMcpServerConfig()
+    if (defaultVibeForgeMcpServer != null) {
+      mcpServers.set(DEFAULT_VIBE_FORGE_MCP_SERVER_NAME, {
+        id: `mcpServer:fallback:${DEFAULT_VIBE_FORGE_MCP_SERVER_NAME}`,
+        kind: 'mcpServer',
+        origin: 'fallback',
+        scope: 'adapter',
+        enabled: true,
+        targets: ['claude-code', 'codex', 'opencode'],
+        payload: {
+          name: DEFAULT_VIBE_FORGE_MCP_SERVER_NAME,
+          config: defaultVibeForgeMcpServer
+        }
+      })
+    }
+  }
+  const userMcpServers = userConfig?.mcpServers ?? {}
+  for (const [name, serverConfig] of Object.entries(userMcpServers)) {
+    mcpServers.set(name, {
+      id: `mcpServer:user:${name}`,
+      kind: 'mcpServer',
+      origin: 'config',
+      scope: 'user',
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        name,
+        config: serverConfig
+      }
+    })
+  }
+  for (const asset of pluginMcpAssets) {
+    mcpServers.set(asset.payload.name, asset)
+  }
+  for (const [name, serverConfig] of Object.entries(config?.mcpServers ?? {})) {
+    mcpServers.set(name, {
+      id: `mcpServer:project:${name}`,
+      kind: 'mcpServer',
+      origin: 'config',
+      scope: 'project',
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        name,
+        config: serverConfig
+      }
+    })
+  }
+  assets.push(...mcpServers.values())
+
+  const hookPlugins = [
+    ...createHookPluginAssets(userConfig?.plugins, enabledPlugins, 'user'),
+    ...createHookPluginAssets(config?.plugins, enabledPlugins, 'project')
+  ]
+  const claudeNativePlugins = createClaudeNativePluginAssets(enabledPlugins)
+  assets.push(...hookPlugins, ...claudeNativePlugins, ...openCodeOverlayAssets)
+
+  return {
+    cwd: params.cwd,
+    assets,
+    rules,
+    specs,
+    entities,
+    skills,
+    mcpServers: Object.fromEntries(mcpServers.entries()),
+    hookPlugins,
+    enabledPlugins,
+    extraKnownMarketplaces,
+    defaultIncludeMcpServers: uniqueValues([
+      ...(config?.defaultIncludeMcpServers ?? []),
+      ...(userConfig?.defaultIncludeMcpServers ?? [])
+    ]),
+    defaultExcludeMcpServers: uniqueValues([
+      ...(config?.defaultExcludeMcpServers ?? []),
+      ...(userConfig?.defaultExcludeMcpServers ?? [])
+    ])
+  }
+}

package/src/document-assets.ts

@@ -0,0 +1,201 @@
+import { basename, dirname } from 'node:path'
+
+import { glob } from 'fast-glob'
+import type {
+  RuleReference,
+  SkillSelection,
+  WorkspaceAsset,
+  WorkspaceAssetAdapter,
+  WorkspaceAssetKind,
+  WorkspaceAssetBundle,
+  WorkspaceSkillSelection
+} from '@vibe-forge/types'
+import {
+  normalizePath,
+  resolveDocumentName,
+  resolveRelativePath,
+  resolveSpecIdentifier
+} from '@vibe-forge/utils'
+
+import type { WorkspaceDocumentAsset, WorkspaceDocumentPayload } from './internal-types'
+import {
+  assetOriginPriority,
+  isPluginEnabled,
+  resolvePluginIdFromPath,
+  toAssetScope
+} from './helpers'
+
+const isLocalRuleReference = (
+  rule: RuleReference
+): rule is Extract<RuleReference, { path: string }> => (
+  rule != null &&
+  typeof rule === 'object' &&
+  'path' in rule &&
+  typeof rule.path === 'string'
+)
+
+export const createDocumentAsset = <
+  TKind extends Extract<WorkspaceAssetKind, 'rule' | 'spec' | 'entity' | 'skill'>,
+  TDefinition,
+>(
+  params: {
+    cwd: string
+    kind: TKind
+    definition: TDefinition & { path: string }
+    targets?: WorkspaceAssetAdapter[]
+  }
+): Extract<WorkspaceAsset, { kind: TKind }> => {
+  const pluginId = resolvePluginIdFromPath(params.cwd, params.definition.path)
+  const origin: WorkspaceAsset['origin'] = pluginId == null ? 'project' : 'plugin'
+  return {
+    id: `${params.kind}:${resolveRelativePath(params.cwd, params.definition.path)}`,
+    kind: params.kind,
+    pluginId,
+    origin,
+    scope: toAssetScope(origin),
+    enabled: true,
+    targets: params.targets ?? ['claude-code', 'codex', 'opencode'],
+    payload: {
+      definition: params.definition as any,
+      sourcePath: params.definition.path
+    }
+  } as Extract<WorkspaceAsset, { kind: TKind }>
+}
+
+export const dedupeDocumentAssets = <
+  TAsset extends Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>
+>(
+  assets: TAsset[],
+  enabledPlugins: Record<string, boolean>
+) => assets.filter((asset) => isPluginEnabled(enabledPlugins, asset.pluginId))
+
+const compareDocumentAssetPriority = (
+  left: Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>,
+  right: Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>
+) => {
+  const originDiff = assetOriginPriority[left.origin] - assetOriginPriority[right.origin]
+  if (originDiff !== 0) return originDiff
+  return left.payload.definition.path.localeCompare(right.payload.definition.path)
+}
+
+export const dedupeDocumentAssetsByIdentifier = <
+  TAsset extends Extract<WorkspaceAsset, { kind: 'rule' | 'spec' | 'entity' | 'skill' }>
+>(
+  assets: TAsset[],
+  resolveIdentifier: (asset: TAsset) => string
+) => {
+  const selected = new Map<string, TAsset>()
+
+  for (const asset of [...assets].sort(compareDocumentAssetPriority)) {
+    const identifier = resolveIdentifier(asset)
+    if (!selected.has(identifier)) selected.set(identifier, asset)
+  }
+
+  return Array.from(selected.values()).sort(compareDocumentAssetPriority)
+}
+
+export const resolveRuleIdentifier = (
+  path: string,
+  explicitName?: string
+) => resolveDocumentName(path, explicitName)
+
+export const resolveSkillIdentifier = (
+  path: string,
+  explicitName?: string
+) => resolveDocumentName(path, explicitName, ['skill.md'])
+
+export const pickSpecAsset = (
+  bundle: WorkspaceAssetBundle,
+  name: string
+): Extract<WorkspaceAsset, { kind: 'spec' }> | undefined => {
+  const assets = bundle.specs.filter((asset) => {
+    const definition = asset.payload.definition
+    return resolveSpecIdentifier(definition.path, definition.attributes.name) === name
+  })
+  return assets.find(asset => asset.origin === 'project') ?? assets[0]
+}
+
+export const pickEntityAsset = (
+  bundle: WorkspaceAssetBundle,
+  name: string
+): Extract<WorkspaceAsset, { kind: 'entity' }> | undefined => {
+  const assets = bundle.entities.filter((asset) => {
+    const definition = asset.payload.definition
+    const identifier = resolveDocumentName(definition.path, definition.attributes.name, ['readme.md', 'index.json'])
+    return identifier === name
+  })
+  return assets.find(asset => asset.origin === 'project') ?? assets[0]
+}
+
+export const filterSkillAssets = (
+  skills: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>,
+  selection?: WorkspaceSkillSelection
+): Array<Extract<WorkspaceAsset, { kind: 'skill' }>> => {
+  if (selection == null) return skills
+
+  const include = selection.include != null && selection.include.length > 0
+    ? new Set(selection.include)
+    : undefined
+  const exclude = new Set(selection.exclude ?? [])
+
+  return skills.filter((skill) => {
+    const name = basename(dirname(skill.payload.definition.path))
+    return (include == null || include.has(name)) && !exclude.has(name)
+  })
+}
+
+export const dedupeSkillAssets = (
+  skills: Array<Extract<WorkspaceAsset, { kind: 'skill' }>>
+): Array<Extract<WorkspaceAsset, { kind: 'skill' }>> => {
+  const seen = new Set<string>()
+  return skills.filter((skill) => {
+    if (seen.has(skill.payload.definition.path)) return false
+    seen.add(skill.payload.definition.path)
+    return true
+  })
+}
+
+export const resolveRulePatterns = (rules: RuleReference[]) => (
+  rules.flatMap((rule) => {
+    if (typeof rule === 'string') return [rule]
+    if (isLocalRuleReference(rule)) return [rule.path]
+    return []
+  })
+)
+
+export const resolveIncludedSkillNames = (selection: string[] | SkillSelection) => (
+  Array.isArray(selection)
+    ? selection
+    : selection.type === 'include'
+      ? selection.list
+      : []
+)
+
+export const resolveExcludedSkillNames = (selection: string[] | SkillSelection) => (
+  Array.isArray(selection)
+    ? []
+    : selection.type === 'exclude'
+      ? selection.list
+      : []
+)
+
+export const resolveSelectedRuleAssets = async (
+  bundle: WorkspaceAssetBundle,
+  patterns: string[]
+): Promise<Array<Extract<WorkspaceAsset, { kind: 'rule' }>>> => {
+  const matchedPaths = new Set(
+    (await glob(patterns, { cwd: bundle.cwd, absolute: true }))
+      .map(normalizePath)
+  )
+  return bundle.rules.filter((asset) => matchedPaths.has(normalizePath(asset.payload.definition.path)))
+}
+
+export const toDocumentDefinitions = <TDefinition>(
+  assets: Array<WorkspaceDocumentAsset<TDefinition>>
+) => assets.map(asset => asset.payload.definition)
+
+export const toPromptAssetIds = (assets: Array<{ id: string }>) => (
+  Array.from(new Set(assets.map(asset => asset.id)))
+)
+
+export type { WorkspaceDocumentAsset, WorkspaceDocumentPayload }

package/src/helpers.ts

@@ -0,0 +1,35 @@
+import type { WorkspaceAsset } from '@vibe-forge/types'
+import { resolveRelativePath } from '@vibe-forge/utils'
+
+export const resolvePluginIdFromPath = (cwd: string, path: string) => {
+  const relativePath = resolveRelativePath(cwd, path)
+  const match = relativePath.match(/^\.ai\/plugins\/([^/]+)\//)
+  return match?.[1]
+}
+
+export const isPluginEnabled = (
+  enabledPlugins: Record<string, boolean>,
+  pluginId?: string
+) => pluginId == null || enabledPlugins[pluginId] !== false
+
+export const mergeRecord = <T>(left?: Record<string, T>, right?: Record<string, T>) => ({
+  ...(left ?? {}),
+  ...(right ?? {})
+})
+
+export const uniqueValues = (values: string[]) => Array.from(new Set(values.filter(Boolean)))
+
+export const assetOriginPriority: Record<WorkspaceAsset['origin'], number> = {
+  project: 0,
+  plugin: 1,
+  config: 2,
+  fallback: 3
+}
+
+export const toAssetScope = (origin: WorkspaceAsset['origin']): WorkspaceAsset['scope'] => (
+  origin === 'config'
+    ? 'project'
+    : origin === 'fallback'
+      ? 'adapter'
+      : 'workspace'
+)

package/src/index.ts

@@ -0,0 +1,3 @@
+export { buildAdapterAssetPlan } from './adapter-asset-plan'
+export { resolveWorkspaceAssetBundle } from './bundle'
+export { resolvePromptAssetSelection } from './prompt-selection'

package/src/internal-types.ts

@@ -0,0 +1,41 @@
+import type { WorkspaceAsset } from '@vibe-forge/types'
+
+export interface WorkspaceDocumentPayload<TDefinition> {
+  definition: TDefinition
+  sourcePath: string
+}
+
+export interface WorkspaceOverlayPayload {
+  sourcePath: string
+  entryName: string
+  targetSubpath: string
+}
+
+export type WorkspaceOpenCodeOverlayAsset =
+  | (
+    & Extract<WorkspaceAsset, { kind: 'nativePlugin' }>
+    & { payload: WorkspaceOverlayPayload }
+  )
+  | Extract<WorkspaceAsset, { kind: 'agent' | 'command' | 'mode' }>
+
+export type WorkspaceDocumentAsset<TDefinition> =
+  & Extract<
+    WorkspaceAsset,
+    { kind: 'rule' | 'spec' | 'entity' | 'skill' }
+  >
+  & {
+    payload: WorkspaceDocumentPayload<TDefinition & { path: string }>
+  }
+
+export const isOverlayPayload = (payload: unknown): payload is WorkspaceOverlayPayload => (
+  payload != null &&
+  typeof payload === 'object' &&
+  typeof (payload as WorkspaceOverlayPayload).sourcePath === 'string' &&
+  typeof (payload as WorkspaceOverlayPayload).entryName === 'string' &&
+  typeof (payload as WorkspaceOverlayPayload).targetSubpath === 'string'
+)
+
+export const isOpenCodeOverlayAsset = (asset: WorkspaceAsset): asset is WorkspaceOpenCodeOverlayAsset => (
+  (asset.kind === 'nativePlugin' || asset.kind === 'agent' || asset.kind === 'command' || asset.kind === 'mode') &&
+  isOverlayPayload(asset.payload)
+)

package/src/plugin-assets.ts

@@ -0,0 +1,178 @@
+import { readFile } from 'node:fs/promises'
+import { basename, extname } from 'node:path'
+
+import { glob } from 'fast-glob'
+import type { Config, WorkspaceAsset, WorkspaceAssetAdapter } from '@vibe-forge/types'
+import { resolveRelativePath } from '@vibe-forge/utils'
+import yaml from 'js-yaml'
+
+import type { WorkspaceOpenCodeOverlayAsset } from './internal-types'
+import {
+  isPluginEnabled,
+  resolvePluginIdFromPath
+} from './helpers'
+
+const parseStructuredDocument = async (path: string) => {
+  const raw = await readFile(path, 'utf8')
+  const extension = extname(path).toLowerCase()
+  if (extension === '.yaml' || extension === '.yml') {
+    return yaml.load(raw)
+  }
+  return JSON.parse(raw)
+}
+
+export const loadPluginMcpAssets = async (
+  cwd: string,
+  enabledPlugins: Record<string, boolean>
+): Promise<Array<Extract<WorkspaceAsset, { kind: 'mcpServer' }>>> => {
+  const paths = await glob([
+    '.ai/plugins/*/mcp/*.json',
+    '.ai/plugins/*/mcp/*.yaml',
+    '.ai/plugins/*/mcp/*.yml'
+  ], {
+    cwd,
+    absolute: true
+  })
+
+  const entries = await Promise.all(paths.map(async (path) => {
+    const pluginId = resolvePluginIdFromPath(cwd, path)
+    if (!isPluginEnabled(enabledPlugins, pluginId)) return undefined
+
+    const parsed = await parseStructuredDocument(path)
+    if (parsed == null || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined
+
+    const record = parsed as Record<string, unknown>
+    const name = typeof record.name === 'string' && record.name.trim() !== ''
+      ? record.name.trim()
+      : basename(path, extname(path))
+    const { name: _name, ...config } = record
+
+    return {
+      id: `mcpServer:${resolveRelativePath(cwd, path)}`,
+      kind: 'mcpServer',
+      pluginId,
+      origin: 'plugin',
+      scope: 'workspace',
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        name,
+        config: config as NonNullable<Config['mcpServers']>[string]
+      }
+    } satisfies Extract<WorkspaceAsset, { kind: 'mcpServer' }>
+  }))
+
+  return entries.filter((entry): entry is NonNullable<typeof entry> => entry != null)
+}
+
+export const loadOpenCodeOverlayAssets = async (
+  cwd: string,
+  enabledPlugins: Record<string, boolean>
+): Promise<WorkspaceOpenCodeOverlayAsset[]> => {
+  const paths = await glob([
+    '.ai/plugins/*/opencode/plugins/*',
+    '.ai/plugins/*/opencode/agents/*',
+    '.ai/plugins/*/opencode/commands/*',
+    '.ai/plugins/*/opencode/modes/*'
+  ], {
+    cwd,
+    absolute: true,
+    onlyFiles: false
+  })
+
+  return paths
+    .map((path) => {
+      const relativePath = resolveRelativePath(cwd, path)
+      const match = relativePath.match(/^\.ai\/plugins\/([^/]+)\/opencode\/(plugins|agents|commands|modes)\/([^/]+)$/)
+      if (!match) return undefined
+
+      const [, pluginId, rawFolder, entryName] = match
+      if (!isPluginEnabled(enabledPlugins, pluginId)) return undefined
+
+      const base = {
+        pluginId,
+        origin: 'plugin' as const,
+        scope: 'workspace' as const,
+        enabled: true,
+        targets: ['opencode'] as WorkspaceAssetAdapter[],
+        payload: {
+          sourcePath: path,
+          entryName,
+          targetSubpath: `${rawFolder}/${entryName}`
+        }
+      }
+
+      if (rawFolder === 'plugins') {
+        return {
+          id: `nativePlugin:${relativePath}`,
+          kind: 'nativePlugin',
+          ...base
+        } satisfies Extract<WorkspaceAsset, { kind: 'nativePlugin' }>
+      }
+
+      if (rawFolder === 'agents') {
+        return {
+          id: `agent:${relativePath}`,
+          kind: 'agent',
+          ...base
+        } satisfies Extract<WorkspaceAsset, { kind: 'agent' }>
+      }
+
+      if (rawFolder === 'commands') {
+        return {
+          id: `command:${relativePath}`,
+          kind: 'command',
+          ...base
+        } satisfies Extract<WorkspaceAsset, { kind: 'command' }>
+      }
+
+      return {
+        id: `mode:${relativePath}`,
+        kind: 'mode',
+        ...base
+      } satisfies Extract<WorkspaceAsset, { kind: 'mode' }>
+    })
+    .filter((entry): entry is NonNullable<typeof entry> => entry != null)
+}
+
+export const createHookPluginAssets = (
+  config: Config['plugins'],
+  enabledPlugins: Record<string, boolean>,
+  scope: Extract<WorkspaceAsset['scope'], 'project' | 'user'>
+): Array<Extract<WorkspaceAsset, { kind: 'hookPlugin' }>> => {
+  if (config == null || Array.isArray(config)) return [] as Array<Extract<WorkspaceAsset, { kind: 'hookPlugin' }>>
+
+  return Object.entries(config)
+    .filter((entry) => enabledPlugins[entry[0]] !== false)
+    .map(([pluginId, pluginConfig]) => ({
+      id: `hookPlugin:${scope}:${pluginId}`,
+      kind: 'hookPlugin',
+      pluginId,
+      origin: 'config',
+      scope,
+      enabled: true,
+      targets: ['claude-code', 'codex', 'opencode'],
+      payload: {
+        packageName: pluginId,
+        config: pluginConfig
+      }
+    } satisfies Extract<WorkspaceAsset, { kind: 'hookPlugin' }>))
+}
+
+export const createClaudeNativePluginAssets = (
+  enabledPlugins: Record<string, boolean>
+): Array<Extract<WorkspaceAsset, { kind: 'nativePlugin' }>> => {
+  return Object.entries(enabledPlugins).map(([pluginId, enabled]) => ({
+    id: `nativePlugin:claude-code:${pluginId}`,
+    kind: 'nativePlugin',
+    pluginId,
+    origin: 'config',
+    scope: 'project',
+    enabled,
+    targets: ['claude-code'],
+    payload: {
+      name: pluginId,
+      enabled
+    }
+  } satisfies Extract<WorkspaceAsset, { kind: 'nativePlugin' }>))
+}

package/src/prompt-selection.ts

@@ -0,0 +1,151 @@
+import { basename, dirname } from 'node:path'
+
+import { DefinitionLoader } from '@vibe-forge/definition-loader'
+import type {
+  Filter,
+  PromptAssetResolution,
+  ResolvedPromptAssetOptions,
+  WorkspaceAsset,
+  WorkspaceAssetBundle,
+  WorkspaceSkillSelection
+} from '@vibe-forge/types'
+
+import {
+  dedupeSkillAssets,
+  filterSkillAssets,
+  pickEntityAsset,
+  pickSpecAsset,
+  resolveExcludedSkillNames,
+  resolveIncludedSkillNames,
+  resolveRulePatterns,
+  resolveSelectedRuleAssets,
+  toDocumentDefinitions,
+  toPromptAssetIds
+} from './document-assets'
+
+export async function resolvePromptAssetSelection(
+  params: {
+    bundle: WorkspaceAssetBundle
+    type: 'spec' | 'entity' | undefined
+    name?: string
+    input?: {
+      skills?: WorkspaceSkillSelection
+    }
+  }
+): Promise<[PromptAssetResolution, ResolvedPromptAssetOptions]> {
+  const loader = new DefinitionLoader(params.bundle.cwd)
+  const options: ResolvedPromptAssetOptions = {}
+  const systemPromptParts: string[] = []
+
+  const entities = params.type !== 'entity'
+    ? toDocumentDefinitions(params.bundle.entities)
+    : []
+  const skills = toDocumentDefinitions(
+    filterSkillAssets(params.bundle.skills, params.input?.skills)
+  )
+  const rules = toDocumentDefinitions(params.bundle.rules)
+  const specs = toDocumentDefinitions(params.bundle.specs)
+
+  const promptAssetIds = new Set<string>([
+    ...toPromptAssetIds(params.bundle.rules),
+    ...(params.type !== 'entity' ? toPromptAssetIds(params.bundle.entities) : []),
+    ...toPromptAssetIds(params.bundle.specs),
+    ...toPromptAssetIds(filterSkillAssets(params.bundle.skills, params.input?.skills))
+  ])
+
+  const targetSkillsAssets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>> = []
+  let targetBody = ''
+  let targetToolsFilter: Filter | undefined
+  let targetMcpServersFilter: Filter | undefined
+  let selectedSkillAssets: Array<Extract<WorkspaceAsset, { kind: 'skill' }>> = []
+
+  if (params.input?.skills?.include != null && params.input.skills.include.length > 0) {
+    selectedSkillAssets = dedupeSkillAssets(
+      filterSkillAssets(params.bundle.skills, { include: params.input.skills.include })
+    )
+  }
+
+  if (params.type && params.name) {
+    const targetAsset = params.type === 'spec'
+      ? pickSpecAsset(params.bundle, params.name)
+      : pickEntityAsset(params.bundle, params.name)
+
+    if (targetAsset == null) {
+      throw new Error(`Failed to load ${params.type} ${params.name}`)
+    }
+
+    const { definition } = targetAsset.payload
+    const { attributes, body } = definition
+    promptAssetIds.add(targetAsset.id)
+
+    if (attributes.rules) {
+      const matchedRuleAssets = await resolveSelectedRuleAssets(params.bundle, resolveRulePatterns(attributes.rules))
+      rules.push(
+        ...matchedRuleAssets.map((asset) => ({
+          ...asset.payload.definition,
+          attributes: {
+            ...asset.payload.definition.attributes,
+            always: true
+          }
+        }))
+      )
+      for (const asset of matchedRuleAssets) {
+        promptAssetIds.add(asset.id)
+      }
+    }
+
+    if (attributes.skills) {
+      const includedSkillNames = new Set(resolveIncludedSkillNames(attributes.skills))
+      const excludedSkillNames = new Set(resolveExcludedSkillNames(attributes.skills))
+      for (const skillAsset of params.bundle.skills) {
+        const skillName = basename(dirname(skillAsset.payload.definition.path))
+        if (includedSkillNames.size > 0 && !includedSkillNames.has(skillName)) continue
+        if (excludedSkillNames.has(skillName)) continue
+        targetSkillsAssets.push(skillAsset)
+        promptAssetIds.add(skillAsset.id)
+      }
+    }
+
+    targetBody = body
+    targetToolsFilter = attributes.tools
+    targetMcpServersFilter = attributes.mcpServers
+  }
+
+  const targetSkills = toDocumentDefinitions(targetSkillsAssets)
+  const selectedSkillsPrompt = toDocumentDefinitions(
+    selectedSkillAssets.filter(
+      skill => !targetSkillsAssets.some(target => target.payload.definition.path === skill.payload.definition.path)
+    )
+  )
+
+  systemPromptParts.push(loader.generateRulesPrompt(rules))
+  systemPromptParts.push(loader.generateSkillsPrompt(targetSkills))
+  systemPromptParts.push(loader.generateSkillsPrompt(selectedSkillsPrompt))
+  systemPromptParts.push(loader.generateEntitiesRoutePrompt(entities))
+  systemPromptParts.push(loader.generateSkillsRoutePrompt(skills))
+  systemPromptParts.push(loader.generateSpecRoutePrompt(specs))
+  systemPromptParts.push(targetBody)
+
+  if (targetToolsFilter) {
+    options.tools = targetToolsFilter
+  }
+  if (targetMcpServersFilter) {
+    options.mcpServers = targetMcpServersFilter
+  }
+
+  options.systemPrompt = systemPromptParts.join('\n\n')
+  options.promptAssetIds = Array.from(promptAssetIds)
+
+  return [
+    {
+      rules,
+      targetSkills,
+      entities,
+      skills,
+      specs,
+      targetBody,
+      promptAssetIds: Array.from(promptAssetIds)
+    },
+    options
+  ]
+}