@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/packages/task-support/src/workspace-assets.js

@@ -0,0 +1,629 @@
+import { readFile } from 'node:fs/promises';
+import { basename, dirname, extname, relative } from 'node:path';
+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 { glob } from 'fast-glob';
+import yaml from 'js-yaml';
+const normalizePath = (value) => value.split('\\').join('/');
+const resolveRelativePath = (cwd, value) => normalizePath(relative(cwd, value));
+const resolveDocumentName = (path, explicitName, indexFileNames = []) => {
+    const trimmedName = explicitName?.trim();
+    if (trimmedName)
+        return trimmedName;
+    const fileName = basename(path).toLowerCase();
+    if (indexFileNames.includes(fileName)) {
+        return basename(dirname(path));
+    }
+    return basename(path).replace(/\.[^/.]+$/, '');
+};
+const resolveSpecIdentifier = (path, explicitName) => (resolveDocumentName(path, explicitName, ['index.md']));
+const resolvePluginIdFromPath = (cwd, path) => {
+    const relativePath = resolveRelativePath(cwd, path);
+    const match = relativePath.match(/^\.ai\/plugins\/([^/]+)\//);
+    return match?.[1];
+};
+const isPluginEnabled = (enabledPlugins, pluginId) => pluginId == null || enabledPlugins[pluginId] !== false;
+const mergeRecord = (left, right) => ({
+    ...(left ?? {}),
+    ...(right ?? {})
+});
+const uniqueValues = (values) => Array.from(new Set(values.filter(Boolean)));
+const isOverlayPayload = (payload) => (payload != null &&
+    typeof payload === 'object' &&
+    typeof payload.sourcePath === 'string' &&
+    typeof payload.entryName === 'string' &&
+    typeof payload.targetSubpath === 'string');
+const isOpenCodeOverlayAsset = (asset) => ((asset.kind === 'nativePlugin' || asset.kind === 'agent' || asset.kind === 'command' || asset.kind === 'mode') &&
+    isOverlayPayload(asset.payload));
+const isLocalRuleReference = (rule) => (rule != null &&
+    typeof rule === 'object' &&
+    'path' in rule &&
+    typeof rule.path === 'string');
+const assetOriginPriority = {
+    project: 0,
+    plugin: 1,
+    config: 2,
+    fallback: 3
+};
+const readConfigForWorkspace = async (cwd) => {
+    return loadConfig({
+        cwd,
+        jsonVariables: buildConfigJsonVariables(cwd, process.env)
+    });
+};
+const toAssetScope = (origin) => (origin === 'config'
+    ? 'project'
+    : origin === 'fallback'
+        ? 'adapter'
+        : 'workspace');
+const pushAsset = (collection, next) => {
+    collection.push(next);
+    return next;
+};
+const createDocumentAsset = (params) => {
+    const pluginId = resolvePluginIdFromPath(params.cwd, params.definition.path);
+    const 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,
+            sourcePath: params.definition.path
+        }
+    };
+};
+const parseStructuredDocument = async (path) => {
+    const raw = await readFile(path, 'utf8');
+    const extension = extname(path).toLowerCase();
+    if (extension === '.yaml' || extension === '.yml') {
+        return yaml.load(raw);
+    }
+    return JSON.parse(raw);
+};
+const loadPluginMcpAssets = async (cwd, enabledPlugins) => {
+    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;
+        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
+            }
+        };
+    }));
+    return entries.filter((entry) => entry != null);
+};
+const loadOpenCodeOverlayAssets = async (cwd, enabledPlugins) => {
+    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',
+            scope: 'workspace',
+            enabled: true,
+            targets: ['opencode'],
+            payload: {
+                sourcePath: path,
+                entryName,
+                targetSubpath: `${rawFolder}/${entryName}`
+            }
+        };
+        if (rawFolder === 'plugins') {
+            return {
+                id: `nativePlugin:${relativePath}`,
+                kind: 'nativePlugin',
+                ...base
+            };
+        }
+        if (rawFolder === 'agents') {
+            return {
+                id: `agent:${relativePath}`,
+                kind: 'agent',
+                ...base
+            };
+        }
+        if (rawFolder === 'commands') {
+            return {
+                id: `command:${relativePath}`,
+                kind: 'command',
+                ...base
+            };
+        }
+        return {
+            id: `mode:${relativePath}`,
+            kind: 'mode',
+            ...base
+        };
+    })
+        .filter((entry) => entry != null);
+};
+const createHookPluginAssets = (config, enabledPlugins, scope) => {
+    if (config == null || Array.isArray(config))
+        return [];
+    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
+        }
+    }));
+};
+const createClaudeNativePluginAssets = (enabledPlugins) => {
+    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
+        }
+    }));
+};
+const dedupeDocumentAssets = (assets, enabledPlugins) => assets.filter((asset) => isPluginEnabled(enabledPlugins, asset.pluginId));
+const compareDocumentAssetPriority = (left, right) => {
+    const originDiff = assetOriginPriority[left.origin] - assetOriginPriority[right.origin];
+    if (originDiff !== 0)
+        return originDiff;
+    return left.payload.definition.path.localeCompare(right.payload.definition.path);
+};
+const dedupeDocumentAssetsByIdentifier = (assets, resolveIdentifier) => {
+    const selected = new Map();
+    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);
+};
+const resolveRuleIdentifier = (path, explicitName) => resolveDocumentName(path, explicitName);
+const resolveSkillIdentifier = (path, explicitName) => resolveDocumentName(path, explicitName, ['skill.md']);
+const pickSpecAsset = (bundle, name) => {
+    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];
+};
+const pickEntityAsset = (bundle, name) => {
+    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];
+};
+const filterSkillAssets = (skills, selection) => {
+    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);
+    });
+};
+const dedupeSkillAssets = (skills) => {
+    const seen = new Set();
+    return skills.filter((skill) => {
+        if (seen.has(skill.payload.definition.path))
+            return false;
+        seen.add(skill.payload.definition.path);
+        return true;
+    });
+};
+const resolveRulePatterns = (rules) => (rules.flatMap((rule) => {
+    if (typeof rule === 'string')
+        return [rule];
+    if (isLocalRuleReference(rule))
+        return [rule.path];
+    return [];
+}));
+const resolveIncludedSkillNames = (selection) => (Array.isArray(selection)
+    ? selection
+    : selection.type === 'include'
+        ? selection.list
+        : []);
+const resolveExcludedSkillNames = (selection) => (Array.isArray(selection)
+    ? []
+    : selection.type === 'exclude'
+        ? selection.list
+        : []);
+const resolveSelectedRuleAssets = async (bundle, patterns) => {
+    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)));
+};
+const toDocumentDefinitions = (assets) => assets.map(asset => asset.payload.definition);
+const toPromptAssetIds = (assets) => uniqueValues(assets.map(asset => asset.id));
+export async function resolveWorkspaceAssetBundle(params) {
+    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 = [];
+    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();
+    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 ?? [])
+        ])
+    };
+}
+export async function resolvePromptAssetSelection(params) {
+    const loader = new DefinitionLoader(params.bundle.cwd);
+    const options = {};
+    const systemPromptParts = [];
+    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([
+        ...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 = [];
+    let targetBody = '';
+    let targetToolsFilter;
+    let targetMcpServersFilter;
+    let selectedSkillAssets = [];
+    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
+    ];
+}
+const resolveMcpServerSelection = (bundle, selection) => {
+    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) {
+    const diagnostics = [];
+    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 = [];
+    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'
+                        ]
+                    }
+                }
+                : {}
+    };
+}