@bluefly/openstandardagents 0.5.0 → 0.5.1

package/dist/mcp-server/index.js

@@ -20,38 +20,35 @@
 import 'reflect-metadata';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import axios from 'axios';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import pino from 'pino';
 import fg from 'fast-glob';
 import yaml from 'js-yaml';
-import { spawnSync } from 'node:child_process';
+import axios from 'axios';
+import semver from 'semver';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import pino from 'pino';
-import semver from 'semver';
-import { z } from 'zod';
-import { registry as convertRegistry, initializeAdapters, } from '../adapters/index.js';
-import { getAgentTypeConfigs, getDefaultAgentKind, getDefaultAgentVersion, getDefaultDescriptionTemplate, getDefaultRoleTemplate, } from '../config/defaults.js';
 import { container } from '../di-container.js';
 import { ManifestRepository } from '../repositories/manifest.repository.js';
-import { AgentCardGenerator } from '../services/agent-card-generator.js';
+import { ValidationService } from '../services/validation.service.js';
 import { MigrationTransformService } from '../services/migration-transform.service.js';
+import { VersionDetectionService } from '../services/version-detection.service.js';
+import { AgentCardGenerator } from '../services/agent-card-generator.js';
 import { RegistryService } from '../services/registry.service.js';
-import { ValidationService } from '../services/validation.service.js';
-import { AnthropicValidator } from '../services/validators/anthropic.validator.js';
-import { AutoGenValidator } from '../services/validators/autogen.validator.js';
-import { CrewAIValidator } from '../services/validators/crewai.validator.js';
+import { getApiVersion, getVersion } from '../utils/version.js';
+import { getDefaultAgentVersion, getDefaultAgentKind, getDefaultRoleTemplate, getDefaultDescriptionTemplate, getAgentTypeConfigs, } from '../config/defaults.js';
 import { CursorValidator } from '../services/validators/cursor.validator.js';
-import { KagentValidator } from '../services/validators/kagent.validator.js';
+import { OpenAIValidator } from '../services/validators/openai.validator.js';
+import { CrewAIValidator } from '../services/validators/crewai.validator.js';
 import { LangChainValidator } from '../services/validators/langchain.validator.js';
+import { AnthropicValidator } from '../services/validators/anthropic.validator.js';
 import { LangflowValidator } from '../services/validators/langflow.validator.js';
-import { LangGraphValidator } from '../services/validators/langgraph.validator.js';
-import { LlamaIndexValidator } from '../services/validators/llamaindex.validator.js';
-import { OpenAIValidator } from '../services/validators/openai.validator.js';
+import { AutoGenValidator } from '../services/validators/autogen.validator.js';
 import { VercelAIValidator } from '../services/validators/vercel-ai.validator.js';
-import { VersionDetectionService } from '../services/version-detection.service.js';
-import { scanManifests } from '../utils/manifest-scanner.js';
-import { getApiVersion, getVersion } from '../utils/version.js';
+import { LlamaIndexValidator } from '../services/validators/llamaindex.validator.js';
+import { LangGraphValidator } from '../services/validators/langgraph.validator.js';
+import { KagentValidator } from '../services/validators/kagent.validator.js';
 // ---------------------------------------------------------------------------
 // Logging — pino (structured JSON to stderr so MCP stdio stays clean)
 // ---------------------------------------------------------------------------
@@ -69,39 +66,23 @@ const ValidateInput = z.object({
     path: z.string().min(1, 'path is required'),
     platform: z
         .enum([
-        'kagent',
-        'langchain',
-        'crewai',
-        'docker',
-        'kubernetes',
-        'gitlab-duo',
-        'anthropic',
+        'kagent', 'langchain', 'crewai', 'docker', 'kubernetes', 'gitlab-duo',
+        'anthropic', 'cursor', 'openai_agents', 'langflow', 'autogen',
+        'vercel_ai', 'llamaindex', 'langgraph',
     ])
         .optional(),
     strict: z.boolean().optional().default(false),
 });
 const ScaffoldInput = z.object({
-    name: z
-        .string()
-        .min(1)
-        .regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, 'Must be DNS-1123 format'),
+    name: z.string().min(1).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/, 'Must be DNS-1123 format'),
     output_dir: z.string().optional().default('.agents'),
     description: z.string().optional(),
     role: z.string().optional(),
     type: z
-        .enum([
-        'worker',
-        'orchestrator',
-        'reviewer',
-        'analyzer',
-        'executor',
-        'approver',
-    ])
+        .enum(['worker', 'orchestrator', 'reviewer', 'analyzer', 'executor', 'approver'])
         .optional()
         .default('worker'),
     version: z.string().optional(),
-    source_project_id: z.string().optional(),
-    execution_node_id: z.string().optional(),
 });
 const GenerateInput = z.object({
     path: z.string().min(1, 'path is required'),
@@ -134,7 +115,6 @@ const ConvertInput = z.object({
         'semantic-kernel',
         'a2a',
         'agent-card',
-        'claude-agent-sdk',
     ]),
     output_dir: z.string().optional(),
 });
@@ -161,8 +141,6 @@ const migrationTransformService = container.get(MigrationTransformService);
 const versionDetectionService = container.get(VersionDetectionService);
 const registryService = container.get(RegistryService);
 const agentCardGenerator = new AgentCardGenerator();
-// Initialize adapter registry (config-only adapters for MCP convert)
-initializeAdapters();
 // ---------------------------------------------------------------------------
 // MCP Server
 // ---------------------------------------------------------------------------
@@ -184,28 +162,17 @@ const tools = [
         inputSchema: {
             type: 'object',
             properties: {
-                path: {
-                    type: 'string',
-                    description: 'Path to manifest file (.ossa.yaml, .ossa.yml, .json)',
-                },
+                path: { type: 'string', description: 'Path to manifest file (.ossa.yaml, .ossa.yml, .json)' },
                 platform: {
                     type: 'string',
                     enum: [
-                        'kagent',
-                        'langchain',
-                        'crewai',
-                        'docker',
-                        'kubernetes',
-                        'gitlab-duo',
-                        'anthropic',
+                        'kagent', 'langchain', 'crewai', 'docker', 'kubernetes', 'gitlab-duo',
+                        'anthropic', 'cursor', 'openai_agents', 'langflow', 'autogen',
+                        'vercel_ai', 'llamaindex', 'langgraph',
                     ],
-                    description: 'Optional platform-specific validation',
-                },
-                strict: {
-                    type: 'boolean',
-                    description: 'Enable strict mode (warnings become errors)',
-                    default: false,
+                    description: 'Optional platform-specific validation (runs targeted validator for this platform)',
                 },
+                strict: { type: 'boolean', description: 'Enable strict mode (warnings become errors)', default: false },
             },
             required: ['path'],
         },
@@ -216,33 +183,16 @@ const tools = [
         inputSchema: {
             type: 'object',
             properties: {
-                name: {
-                    type: 'string',
-                    description: 'Agent name (DNS-1123: lowercase alphanumeric + hyphens)',
-                },
-                output_dir: {
-                    type: 'string',
-                    description: 'Parent directory (default: .agents)',
-                    default: '.agents',
-                },
+                name: { type: 'string', description: 'Agent name (DNS-1123: lowercase alphanumeric + hyphens)' },
+                output_dir: { type: 'string', description: 'Parent directory (default: .agents)', default: '.agents' },
                 description: { type: 'string', description: 'Short description' },
                 role: { type: 'string', description: 'System prompt / role' },
                 type: {
                     type: 'string',
-                    enum: [
-                        'worker',
-                        'orchestrator',
-                        'reviewer',
-                        'analyzer',
-                        'executor',
-                        'approver',
-                    ],
+                    enum: ['worker', 'orchestrator', 'reviewer', 'analyzer', 'executor', 'approver'],
                     default: 'worker',
                 },
-                version: {
-                    type: 'string',
-                    description: 'Initial version (default: 1.0.0)',
-                },
+                version: { type: 'string', description: 'Initial version (default: 1.0.0)' },
             },
             required: ['name'],
         },
@@ -254,10 +204,7 @@ const tools = [
             type: 'object',
             properties: {
                 path: { type: 'string', description: 'Path to OSSA manifest file' },
-                output_dir: {
-                    type: 'string',
-                    description: 'Optional directory to write agent-card.json',
-                },
+                output_dir: { type: 'string', description: 'Optional directory to write agent-card.json' },
             },
             required: ['path'],
         },
@@ -269,15 +216,8 @@ const tools = [
             type: 'object',
             properties: {
                 path: { type: 'string', description: 'Path to OSSA manifest file' },
-                registry_url: {
-                    type: 'string',
-                    description: 'Registry base URL (or set REGISTRY_URL / AGENT_REGISTRY_URL env)',
-                },
-                dry_run: {
-                    type: 'boolean',
-                    description: 'Preview publish payload without sending',
-                    default: false,
-                },
+                registry_url: { type: 'string', description: 'Registry base URL (or set REGISTRY_URL / AGENT_REGISTRY_URL env)' },
+                dry_run: { type: 'boolean', description: 'Preview publish payload without sending', default: false },
             },
             required: ['path'],
         },
@@ -288,16 +228,8 @@ const tools = [
         inputSchema: {
             type: 'object',
             properties: {
-                directory: {
-                    type: 'string',
-                    description: 'Root directory to scan (default: cwd)',
-                    default: '.',
-                },
-                recursive: {
-                    type: 'boolean',
-                    description: 'Scan subdirectories',
-                    default: true,
-                },
+                directory: { type: 'string', description: 'Root directory to scan (default: cwd)', default: '.' },
+                recursive: { type: 'boolean', description: 'Scan subdirectories', default: true },
                 format: {
                     type: 'string',
                     enum: ['summary', 'detailed', 'json'],
@@ -327,25 +259,10 @@ const tools = [
                 path: { type: 'string', description: 'Path to OSSA manifest file' },
                 target: {
                     type: 'string',
-                    enum: [
-                        'kagent',
-                        'docker',
-                        'langchain',
-                        'crewai',
-                        'gitlab-duo',
-                        'anthropic',
-                        'openai',
-                        'autogen',
-                        'semantic-kernel',
-                        'a2a',
-                        'agent-card',
-                    ],
+                    enum: ['kagent', 'docker', 'langchain', 'crewai', 'gitlab-duo', 'anthropic', 'openai', 'autogen', 'semantic-kernel', 'a2a', 'agent-card'],
                     description: 'Target format',
                 },
-                output_dir: {
-                    type: 'string',
-                    description: 'Optional directory to write converted output',
-                },
+                output_dir: { type: 'string', description: 'Optional directory to write converted output' },
             },
             required: ['path', 'target'],
         },
@@ -361,10 +278,7 @@ const tools = [
                     enum: ['init', 'discover', 'status'],
                     description: 'Workspace action',
                 },
-                directory: {
-                    type: 'string',
-                    description: 'Root directory to scan (default: current dir)',
-                },
+                directory: { type: 'string', description: 'Root directory to scan (default: current dir)' },
                 name: { type: 'string', description: 'Workspace name (for init)' },
             },
             required: ['action'],
@@ -394,10 +308,7 @@ const tools = [
                     description: 'Target OSSA version (default: ossa/v0.4)',
                     default: 'ossa/v0.4',
                 },
-                output_dir: {
-                    type: 'string',
-                    description: 'Optional directory to write migrated manifest',
-                },
+                output_dir: { type: 'string', description: 'Optional directory to write migrated manifest' },
             },
             required: ['path'],
         },
@@ -451,20 +362,11 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             const schemaContent = fs.existsSync(schemaPath)
                 ? fs.readFileSync(schemaPath, 'utf8')
                 : JSON.stringify({ error: 'Schema file not found', path: schemaPath });
-            return {
-                contents: [
-                    {
-                        uri: request.params.uri,
-                        mimeType: 'application/schema+json',
-                        text: schemaContent,
-                    },
-                ],
-            };
+            return { contents: [{ uri: request.params.uri, mimeType: 'application/schema+json', text: schemaContent }] };
         }
         case 'ossa://template/minimal':
             return {
-                contents: [
-                    {
+                contents: [{
                         uri: request.params.uri,
                         mimeType: 'text/yaml',
                         text: `apiVersion: ossa/v0.4
@@ -476,13 +378,11 @@ metadata:
 spec:
   role: You are a helpful assistant.
 `,
-                    },
-                ],
+                    }],
             };
         case 'ossa://template/full':
             return {
-                contents: [
-                    {
+                contents: [{
                         uri: request.params.uri,
                         mimeType: 'text/yaml',
                         text: `apiVersion: ossa/v0.4
@@ -576,13 +476,11 @@ token_efficiency:
       - model: claude-sonnet-4-20250514
         max_tokens: 4096
 `,
-                    },
-                ],
+                    }],
             };
         case 'ossa://guide/mcp-ossa-a2a':
             return {
-                contents: [
-                    {
+                contents: [{
                         uri: request.params.uri,
                         mimeType: 'text/markdown',
                         text: `# MCP → OSSA → A2A: The Agent Stack
@@ -650,150 +548,34 @@ npx ossa convert .agents/my-agent/manifest.ossa.yaml --target agent-card
 - npm: https://www.npmjs.com/package/@bluefly/openstandardagents
 - MCP Server: \`npx ossa-mcp\` (this server)
 `,
-                    },
-                ],
+                    }],
             };
         case 'ossa://platforms/supported':
             return {
-                contents: [
-                    {
+                contents: [{
                         uri: request.params.uri,
                         mimeType: 'application/json',
                         text: JSON.stringify({
                             platforms: [
-                                {
-                                    id: 'kagent',
-                                    name: 'kagent.dev',
-                                    type: 'kubernetes',
-                                    docs: 'https://kagent.dev',
-                                    format: 'v1alpha2 CRD (Agent + ModelConfig)',
-                                },
-                                {
-                                    id: 'docker',
-                                    name: 'Docker',
-                                    type: 'container',
-                                    docs: 'https://docs.docker.com',
-                                    format: 'docker-compose.yml',
-                                },
-                                {
-                                    id: 'openai',
-                                    name: 'OpenAI',
-                                    type: 'llm',
-                                    sdk: { npm: 'openai', pip: 'openai' },
-                                    docs: 'https://platform.openai.com/docs',
-                                    format: 'Assistants / function_calling',
-                                },
-                                {
-                                    id: 'anthropic',
-                                    name: 'Anthropic',
-                                    type: 'llm',
-                                    sdk: { npm: '@anthropic-ai/sdk', pip: 'anthropic' },
-                                    docs: 'https://docs.anthropic.com',
-                                    format: 'Messages API + tool_use',
-                                },
-                                {
-                                    id: 'google_genai',
-                                    name: 'Google Gemini',
-                                    type: 'llm',
-                                    sdk: {
-                                        npm: '@google/generative-ai',
-                                        pip: 'google-generativeai',
-                                    },
-                                    docs: 'https://ai.google.dev',
-                                    format: 'GenerativeAI',
-                                },
-                                {
-                                    id: 'langchain',
-                                    name: 'LangChain',
-                                    type: 'framework',
-                                    sdk: {
-                                        npm: ['langchain', '@langchain/core'],
-                                        pip: ['langchain', 'langchain-openai'],
-                                    },
-                                    docs: 'https://js.langchain.com',
-                                    format: 'Agent + StructuredTool',
-                                },
-                                {
-                                    id: 'langflow',
-                                    name: 'LangFlow',
-                                    type: 'visual',
-                                    sdk: { pip: 'langflow' },
-                                    docs: 'https://docs.langflow.org',
-                                    format: 'Custom component',
-                                },
-                                {
-                                    id: 'crewai',
-                                    name: 'CrewAI',
-                                    type: 'framework',
-                                    sdk: { pip: 'crewai' },
-                                    docs: 'https://docs.crewai.com',
-                                    format: 'Agent YAML',
-                                },
-                                {
-                                    id: 'autogen',
-                                    name: 'AutoGen',
-                                    type: 'framework',
-                                    sdk: { pip: 'autogen-agentchat' },
-                                    docs: 'https://microsoft.github.io/autogen',
-                                    format: 'ConversableAgent',
-                                },
-                                {
-                                    id: 'semantic-kernel',
-                                    name: 'Semantic Kernel',
-                                    type: 'framework',
-                                    sdk: { npm: 'semantic-kernel', pip: 'semantic-kernel' },
-                                    docs: 'https://learn.microsoft.com/en-us/semantic-kernel',
-                                    format: 'Agent + Plugins',
-                                },
-                                {
-                                    id: 'llamaindex',
-                                    name: 'LlamaIndex',
-                                    type: 'framework',
-                                    sdk: { npm: 'llamaindex', pip: 'llama-index' },
-                                    docs: 'https://docs.llamaindex.ai',
-                                    format: 'Agent config',
-                                },
-                                {
-                                    id: 'dspy',
-                                    name: 'DSPy',
-                                    type: 'framework',
-                                    sdk: { pip: 'dspy' },
-                                    docs: 'https://dspy.ai',
-                                    format: 'Module config',
-                                },
-                                {
-                                    id: 'gitlab-duo',
-                                    name: 'GitLab Duo',
-                                    type: 'devops',
-                                    docs: 'https://docs.gitlab.com/ee/user/gitlab_duo',
-                                    format: 'Duo agent YAML',
-                                },
-                                {
-                                    id: 'agent-card',
-                                    name: 'Universal Agent Card',
-                                    type: 'universal',
-                                    docs: 'https://openstandardagents.org',
-                                    format: 'Cross-platform JSON with all 12 adapters',
-                                },
-                                {
-                                    id: 'claude-agent-sdk',
-                                    name: 'Claude Agent SDK',
-                                    type: 'agent-sdk',
-                                    sdk: {
-                                        npm: '@anthropic-ai/claude-agent-sdk',
-                                        pip: 'claude-agent-sdk',
-                                        go: 'github.com/M1n9X/claude-agent-sdk-go',
-                                        rust: 'claude_agent',
-                                    },
-                                    docs: 'https://docs.claude.com/en/api/agent-sdk/overview',
-                                    format: 'Runnable Agent SDK app (TS/PY/Go/Rust)',
-                                },
+                                { id: 'kagent', name: 'kagent.dev', type: 'kubernetes', docs: 'https://kagent.dev', format: 'v1alpha2 CRD (Agent + ModelConfig)' },
+                                { id: 'docker', name: 'Docker', type: 'container', docs: 'https://docs.docker.com', format: 'docker-compose.yml' },
+                                { id: 'openai', name: 'OpenAI', type: 'llm', sdk: { npm: 'openai', pip: 'openai' }, docs: 'https://platform.openai.com/docs', format: 'Assistants / function_calling' },
+                                { id: 'anthropic', name: 'Anthropic', type: 'llm', sdk: { npm: '@anthropic-ai/sdk', pip: 'anthropic' }, docs: 'https://docs.anthropic.com', format: 'Messages API + tool_use' },
+                                { id: 'google_genai', name: 'Google Gemini', type: 'llm', sdk: { npm: '@google/generative-ai', pip: 'google-generativeai' }, docs: 'https://ai.google.dev', format: 'GenerativeAI' },
+                                { id: 'langchain', name: 'LangChain', type: 'framework', sdk: { npm: ['langchain', '@langchain/core'], pip: ['langchain', 'langchain-openai'] }, docs: 'https://js.langchain.com', format: 'Agent + StructuredTool' },
+                                { id: 'langflow', name: 'LangFlow', type: 'visual', sdk: { pip: 'langflow' }, docs: 'https://docs.langflow.org', format: 'Custom component' },
+                                { id: 'crewai', name: 'CrewAI', type: 'framework', sdk: { pip: 'crewai' }, docs: 'https://docs.crewai.com', format: 'Agent YAML' },
+                                { id: 'autogen', name: 'AutoGen', type: 'framework', sdk: { pip: 'autogen-agentchat' }, docs: 'https://microsoft.github.io/autogen', format: 'ConversableAgent' },
+                                { id: 'semantic-kernel', name: 'Semantic Kernel', type: 'framework', sdk: { npm: 'semantic-kernel', pip: 'semantic-kernel' }, docs: 'https://learn.microsoft.com/en-us/semantic-kernel', format: 'Agent + Plugins' },
+                                { id: 'llamaindex', name: 'LlamaIndex', type: 'framework', sdk: { npm: 'llamaindex', pip: 'llama-index' }, docs: 'https://docs.llamaindex.ai', format: 'Agent config' },
+                                { id: 'dspy', name: 'DSPy', type: 'framework', sdk: { pip: 'dspy' }, docs: 'https://dspy.ai', format: 'Module config' },
+                                { id: 'gitlab-duo', name: 'GitLab Duo', type: 'devops', docs: 'https://docs.gitlab.com/ee/user/gitlab_duo', format: 'Duo agent YAML' },
+                                { id: 'agent-card', name: 'Universal Agent Card', type: 'universal', docs: 'https://openstandardagents.org', format: 'Cross-platform JSON with all 12 adapters' },
                             ],
-                            total: 15,
+                            total: 14,
                             ossa_version: 'ossa/v0.4',
                         }, null, 2),
-                    },
-                ],
+                    }],
             };
         default:
             throw new Error(`Unknown resource: ${request.params.uri}`);
@@ -808,16 +590,8 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => ({
             name: 'create-agent',
             description: 'Create a new OSSA agent from a description of what it should do',
             arguments: [
-                {
-                    name: 'description',
-                    description: 'What the agent should do',
-                    required: true,
-                },
-                {
-                    name: 'name',
-                    description: 'Agent name (DNS-1123 format)',
-                    required: false,
-                },
+                { name: 'description', description: 'What the agent should do', required: true },
+                { name: 'name', description: 'Agent name (DNS-1123 format)', required: false },
             ],
         },
         {
@@ -846,8 +620,7 @@ server.setRequestHandler(GetPromptRequestSchema, async (request) => {
         case 'create-agent':
             return {
                 description: 'Create a new OSSA agent',
-                messages: [
-                    {
+                messages: [{
                         role: 'user',
                         content: {
                             type: 'text',
@@ -857,14 +630,12 @@ Use the ossa_scaffold tool to create the directory structure, then customize the
 
 After scaffolding, read the manifest, customize it with appropriate tools, capabilities, and LLM config, then validate it with ossa_validate.`,
                         },
-                    },
-                ],
+                    }],
             };
         case 'convert-for-platform':
             return {
                 description: 'Convert manifest to target platform',
-                messages: [
-                    {
+                messages: [{
                         role: 'user',
                         content: {
                             type: 'text',
@@ -872,14 +643,12 @@ After scaffolding, read the manifest, customize it with appropriate tools, capab
 
 Use ossa_convert with the target platform. If converting to agent-card, explain the cross-platform adapters available (OpenAI, Anthropic, LangChain, CrewAI, etc.) and the SDK packages needed.`,
                         },
-                    },
-                ],
+                    }],
             };
         case 'explain-manifest':
             return {
                 description: 'Explain an OSSA manifest',
-                messages: [
-                    {
+                messages: [{
                         role: 'user',
                         content: {
                             type: 'text',
@@ -890,14 +659,12 @@ Use ossa_convert with the target platform. If converting to agent-card, explain
 4. Its autonomy level and safety constraints
 5. How it can be deployed (platforms it supports)`,
                         },
-                    },
-                ],
+                    }],
             };
         case 'what-is-ossa':
             return {
                 description: 'Explain OSSA',
-                messages: [
-                    {
+                messages: [{
                         role: 'user',
                         content: {
                             type: 'text',
@@ -910,8 +677,7 @@ Read the ossa://guide/mcp-ossa-a2a resource for the full explanation. Key points
 
 Show the supported platforms using the ossa://platforms/supported resource.`,
                         },
-                    },
-                ],
+                    }],
             };
         default:
             throw new Error(`Unknown prompt: ${request.params.name}`);
@@ -1006,10 +772,7 @@ async function handleValidate(args) {
             }
             // Merge platform results into base results
             if (platformErrors.length) {
-                result.errors = [
-                    ...(result.errors || []),
-                    ...platformErrors,
-                ];
+                result.errors = [...(result.errors || []), ...platformErrors];
                 result.valid = false;
             }
             if (platformWarnings.length) {
@@ -1020,10 +783,7 @@ async function handleValidate(args) {
     // Strict mode: promote warnings to errors
     if (input.strict && result.warnings?.length) {
         const promoted = result.warnings.map((w) => `[strict] ${w}`);
-        result.errors = [
-            ...(result.errors || []),
-            ...promoted,
-        ];
+        result.errors = [...(result.errors || []), ...promoted];
         result.valid = !result.errors?.length;
     }
     return okResponse({
@@ -1032,13 +792,11 @@ async function handleValidate(args) {
         warnings: result.warnings || [],
         manifest_path: manifestPath,
         platform: input.platform || null,
-        platform_validation: input.platform
-            ? {
-                platform: input.platform,
-                errors: platformErrors,
-                warnings: platformWarnings,
-            }
-            : undefined,
+        platform_validation: input.platform ? {
+            platform: input.platform,
+            errors: platformErrors,
+            warnings: platformWarnings,
+        } : undefined,
     });
 }
 // ---------------------------------------------------------------------------
@@ -1060,17 +818,11 @@ async function handleScaffold(args) {
             name: input.name,
             version: input.version || getDefaultAgentVersion(),
             description: input.description || getDefaultDescriptionTemplate(input.name),
-            mesh_bindings: {
-                source_project_id: input.source_project_id || process.env.OSSA_DEFAULT_SOURCE_PROJECT_ID || '',
-                execution_node_id: input.execution_node_id || process.env.OSSA_DEFAULT_EXECUTION_NODE_ID || '',
-            },
         },
         spec: {
             role: input.role || getDefaultRoleTemplate(input.name),
             llm: { provider: 'openai', model: '${LLM_MODEL:-gpt-4}' },
-            tools: typeConfig.capabilityName
-                ? [{ type: 'capability', name: typeConfig.capabilityName }]
-                : [],
+            tools: typeConfig.capabilityName ? [{ type: 'capability', name: typeConfig.capabilityName }] : [],
         },
     };
     // Create directory structure
@@ -1108,11 +860,7 @@ async function handleGenerate(args) {
         fs.mkdirSync(wellKnown, { recursive: true });
         const cardPath = path.join(wellKnown, 'agent-card.json');
         fs.writeFileSync(cardPath, result.json ?? JSON.stringify(result.card, null, 2), 'utf8');
-        return okResponse({
-            success: true,
-            agent_card: result.card,
-            written_to: cardPath,
-        });
+        return okResponse({ success: true, agent_card: result.card, written_to: cardPath });
     }
     return okResponse({ success: true, agent_card: result.card });
 }
@@ -1131,9 +879,7 @@ async function handlePublish(args) {
     };
     // Dry run — show what would happen for both local and remote
     if (input.dry_run) {
-        const registryUrl = input.registry_url ||
-            process.env.REGISTRY_URL ||
-            process.env.AGENT_REGISTRY_URL;
+        const registryUrl = input.registry_url || process.env.REGISTRY_URL || process.env.AGENT_REGISTRY_URL;
         return okResponse({
             dry_run: true,
             payload,
@@ -1143,10 +889,7 @@ async function handlePublish(args) {
                 version: manifest.metadata?.version || '1.0.0',
             },
             remote_publish: registryUrl
-                ? {
-                    registry_url: registryUrl,
-                    url: registryUrl.replace(/\/?$/, '/api/v1/agents'),
-                }
+                ? { registry_url: registryUrl, url: registryUrl.replace(/\/?$/, '/api/v1/agents') }
                 : null,
             message: 'Payload that would be sent to local and/or remote registry',
         });
@@ -1173,9 +916,7 @@ async function handlePublish(args) {
             error: err instanceof Error ? err.message : String(err),
         };
     }
-    const registryUrl = input.registry_url ||
-        process.env.REGISTRY_URL ||
-        process.env.AGENT_REGISTRY_URL;
+    const registryUrl = input.registry_url || process.env.REGISTRY_URL || process.env.AGENT_REGISTRY_URL;
     // Remote HTTP registry (if configured)
     if (registryUrl) {
         const url = registryUrl.replace(/\/?$/, '/api/v1/agents');
@@ -1186,74 +927,66 @@ async function handlePublish(args) {
         });
         return okResponse({
             success: res.status >= 200 && res.status < 300,
-            status: res.status,
-            registry_url: registryUrl,
-            data: res.data,
-            local_publish: localResult,
-        });
-    }
-    // arctl CLI fallback
-    const arctl = spawnSync('arctl', ['publish', manifestPath], {
-        encoding: 'utf8',
-        timeout: 30000,
-    });
-    if (arctl.status === 0) {
-        return okResponse({
-            success: true,
-            method: 'arctl',
-            stdout: arctl.stdout?.trim(),
-            local_publish: localResult,
-        });
-    }
-    // No remote configured — return local result
-    if (localResult?.success) {
-        return okResponse({
-            success: true,
-            method: 'local',
-            local_publish: localResult,
-            message: 'Published to local registry. Set REGISTRY_URL for remote publish.',
+            local: localResult,
+            remote: {
+                success: res.status >= 200 && res.status < 300,
+                status: res.status,
+                registry_url: registryUrl,
+                data: res.data,
+            },
         });
     }
+    // No remote registry — return local result only
     return okResponse({
-        published: false,
-        message: 'No registry configured. Set REGISTRY_URL or install arctl.',
-        local_publish: localResult,
-        next_steps: [
-            'Set REGISTRY_URL or AGENT_REGISTRY_URL environment variable',
-            'Or install arctl: npm install -g @agentregistry/arctl',
-            'Then: arctl publish ' + manifestPath,
-        ],
+        success: localResult?.success === true,
+        local: localResult,
+        remote: null,
+        message: localResult?.success
+            ? 'Published to local registry. Set REGISTRY_URL for remote publishing.'
+            : 'Local publish failed. Set REGISTRY_URL for remote publishing.',
     });
 }
 // ---------------------------------------------------------------------------
-// ossa_list — workspace discovery via shared manifest scanner
-// Uses src/utils/manifest-scanner.ts for consistent glob patterns and parsing.
+// ossa_list — workspace discovery via fast-glob
+// HACK: Inline fast-glob scan instead of AgentsMdDiscoveryService.
+// The DI service does heavier work (repo analysis, AGENTS.md generation)
+// that we don't need for a simple MCP list response.
+// TODO(#443): Extract lightweight scan into a shared utility.
 // ---------------------------------------------------------------------------
 async function handleList(args) {
     const input = ListInput.parse(args);
     const baseDir = resolvePath(input.directory);
-    const results = await scanManifests(baseDir, {
-        recursive: input.recursive,
-        includeAgentsDirs: true,
+    const patterns = input.recursive
+        ? ['**/*.ossa.yaml', '**/*.ossa.yml', '**/.agents/*/manifest.ossa.yaml']
+        : ['*.ossa.yaml', '*.ossa.yml', '.agents/*/manifest.ossa.yaml'];
+    const files = await fg(patterns, {
+        cwd: baseDir,
         absolute: true,
+        ignore: ['**/node_modules/**', '**/dist/**', '**/.git/**'],
     });
-    const agents = results.map((r) => r.error
-        ? { name: r.name, path: r.path, error: r.error }
-        : {
-            name: r.name,
-            version: r.version,
-            path: r.path,
-            kind: r.kind,
-            apiVersion: r.apiVersion,
-            description: r.description,
-        });
+    const agents = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(file, 'utf8');
+            const doc = yaml.load(raw);
+            const meta = doc.metadata;
+            agents.push({
+                name: meta?.name || path.basename(path.dirname(file)),
+                version: meta?.version || 'unknown',
+                path: file,
+                kind: doc.kind || 'Agent',
+                apiVersion: doc.apiVersion || 'unknown',
+                description: meta?.description || '',
+            });
+        }
+        catch {
+            agents.push({ name: path.basename(file), path: file, error: 'Failed to parse' });
+        }
+    }
     if (input.format === 'json') {
         return okResponse({ count: agents.length, agents });
     }
     if (input.format === 'detailed') {
-        const patterns = input.recursive
-            ? ['**/*.ossa.yaml', '**/*.ossa.yml', '**/.agents/*/manifest.ossa.yaml']
-            : ['*.ossa.yaml', '*.ossa.yml', '.agents/*/manifest.ossa.yaml'];
         return okResponse({
             count: agents.length,
             agents,
@@ -1304,21 +1037,12 @@ async function handleInspect(args) {
         name: meta?.name,
         version: versionStr,
         version_analysis: parsed
-            ? {
-                major: parsed.major,
-                minor: parsed.minor,
-                patch: parsed.patch,
-                prerelease: parsed.prerelease,
-            }
+            ? { major: parsed.major, minor: parsed.minor, patch: parsed.patch, prerelease: parsed.prerelease }
             : null,
         kind: manifest.kind,
         apiVersion: manifest.apiVersion,
-        mesh_bindings: meta?.mesh_bindings || null,
         description: meta?.description,
-        role: spec?.role
-            ? String(spec.role).substring(0, 200) +
-                (String(spec.role).length > 200 ? '...' : '')
-            : null,
+        role: spec?.role ? String(spec.role).substring(0, 200) + (String(spec.role).length > 200 ? '...' : '') : null,
         llm: spec?.llm || null,
         tools: toolSummary,
         tool_count: specTools.length,
@@ -1339,524 +1063,552 @@ async function handleInspect(args) {
 // ---------------------------------------------------------------------------
 // ossa_convert — export to target platform format
 //
-// Most targets delegate to the adapter registry's toConfig() method (#442).
-// a2a/agent-card and claude-agent-sdk remain inline due to their complexity
-// (cross-platform card generation and SDK-specific config respectively).
+// HACK: These inline adapters produce lightweight JSON configs suitable for
+// MCP tool responses. The CLI export adapters (src/adapters/) generate full
+// multi-file project scaffolds (Dockerfile, docker-compose, Python packages,
+// etc.) which are too heavy for MCP responses. This is intentional divergence.
+// TODO(#442): Create a shared "config-only" export mode in the adapter classes
+// so both CLI and MCP can use the same code path.
 // ---------------------------------------------------------------------------
 async function handleConvert(args) {
     const input = ConvertInput.parse(args);
     const manifestPath = resolvePath(input.path);
     const manifest = await manifestRepo.load(manifestPath);
-    const meta = manifest.metadata || {
-        name: path.basename(manifestPath, '.ossa.yaml'),
-        version: '0.0.0',
-    };
+    const meta = manifest.metadata || { name: path.basename(manifestPath, '.ossa.yaml'), version: '0.0.0' };
     let converted;
     let filename;
-    // a2a/agent-card is special: complex cross-platform card stays inline
-    if (input.target === 'a2a' || input.target === 'agent-card') {
-        // Build comprehensive cross-platform agent card
-        // This is THE universal discovery format: MCP → OSSA → A2A
-        let cardResult = {
-            success: false,
-            errors: [],
-        };
-        try {
-            cardResult = agentCardGenerator.generate(manifest);
+    switch (input.target) {
+        case 'kagent': {
+            // Generate kagent.dev v1alpha2 format (actual CRD that kagent controller understands)
+            const kagentExtensions = manifest.extensions;
+            const kagentExt = kagentExtensions?.kagent;
+            const kagentNs = kagentExt?.kubernetes?.namespace || 'kagent';
+            const a2aConfig = kagentExt?.a2aConfig;
+            // Map OSSA tools to kagent McpServer tool format
+            const ossaTools = (manifest.spec?.tools || []);
+            const kagentTools = ossaTools.map((t) => {
+                if (t.type === 'mcp') {
+                    return {
+                        type: 'McpServer',
+                        mcpServer: {
+                            name: t.server || t.name || 'tool-server',
+                            kind: 'RemoteMCPServer',
+                            ...(t.toolNames ? { toolNames: t.toolNames } : {}),
+                        },
+                    };
+                }
+                return {
+                    type: 'McpServer',
+                    mcpServer: {
+                        name: t.name || 'tool-server',
+                        kind: 'RemoteMCPServer',
+                    },
+                };
+            });
+            // Build the v1alpha2 Agent CRD
+            converted = {
+                apiVersion: 'kagent.dev/v1alpha2',
+                kind: 'Agent',
+                metadata: {
+                    name: meta.name,
+                    namespace: kagentNs,
+                    labels: {
+                        'ossa.dev/name': meta.name,
+                        'ossa.dev/version': meta.version || '0.0.0',
+                        'app.kubernetes.io/managed-by': 'ossa',
+                    },
+                },
+                spec: {
+                    description: meta.description || '',
+                    type: 'Declarative',
+                    declarative: {
+                        modelConfig: `${meta.name}-model-config`,
+                        systemMessage: manifest.spec?.role || '',
+                        tools: kagentTools,
+                        ...(a2aConfig ? { a2aConfig } : {}),
+                    },
+                },
+            };
+            // Also generate the ModelConfig companion resource
+            const modelConfig = {
+                apiVersion: 'kagent.dev/v1alpha2',
+                kind: 'ModelConfig',
+                metadata: {
+                    name: `${meta.name}-model-config`,
+                    namespace: kagentNs,
+                },
+                spec: {
+                    provider: manifest.spec?.llm?.provider || 'openai',
+                    model: manifest.spec?.llm?.model || 'gpt-4',
+                    ...(manifest.spec?.llm?.temperature != null ? { temperature: manifest.spec.llm.temperature } : {}),
+                    ...(manifest.spec?.llm?.maxTokens != null ? { maxTokens: manifest.spec.llm.maxTokens } : {}),
+                },
+            };
+            // Return both resources in a multi-document YAML
+            converted = {
+                _ossa_multi_resource: true,
+                resources: [converted, modelConfig],
+                agent: converted,
+                modelConfig,
+            };
+            filename = `${meta.name}.kagent.yaml`;
+            break;
         }
-        catch {
-            // AgentCardGenerator may fail on some manifests — continue building the card
+        case 'docker': {
+            converted = {
+                version: '3.8',
+                services: {
+                    [meta.name]: {
+                        image: `ossa/${meta.name}:${meta.version || 'latest'}`,
+                        environment: {
+                            AGENT_NAME: meta.name,
+                            LLM_PROVIDER: manifest.spec?.llm?.provider || 'openai',
+                            LLM_MODEL: manifest.spec?.llm?.model || 'gpt-4',
+                        },
+                        labels: {
+                            'ossa.name': meta.name,
+                            'ossa.version': meta.version || '0.0.0',
+                            'ossa.kind': manifest.kind || 'Agent',
+                        },
+                    },
+                },
+            };
+            filename = `docker-compose.${meta.name}.yml`;
+            break;
         }
-        const tools = (manifest.spec?.tools || []);
-        const role = manifest.spec?.role || '';
-        const llm = manifest.spec?.llm;
-        const provider = llm?.provider || 'openai';
-        const model = llm?.model || 'gpt-4';
-        const description = meta.description || '';
-        // Build universal tool schemas for cross-platform use
-        const universalTools = tools.map((t) => ({
-            name: t.name || 'unnamed',
-            description: t.description || '',
-            inputSchema: (t.inputSchema ||
-                t.input_schema ||
-                t.parameters || { type: 'object', properties: {} }),
-            ...(t.outputSchema || t.output_schema
-                ? { outputSchema: t.outputSchema || t.output_schema }
-                : {}),
-            ...(t.type ? { type: t.type } : {}),
-            ...(t.server ? { mcpServer: t.server } : {}),
-        }));
-        // A2A skills from tools (Google A2A agent card format)
-        const a2aSkills = universalTools.map((t) => ({
-            id: t.name,
-            name: t.name,
-            description: t.description,
-            ...(t.inputSchema ? { inputModes: ['application/json'] } : {}),
-            outputModes: ['application/json', 'text/plain'],
-        }));
-        // MCP tool format (Model Context Protocol)
-        const mcpTools = universalTools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            inputSchema: t.inputSchema,
-        }));
-        // OpenAI function_calling format
-        const openaiTools = universalTools.map((t) => ({
-            type: 'function',
-            function: {
-                name: t.name,
-                description: t.description,
-                parameters: t.inputSchema,
-            },
-        }));
-        // Anthropic tool_use format
-        const anthropicTools = universalTools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            input_schema: t.inputSchema,
-        }));
-        // LangChain StructuredTool format
-        const langchainTools = universalTools.map((t) => ({
-            _type: 'structured_tool',
-            name: t.name,
-            description: t.description,
-            args_schema: t.inputSchema,
-        }));
-        // CrewAI tool format
-        const crewaiTools = universalTools.map((t) => ({
-            name: t.name,
-            description: t.description,
-            ...(t.inputSchema ? { args_schema: t.inputSchema } : {}),
-        }));
-        // LangFlow component format
-        const langflowComponent = {
-            display_name: meta.name,
-            description,
-            documentation: `https://openstandardagents.org/agents/${meta.name}`,
-            template: {
-                system_message: { type: 'str', value: role },
-                model_name: { type: 'str', value: model },
-                provider: { type: 'str', value: provider },
-                tools: { type: 'list', value: universalTools.map((t) => t.name) },
-            },
-        };
-        // AutoGen agent format
-        const autogenConfig = {
-            name: meta.name,
-            description,
-            system_message: role,
-            llm_config: {
-                config_list: [
+        case 'langchain': {
+            converted = {
+                _type: 'agent',
+                name: meta.name,
+                description: meta.description || '',
+                llm: {
+                    _type: manifest.spec?.llm?.provider === 'anthropic' ? 'ChatAnthropic' : 'ChatOpenAI',
+                    model_name: manifest.spec?.llm?.model || 'gpt-4',
+                },
+                system_message: manifest.spec?.role || '',
+                tools: (manifest.spec?.tools || []).map((t) => ({
+                    name: t.name,
+                    type: t.type,
+                })),
+            };
+            filename = `${meta.name}.langchain.json`;
+            break;
+        }
+        case 'crewai': {
+            converted = {
+                agents: [
                     {
-                        model,
-                        api_type: provider === 'anthropic' ? 'anthropic' : 'openai',
+                        role: meta.name,
+                        goal: meta.description || '',
+                        backstory: manifest.spec?.role || '',
+                        llm: manifest.spec?.llm?.model || 'gpt-4',
+                        tools: (manifest.spec?.tools || []).map((t) => t.name),
                     },
                 ],
-            },
-            ...(universalTools.length > 0
-                ? {
-                    tools: universalTools.map((t) => ({
-                        name: t.name,
-                        description: t.description,
-                    })),
-                }
-                : {}),
-        };
-        // Semantic Kernel agent format
-        const semanticKernelConfig = {
-            name: meta.name,
-            description,
-            instructions: role,
-            model: { id: model, provider },
-            plugins: universalTools.map((t) => ({
-                name: t.name,
-                description: t.description,
-                parameters: t.inputSchema,
-            })),
-        };
-        // kagent.dev CRD reference (not full CRD — use target: kagent for that)
-        const kagentRef = {
-            apiVersion: 'kagent.dev/v1alpha2',
-            kind: 'Agent',
-            metadata: { name: meta.name },
-            spec: {
-                type: 'Declarative',
-                declarative: {
-                    modelConfig: `${meta.name}-model-config`,
-                    systemMessage: role,
+            };
+            filename = `${meta.name}.crewai.yaml`;
+            break;
+        }
+        case 'gitlab-duo': {
+            converted = {
+                name: meta.name,
+                description: meta.description || '',
+                system_prompt: manifest.spec?.role || '',
+                model: manifest.spec?.llm?.model || 'claude-sonnet-4-20250514',
+                tools: (manifest.spec?.tools || []).map((t) => ({
+                    name: t.name,
+                })),
+            };
+            filename = `${meta.name}.duo-agent.yaml`;
+            break;
+        }
+        case 'anthropic': {
+            converted = {
+                name: meta.name,
+                description: meta.description || '',
+                model: manifest.spec?.llm?.model || 'claude-sonnet-4-20250514',
+                system: manifest.spec?.role || '',
+                tools: (manifest.spec?.tools || []).map((t) => ({
+                    name: t.name,
+                    description: '',
+                    input_schema: { type: 'object', properties: {} },
+                })),
+                max_tokens: 4096,
+            };
+            filename = `${meta.name}.anthropic.json`;
+            break;
+        }
+        case 'openai': {
+            // OpenAI Assistants / function_calling format
+            const oaiTools = (manifest.spec?.tools || []);
+            converted = {
+                model: manifest.spec?.llm?.model || 'gpt-4',
+                name: meta.name,
+                description: meta.description || '',
+                instructions: manifest.spec?.role || '',
+                tools: oaiTools.map((t) => ({
+                    type: 'function',
+                    function: {
+                        name: t.name || 'unnamed',
+                        description: t.description || '',
+                        parameters: t.inputSchema || t.input_schema || t.parameters || { type: 'object', properties: {} },
+                    },
+                })),
+                metadata: {
+                    ossa_version: manifest.apiVersion || 'ossa/v0.4',
+                    ossa_name: meta.name,
                 },
-            },
-        };
-        // Extensions from OSSA manifest
-        const extensions = manifest.extensions;
-        const a2aExt = extensions?.a2a;
-        const mcpExt = extensions?.mcp;
-        // Build the comprehensive agent card
-        converted = {
-            // --- Core identity (OSSA source of truth) ---
-            name: meta.name,
-            version: meta.version || '1.0.0',
-            description,
-            url: `https://openstandardagents.org/agents/${meta.name}`,
-            ossaVersion: manifest.apiVersion || 'ossa/v0.4',
-            kind: manifest.kind || 'Agent',
-            // --- The OSSA contract (identity + capabilities + constraints) ---
-            ossa: {
-                role,
-                capabilities: (manifest.spec?.capabilities || []),
-                ...(manifest.spec?.autonomy
-                    ? { autonomy: manifest.spec.autonomy }
-                    : {}),
-                ...(manifest.spec?.safety ? { safety: manifest.spec.safety } : {}),
-                ...(manifest.spec?.observability
-                    ? { observability: manifest.spec.observability }
-                    : {}),
-                ...(manifest.spec?.access
-                    ? { access: manifest.spec.access }
+            };
+            filename = `${meta.name}.openai.json`;
+            break;
+        }
+        case 'autogen': {
+            // Microsoft AutoGen agent config
+            const autogenTools = (manifest.spec?.tools || []);
+            converted = {
+                name: meta.name,
+                description: meta.description || '',
+                system_message: manifest.spec?.role || '',
+                llm_config: {
+                    config_list: [
+                        {
+                            model: manifest.spec?.llm?.model || 'gpt-4',
+                            api_type: manifest.spec?.llm?.provider === 'anthropic' ? 'anthropic' : 'openai',
+                        },
+                    ],
+                    ...(manifest.spec?.llm?.temperature != null ? { temperature: manifest.spec.llm.temperature } : {}),
+                    ...(manifest.spec?.llm?.maxTokens != null ? { max_tokens: manifest.spec.llm.maxTokens } : {}),
+                },
+                ...(autogenTools.length > 0
+                    ? {
+                        tools: autogenTools.map((t) => ({
+                            name: t.name || 'unnamed',
+                            description: t.description || '',
+                            ...(t.inputSchema || t.input_schema ? { parameters: t.inputSchema || t.input_schema } : {}),
+                        })),
+                    }
                     : {}),
-            },
-            // --- A2A discovery (Google Agent-to-Agent protocol) ---
-            capabilities: {
-                streaming: true,
-                pushNotifications: false,
-                stateTransitionHistory: true,
-            },
-            skills: a2aSkills,
-            defaultInputModes: ['application/json', 'text/plain'],
-            defaultOutputModes: ['application/json', 'text/plain'],
-            // --- MCP tools (Model Context Protocol) ---
-            mcp: {
-                tools: mcpTools,
-                ...(mcpExt?.servers ? { servers: mcpExt.servers } : {}),
-                ...(mcpExt?.resources ? { resources: mcpExt.resources } : {}),
-            },
-            // --- Platform adapters (use these directly in your framework) ---
-            // Each adapter includes: sdk (npm/pip packages), config (ready-to-use), usage (code snippet)
-            adapters: {
-                openai: {
-                    sdk: {
-                        npm: 'openai',
-                        pip: 'openai',
-                        docs: 'https://platform.openai.com/docs/api-reference',
-                    },
-                    config: {
-                        model,
-                        messages: [{ role: 'system', content: role }],
-                        tools: openaiTools,
-                        tool_choice: 'auto',
-                    },
-                    usage: `import OpenAI from 'openai';\nconst client = new OpenAI();\nconst response = await client.chat.completions.create(config);`,
+                metadata: {
+                    ossa_version: manifest.apiVersion || 'ossa/v0.4',
                 },
-                anthropic: {
-                    sdk: {
-                        npm: '@anthropic-ai/sdk',
-                        pip: 'anthropic',
-                        docs: 'https://docs.anthropic.com/en/api',
-                    },
-                    config: {
-                        model: provider === 'anthropic' ? model : 'claude-sonnet-4-20250514',
-                        system: role,
-                        tools: anthropicTools,
-                        max_tokens: llm?.maxTokens || 4096,
+            };
+            filename = `${meta.name}.autogen.json`;
+            break;
+        }
+        case 'semantic-kernel': {
+            // Microsoft Semantic Kernel agent config
+            const skTools = (manifest.spec?.tools || []);
+            converted = {
+                name: meta.name,
+                description: meta.description || '',
+                instructions: manifest.spec?.role || '',
+                execution_settings: {
+                    default: {
+                        model_id: manifest.spec?.llm?.model || 'gpt-4',
+                        service_id: manifest.spec?.llm?.provider || 'openai',
+                        ...(manifest.spec?.llm?.temperature != null ? { temperature: manifest.spec.llm.temperature } : {}),
+                        ...(manifest.spec?.llm?.maxTokens != null ? { max_tokens: manifest.spec.llm.maxTokens } : {}),
                     },
-                    usage: `import Anthropic from '@anthropic-ai/sdk';\nconst client = new Anthropic();\nconst response = await client.messages.create(config);`,
                 },
-                google_genai: {
-                    sdk: {
-                        npm: '@google/generative-ai',
-                        pip: 'google-generativeai',
-                        docs: 'https://ai.google.dev/docs',
-                    },
-                    config: {
-                        model: 'gemini-2.0-flash',
-                        systemInstruction: role,
-                        tools: [
-                            { functionDeclarations: openaiTools.map((t) => t.function) },
-                        ],
+                plugins: skTools.map((t) => ({
+                    name: t.name || 'unnamed',
+                    description: t.description || '',
+                    parameters: t.inputSchema || t.input_schema || t.parameters || { type: 'object', properties: {} },
+                })),
+                metadata: {
+                    ossa_version: manifest.apiVersion || 'ossa/v0.4',
+                },
+            };
+            filename = `${meta.name}.semantic-kernel.json`;
+            break;
+        }
+        case 'a2a':
+        case 'agent-card': {
+            // Build comprehensive cross-platform agent card
+            // This is THE universal discovery format: MCP → OSSA → A2A
+            let cardResult = { success: false, errors: [] };
+            try {
+                cardResult = agentCardGenerator.generate(manifest);
+            }
+            catch {
+                // AgentCardGenerator may fail on some manifests — continue building the card
+            }
+            const tools = (manifest.spec?.tools || []);
+            const role = manifest.spec?.role || '';
+            const llm = manifest.spec?.llm;
+            const provider = llm?.provider || 'openai';
+            const model = llm?.model || 'gpt-4';
+            const description = meta.description || '';
+            // Build universal tool schemas for cross-platform use
+            const universalTools = tools.map((t) => ({
+                name: t.name || 'unnamed',
+                description: t.description || '',
+                inputSchema: (t.inputSchema || t.input_schema || t.parameters || { type: 'object', properties: {} }),
+                ...(t.outputSchema || t.output_schema ? { outputSchema: t.outputSchema || t.output_schema } : {}),
+                ...(t.type ? { type: t.type } : {}),
+                ...(t.server ? { mcpServer: t.server } : {}),
+            }));
+            // A2A skills from tools (Google A2A agent card format)
+            const a2aSkills = universalTools.map((t) => ({
+                id: t.name,
+                name: t.name,
+                description: t.description,
+                ...(t.inputSchema ? { inputModes: ['application/json'] } : {}),
+                outputModes: ['application/json', 'text/plain'],
+            }));
+            // MCP tool format (Model Context Protocol)
+            const mcpTools = universalTools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            }));
+            // OpenAI function_calling format
+            const openaiTools = universalTools.map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema,
+                },
+            }));
+            // Anthropic tool_use format
+            const anthropicTools = universalTools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                input_schema: t.inputSchema,
+            }));
+            // LangChain StructuredTool format
+            const langchainTools = universalTools.map((t) => ({
+                _type: 'structured_tool',
+                name: t.name,
+                description: t.description,
+                args_schema: t.inputSchema,
+            }));
+            // CrewAI tool format
+            const crewaiTools = universalTools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                ...(t.inputSchema ? { args_schema: t.inputSchema } : {}),
+            }));
+            // LangFlow component format
+            const langflowComponent = {
+                display_name: meta.name,
+                description,
+                documentation: `https://openstandardagents.org/agents/${meta.name}`,
+                template: {
+                    system_message: { type: 'str', value: role },
+                    model_name: { type: 'str', value: model },
+                    provider: { type: 'str', value: provider },
+                    tools: { type: 'list', value: universalTools.map((t) => t.name) },
+                },
+            };
+            // AutoGen agent format
+            const autogenConfig = {
+                name: meta.name,
+                description,
+                system_message: role,
+                llm_config: {
+                    config_list: [{ model, api_type: provider === 'anthropic' ? 'anthropic' : 'openai' }],
+                },
+                ...(universalTools.length > 0 ? { tools: universalTools.map((t) => ({ name: t.name, description: t.description })) } : {}),
+            };
+            // Semantic Kernel agent format
+            const semanticKernelConfig = {
+                name: meta.name,
+                description,
+                instructions: role,
+                model: { id: model, provider },
+                plugins: universalTools.map((t) => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema,
+                })),
+            };
+            // kagent.dev CRD reference (not full CRD — use target: kagent for that)
+            const kagentRef = {
+                apiVersion: 'kagent.dev/v1alpha2',
+                kind: 'Agent',
+                metadata: { name: meta.name },
+                spec: {
+                    type: 'Declarative',
+                    declarative: {
+                        modelConfig: `${meta.name}-model-config`,
+                        systemMessage: role,
                     },
-                    usage: `import { GoogleGenerativeAI } from '@google/generative-ai';\nconst genAI = new GoogleGenerativeAI(apiKey);\nconst model = genAI.getGenerativeModel(config);`,
                 },
-                langchain: {
-                    sdk: {
-                        npm: [
-                            'langchain',
-                            '@langchain/core',
-                            '@langchain/openai',
-                            '@langchain/anthropic',
-                        ],
-                        pip: ['langchain', 'langchain-openai', 'langchain-anthropic'],
-                        docs: 'https://js.langchain.com/docs/',
+            };
+            // Extensions from OSSA manifest
+            const extensions = manifest.extensions;
+            const a2aExt = extensions?.a2a;
+            const mcpExt = extensions?.mcp;
+            // Build the comprehensive agent card
+            converted = {
+                // --- Core identity (OSSA source of truth) ---
+                name: meta.name,
+                version: meta.version || '1.0.0',
+                description,
+                url: `https://openstandardagents.org/agents/${meta.name}`,
+                ossaVersion: manifest.apiVersion || 'ossa/v0.4',
+                kind: manifest.kind || 'Agent',
+                // --- The OSSA contract (identity + capabilities + constraints) ---
+                ossa: {
+                    role,
+                    capabilities: (manifest.spec?.capabilities || []),
+                    ...(manifest.spec?.autonomy ? { autonomy: manifest.spec.autonomy } : {}),
+                    ...(manifest.spec?.safety ? { safety: manifest.spec.safety } : {}),
+                    ...(manifest.spec?.observability ? { observability: manifest.spec.observability } : {}),
+                    ...(manifest.spec?.access ? { access: manifest.spec.access } : {}),
+                },
+                // --- A2A discovery (Google Agent-to-Agent protocol) ---
+                capabilities: {
+                    streaming: true,
+                    pushNotifications: false,
+                    stateTransitionHistory: true,
+                },
+                skills: a2aSkills,
+                defaultInputModes: ['application/json', 'text/plain'],
+                defaultOutputModes: ['application/json', 'text/plain'],
+                // --- MCP tools (Model Context Protocol) ---
+                mcp: {
+                    tools: mcpTools,
+                    ...(mcpExt?.servers ? { servers: mcpExt.servers } : {}),
+                    ...(mcpExt?.resources ? { resources: mcpExt.resources } : {}),
+                },
+                // --- Platform adapters (use these directly in your framework) ---
+                // Each adapter includes: sdk (npm/pip packages), config (ready-to-use), usage (code snippet)
+                adapters: {
+                    openai: {
+                        sdk: { npm: 'openai', pip: 'openai', docs: 'https://platform.openai.com/docs/api-reference' },
+                        config: {
+                            model,
+                            messages: [{ role: 'system', content: role }],
+                            tools: openaiTools,
+                            tool_choice: 'auto',
+                        },
+                        usage: `import OpenAI from 'openai';\nconst client = new OpenAI();\nconst response = await client.chat.completions.create(config);`,
                     },
-                    config: {
-                        _type: 'agent',
-                        name: meta.name,
-                        llm: {
-                            _type: provider === 'anthropic' ? 'ChatAnthropic' : 'ChatOpenAI',
-                            model_name: model,
+                    anthropic: {
+                        sdk: { npm: '@anthropic-ai/sdk', pip: 'anthropic', docs: 'https://docs.anthropic.com/en/api' },
+                        config: {
+                            model: provider === 'anthropic' ? model : 'claude-sonnet-4-20250514',
+                            system: role,
+                            tools: anthropicTools,
+                            max_tokens: llm?.maxTokens || 4096,
                         },
-                        system_message: role,
-                        tools: langchainTools,
+                        usage: `import Anthropic from '@anthropic-ai/sdk';\nconst client = new Anthropic();\nconst response = await client.messages.create(config);`,
                     },
-                    usage: `from langchain.agents import create_tool_calling_agent\nagent = create_tool_calling_agent(llm, tools, prompt)`,
-                },
-                langflow: {
-                    sdk: { pip: 'langflow', docs: 'https://docs.langflow.org/' },
-                    config: langflowComponent,
-                    usage: 'Import as custom component in LangFlow UI or use langflow CLI',
-                },
-                crewai: {
-                    sdk: { pip: 'crewai', docs: 'https://docs.crewai.com/' },
-                    config: {
-                        agents: [
-                            {
-                                role: meta.name,
-                                goal: description,
-                                backstory: role,
-                                llm: model,
-                                tools: crewaiTools,
+                    google_genai: {
+                        sdk: { npm: '@google/generative-ai', pip: 'google-generativeai', docs: 'https://ai.google.dev/docs' },
+                        config: {
+                            model: 'gemini-2.0-flash',
+                            systemInstruction: role,
+                            tools: [{ functionDeclarations: openaiTools.map((t) => t.function) }],
+                        },
+                        usage: `import { GoogleGenerativeAI } from '@google/generative-ai';\nconst genAI = new GoogleGenerativeAI(apiKey);\nconst model = genAI.getGenerativeModel(config);`,
+                    },
+                    langchain: {
+                        sdk: {
+                            npm: ['langchain', '@langchain/core', '@langchain/openai', '@langchain/anthropic'],
+                            pip: ['langchain', 'langchain-openai', 'langchain-anthropic'],
+                            docs: 'https://js.langchain.com/docs/',
+                        },
+                        config: {
+                            _type: 'agent',
+                            name: meta.name,
+                            llm: {
+                                _type: provider === 'anthropic' ? 'ChatAnthropic' : 'ChatOpenAI',
+                                model_name: model,
                             },
-                        ],
+                            system_message: role,
+                            tools: langchainTools,
+                        },
+                        usage: `from langchain.agents import create_tool_calling_agent\nagent = create_tool_calling_agent(llm, tools, prompt)`,
                     },
-                    usage: `from crewai import Agent\nagent = Agent(role=config['role'], goal=config['goal'], backstory=config['backstory'])`,
-                },
-                autogen: {
-                    sdk: {
-                        pip: 'autogen-agentchat',
-                        docs: 'https://microsoft.github.io/autogen/',
+                    langflow: {
+                        sdk: { pip: 'langflow', docs: 'https://docs.langflow.org/' },
+                        config: langflowComponent,
+                        usage: 'Import as custom component in LangFlow UI or use langflow CLI',
                     },
-                    config: autogenConfig,
-                    usage: `from autogen import ConversableAgent\nagent = ConversableAgent(name=config['name'], system_message=config['system_message'], llm_config=config['llm_config'])`,
-                },
-                semantic_kernel: {
-                    sdk: {
-                        npm: 'semantic-kernel',
-                        pip: 'semantic-kernel',
-                        docs: 'https://learn.microsoft.com/en-us/semantic-kernel/',
+                    crewai: {
+                        sdk: { pip: 'crewai', docs: 'https://docs.crewai.com/' },
+                        config: {
+                            agents: [{
+                                    role: meta.name,
+                                    goal: description,
+                                    backstory: role,
+                                    llm: model,
+                                    tools: crewaiTools,
+                                }],
+                        },
+                        usage: `from crewai import Agent\nagent = Agent(role=config['role'], goal=config['goal'], backstory=config['backstory'])`,
                     },
-                    config: semanticKernelConfig,
-                    usage: `import semantic_kernel as sk\nkernel = sk.Kernel()\nkernel.add_chat_service("default", OpenAIChatCompletion(config['execution_settings']['default']['model_id']))`,
-                },
-                llamaindex: {
-                    sdk: {
-                        npm: 'llamaindex',
-                        pip: 'llama-index',
-                        docs: 'https://docs.llamaindex.ai/',
+                    autogen: {
+                        sdk: { pip: 'autogen-agentchat', docs: 'https://microsoft.github.io/autogen/' },
+                        config: autogenConfig,
+                        usage: `from autogen import ConversableAgent\nagent = ConversableAgent(name=config['name'], system_message=config['system_message'], llm_config=config['llm_config'])`,
                     },
-                    config: {
-                        name: meta.name,
-                        description,
-                        system_prompt: role,
-                        llm: { model, provider },
-                        tools: universalTools.map((t) => ({
-                            name: t.name,
-                            description: t.description,
-                            fn_schema: t.inputSchema,
-                        })),
+                    semantic_kernel: {
+                        sdk: { npm: 'semantic-kernel', pip: 'semantic-kernel', docs: 'https://learn.microsoft.com/en-us/semantic-kernel/' },
+                        config: semanticKernelConfig,
+                        usage: `import semantic_kernel as sk\nkernel = sk.Kernel()\nkernel.add_chat_service("default", OpenAIChatCompletion(config['execution_settings']['default']['model_id']))`,
                     },
-                    usage: `from llama_index.agent.openai import OpenAIAgent\nagent = OpenAIAgent.from_tools(tools, system_prompt=config['system_prompt'])`,
-                },
-                dspy: {
-                    sdk: { pip: 'dspy', docs: 'https://dspy.ai/' },
-                    config: {
-                        name: meta.name,
-                        instructions: role,
-                        lm: `${provider}/${model}`,
-                        tools: universalTools.map((t) => t.name),
+                    llamaindex: {
+                        sdk: { npm: 'llamaindex', pip: 'llama-index', docs: 'https://docs.llamaindex.ai/' },
+                        config: {
+                            name: meta.name,
+                            description,
+                            system_prompt: role,
+                            llm: { model, provider },
+                            tools: universalTools.map((t) => ({ name: t.name, description: t.description, fn_schema: t.inputSchema })),
+                        },
+                        usage: `from llama_index.agent.openai import OpenAIAgent\nagent = OpenAIAgent.from_tools(tools, system_prompt=config['system_prompt'])`,
                     },
-                    usage: `import dspy\nlm = dspy.LM('${provider}/${model}')\ndspy.configure(lm=lm)`,
-                },
-                kagent: {
-                    sdk: { docs: 'https://kagent.dev/docs' },
-                    config: kagentRef,
-                    usage: 'kubectl apply -f <converted>.kagent.yaml  # Use target: kagent for full CRD output',
-                },
-                gitlab_duo: {
-                    sdk: { docs: 'https://docs.gitlab.com/ee/user/gitlab_duo/' },
-                    config: {
-                        name: meta.name,
-                        description,
-                        system_prompt: role,
-                        model: provider === 'anthropic' ? model : 'claude-sonnet-4-20250514',
-                        tools: universalTools.map((t) => ({ name: t.name })),
+                    dspy: {
+                        sdk: { pip: 'dspy', docs: 'https://dspy.ai/' },
+                        config: {
+                            name: meta.name,
+                            instructions: role,
+                            lm: `${provider}/${model}`,
+                            tools: universalTools.map((t) => t.name),
+                        },
+                        usage: `import dspy\nlm = dspy.LM('${provider}/${model}')\ndspy.configure(lm=lm)`,
                     },
-                    usage: 'Place in .gitlab/duo/agents/ directory',
-                },
-                claude_agent_sdk: {
-                    sdk: {
-                        npm: '@anthropic-ai/claude-agent-sdk',
-                        pip: 'claude-agent-sdk',
-                        go: 'github.com/M1n9X/claude-agent-sdk-go',
-                        rust: 'claude_agent',
-                        docs: 'https://docs.claude.com/en/api/agent-sdk/overview',
+                    kagent: {
+                        sdk: { docs: 'https://kagent.dev/docs' },
+                        config: kagentRef,
+                        usage: 'kubectl apply -f <converted>.kagent.yaml  # Use target: kagent for full CRD output',
                     },
-                    config: {
-                        systemPrompt: role,
-                        model: provider === 'anthropic' ? model : 'claude-sonnet-4-20250514',
-                        allowedTools: universalTools.map((t) => t.name),
+                    gitlab_duo: {
+                        sdk: { docs: 'https://docs.gitlab.com/ee/user/gitlab_duo/' },
+                        config: {
+                            name: meta.name,
+                            description,
+                            system_prompt: role,
+                            model: provider === 'anthropic' ? model : 'claude-sonnet-4-20250514',
+                            tools: universalTools.map((t) => ({ name: t.name })),
+                        },
+                        usage: 'Place in .gitlab/duo/agents/ directory',
                     },
-                    usage: `import { query } from '@anthropic-ai/claude-agent-sdk';\nconst conversation = query({ prompt, options: config });\nfor await (const msg of conversation) { /* handle */ }`,
                 },
-            },
-            // --- A2A protocol details (if defined in OSSA extensions) ---
-            ...(a2aExt
-                ? {
+                // --- A2A protocol details (if defined in OSSA extensions) ---
+                ...(a2aExt ? {
                     a2a: {
                         ...(a2aExt.protocol ? { protocol: a2aExt.protocol } : {}),
                         ...(a2aExt.endpoints ? { endpoints: a2aExt.endpoints } : {}),
                         ...(a2aExt.routing ? { routing: a2aExt.routing } : {}),
                         ...(a2aExt.delegation ? { delegation: a2aExt.delegation } : {}),
                     },
-                }
-                : {}),
-            // --- Full OSSA agent card (from generator) ---
-            ...(cardResult.success && cardResult.card
-                ? {
+                } : {}),
+                // --- Full OSSA agent card (from generator) ---
+                ...(cardResult.success && cardResult.card ? {
                     _agentCard: cardResult.card,
-                }
-                : {}),
-        };
-        filename = 'agent-card.json';
-    }
-    else if (input.target === 'claude-agent-sdk') {
-        // Generate Claude Agent SDK application config (TypeScript + Python)
-        const sdkTools = (manifest.spec?.tools || []);
-        const sdkLlm = manifest.spec?.llm;
-        const sdkModel = (typeof sdkLlm === 'string' ? sdkLlm : sdkLlm?.model) ||
-            'claude-sonnet-4-20250514';
-        const sdkRole = manifest.spec?.role || '';
-        const sdkCaps = (manifest.spec?.capabilities || []).map((c) => typeof c === 'string' ? c : c.name || '');
-        // Map capabilities to Claude Agent SDK built-in tools
-        const builtInTools = [];
-        const capToolMap = {
-            'web-search': ['WebSearch', 'WebFetch'],
-            'file-access': ['Read', 'Write', 'Edit', 'Glob', 'Grep'],
-            'file-read': ['Read', 'Glob', 'Grep'],
-            'file-write': ['Read', 'Write', 'Edit'],
-            'code-execution': ['Bash'],
-            shell: ['Bash'],
-            bash: ['Bash'],
-            'code-analysis': ['Read', 'Glob', 'Grep'],
-            explore: ['Read', 'Glob', 'Grep'],
-        };
-        for (const cap of sdkCaps) {
-            const mapped = capToolMap[cap];
-            if (mapped) {
-                for (const t of mapped) {
-                    if (!builtInTools.includes(t))
-                        builtInTools.push(t);
-                }
-            }
-        }
-        // Map MCP servers from tools
-        const mcpServers = {};
-        const customTools = [];
-        for (const tool of sdkTools) {
-            if (tool.type === 'mcp' && tool.server) {
-                const sname = String(tool.server);
-                if (!mcpServers[sname]) {
-                    mcpServers[sname] = {
-                        type: tool.transport || 'stdio',
-                        ...(tool.command ? { command: tool.command } : {}),
-                        ...(tool.args ? { args: tool.args } : {}),
-                        ...(tool.url ? { url: tool.url } : {}),
-                    };
-                }
-            }
-            else {
-                customTools.push({
-                    name: tool.name || 'unnamed',
-                    description: tool.description || '',
-                    inputSchema: tool.inputSchema ||
-                        tool.input_schema ||
-                        tool.parameters || { type: 'object', properties: {} },
-                });
-            }
-        }
-        // Map autonomy to permission mode
-        const sdkAutonomy = manifest.spec?.autonomy;
-        let permissionMode = 'default';
-        if (sdkAutonomy) {
-            const level = sdkAutonomy.level || '';
-            if (level === 'full' || level === 'autonomous')
-                permissionMode = 'bypassPermissions';
-            else if (level === 'supervised')
-                permissionMode = 'acceptEdits';
-            else if (level === 'planning')
-                permissionMode = 'planMode';
+                } : {}),
+            };
+            filename = 'agent-card.json';
+            break;
         }
-        // Resolve Claude model name
-        let claudeModel = 'claude-sonnet-4-20250514';
-        if (sdkModel.includes('opus'))
-            claudeModel = 'claude-opus-4-20250514';
-        else if (sdkModel.includes('haiku'))
-            claudeModel = 'claude-haiku-4-5-20251001';
-        else if (sdkModel.includes('sonnet'))
-            claudeModel = 'claude-sonnet-4-20250514';
-        else if (sdkModel.includes('claude'))
-            claudeModel = sdkModel;
-        converted = {
-            name: meta.name,
-            version: meta.version || '1.0.0',
-            description: meta.description || '',
-            ossaVersion: manifest.apiVersion || 'ossa/v0.4',
-            // Claude Agent SDK configuration
-            sdk: {
-                typescript: {
-                    package: '@anthropic-ai/claude-agent-sdk',
-                    install: 'npm install @anthropic-ai/claude-agent-sdk',
-                    docs: 'https://docs.claude.com/en/api/agent-sdk/typescript',
-                },
-                python: {
-                    package: 'claude-agent-sdk',
-                    install: 'pip install claude-agent-sdk',
-                    docs: 'https://docs.claude.com/en/api/agent-sdk/python',
-                },
-                go: {
-                    package: 'github.com/M1n9X/claude-agent-sdk-go',
-                    install: 'go get github.com/M1n9X/claude-agent-sdk-go',
-                    docs: 'https://github.com/M1n9X/claude-agent-sdk-go',
-                    community: true,
-                },
-                rust: {
-                    package: 'claude_agent',
-                    install: 'cargo add claude_agent',
-                    docs: 'https://crates.io/crates/claude_agent',
-                    community: true,
-                },
-            },
-            // Agent options (ready to use in SDK)
-            options: {
-                systemPrompt: sdkRole,
-                model: claudeModel,
-                permissionMode,
-                ...(builtInTools.length > 0 ? { allowedTools: builtInTools } : {}),
-                ...(Object.keys(mcpServers).length > 0 ? { mcpServers } : {}),
-            },
-            // Custom tools (need implementation)
-            ...(customTools.length > 0 ? { customTools } : {}),
-            // TypeScript usage
-            usage: {
-                typescript: `import { query } from '@anthropic-ai/claude-agent-sdk';\n\nconst conversation = query({\n  prompt: 'Your prompt here',\n  options: ${JSON.stringify({ systemPrompt: sdkRole.substring(0, 80) + '...', model: claudeModel, permissionMode }, null, 4)}\n});\n\nfor await (const message of conversation) {\n  if (message.type === 'assistant') {\n    for (const block of message.message.content) {\n      if (block.type === 'text') process.stdout.write(block.text);\n    }\n  }\n}`,
-                python: `from claude_agent_sdk import query\n\nasync for message in query(\n    prompt="Your prompt here",\n    options=ClaudeAgentOptions(\n        system_prompt=${JSON.stringify(sdkRole.substring(0, 80) + '...')},\n        model="${claudeModel}",\n        permission_mode="${permissionMode}",\n    )\n):\n    if message.type == "assistant":\n        for block in message.message.content:\n            if hasattr(block, "text"):\n                print(block.text, end="")`,
-            },
-        };
-        filename = `${meta.name}.claude-agent-sdk.json`;
-    }
-    else {
-        // Delegate to adapter registry (config-only + full adapters with toConfig())
-        initializeAdapters();
-        const adapter = convertRegistry.getAdapter(input.target);
-        if (!adapter) {
+        default:
             return errResponse(`Unknown target: ${input.target}`);
-        }
-        try {
-            const result = await adapter.toConfig(manifest);
-            converted = result.config;
-            filename = result.filename;
-        }
-        catch (err) {
-            return errResponse(`toConfig() failed for target "${input.target}": ${err instanceof Error ? err.message : String(err)}`);
-        }
     }
     // Optionally write to disk
     if (input.output_dir) {
@@ -1878,11 +1630,7 @@ async function handleConvert(args) {
             content = JSON.stringify(converted, null, 2);
         }
         fs.writeFileSync(outPath, content, 'utf8');
-        return okResponse({
-            target: input.target,
-            written_to: outPath,
-            content: converted,
-        });
+        return okResponse({ target: input.target, written_to: outPath, content: converted });
     }
     return okResponse({ target: input.target, filename, content: converted });
 }
@@ -1897,11 +1645,7 @@ async function handleWorkspace(args) {
             const wsDir = path.join(dir, '.agents-workspace');
             const registryDir = path.join(wsDir, 'registry');
             if (fs.existsSync(wsDir)) {
-                return okResponse({
-                    action: 'init',
-                    status: 'already_exists',
-                    path: wsDir,
-                });
+                return okResponse({ action: 'init', status: 'already_exists', path: wsDir });
             }
             fs.mkdirSync(registryDir, { recursive: true });
             const wsName = input.name || path.basename(dir);
@@ -1913,31 +1657,13 @@ async function handleWorkspace(args) {
             });
             fs.writeFileSync(path.join(registryDir, 'index.yaml'), indexYaml);
             fs.writeFileSync(path.join(wsDir, 'README.md'), `# OSSA Workspace: ${wsName}\n\nGenerated by OSSA MCP Server.\n\nRun \`ossa workspace discover\` to scan for agents.\n`);
-            return okResponse({
-                action: 'init',
-                status: 'created',
-                path: wsDir,
-                name: wsName,
-            });
+            return okResponse({ action: 'init', status: 'created', path: wsDir, name: wsName });
         }
         case 'discover': {
             // Scan for all *.ossa.yaml manifests
-            const patterns = [
-                '**/*.ossa.yaml',
-                '**/*.ossa.yml',
-                '**/.agents/*/manifest.ossa.yaml',
-            ];
-            const ignorePatterns = [
-                '**/node_modules/**',
-                '**/dist/**',
-                '**/.git/**',
-                '**/coverage/**',
-            ];
-            const files = await fg(patterns, {
-                cwd: dir,
-                ignore: ignorePatterns,
-                absolute: true,
-            });
+            const patterns = ['**/*.ossa.yaml', '**/*.ossa.yml', '**/.agents/*/manifest.ossa.yaml'];
+            const ignorePatterns = ['**/node_modules/**', '**/dist/**', '**/.git/**', '**/coverage/**'];
+            const files = await fg(patterns, { cwd: dir, ignore: ignorePatterns, absolute: true });
             const agents = [];
             for (const f of files) {
                 try {
@@ -1965,12 +1691,7 @@ async function handleWorkspace(args) {
                     workspace: path.basename(dir),
                     discovered: new Date().toISOString(),
                     count: agents.length,
-                    agents: agents.map((a) => ({
-                        name: a.name,
-                        version: a.version,
-                        kind: a.kind,
-                        path: a.path,
-                    })),
+                    agents: agents.map((a) => ({ name: a.name, version: a.version, kind: a.kind, path: a.path })),
                 };
                 fs.writeFileSync(path.join(registryDir, 'index.yaml'), yaml.dump(index));
             }
@@ -1980,18 +1701,10 @@ async function handleWorkspace(args) {
             const wsDir = path.join(dir, '.agents-workspace');
             const indexPath = path.join(wsDir, 'registry', 'index.yaml');
             if (!fs.existsSync(indexPath)) {
-                return okResponse({
-                    action: 'status',
-                    initialized: false,
-                    message: 'Run ossa_workspace with action: init first',
-                });
+                return okResponse({ action: 'status', initialized: false, message: 'Run ossa_workspace with action: init first' });
             }
             const indexContent = yaml.load(fs.readFileSync(indexPath, 'utf8'));
-            return okResponse({
-                action: 'status',
-                initialized: true,
-                workspace: indexContent,
-            });
+            return okResponse({ action: 'status', initialized: true, workspace: indexContent });
         }
     }
 }
@@ -2001,10 +1714,7 @@ async function handleWorkspace(args) {
 /** Recursive deep diff — same algorithm as diff.command.ts (DRY) */
 function deepDiff(obj1, obj2, prefix = '') {
     const changes = [];
-    const allKeys = new Set([
-        ...Object.keys(obj1 || {}),
-        ...Object.keys(obj2 || {}),
-    ]);
+    const allKeys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
     for (const key of allKeys) {
         const fieldPath = prefix ? `${prefix}.${key}` : key;
         const val1 = obj1?.[key];
@@ -2015,21 +1725,13 @@ function deepDiff(obj1, obj2, prefix = '') {
         else if (!(key in (obj2 || {}))) {
             changes.push({ type: 'removed', path: fieldPath, oldValue: val1 });
         }
-        else if (typeof val1 === 'object' &&
-            typeof val2 === 'object' &&
-            val1 !== null &&
-            val2 !== null &&
-            !Array.isArray(val1) &&
-            !Array.isArray(val2)) {
+        else if (typeof val1 === 'object' && typeof val2 === 'object' &&
+            val1 !== null && val2 !== null &&
+            !Array.isArray(val1) && !Array.isArray(val2)) {
             changes.push(...deepDiff(val1, val2, fieldPath));
         }
         else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
-            changes.push({
-                type: 'modified',
-                path: fieldPath,
-                oldValue: val1,
-                newValue: val2,
-            });
+            changes.push({ type: 'modified', path: fieldPath, oldValue: val1, newValue: val2 });
         }
     }
     return changes;
@@ -2038,8 +1740,7 @@ function deepDiff(obj1, obj2, prefix = '') {
 function isBreakingChange(change) {
     if (change.type === 'removed')
         return true;
-    if (change.path.includes('metadata.name') ||
-        change.path.includes('metadata.version'))
+    if (change.path.includes('metadata.name') || change.path.includes('metadata.version'))
         return true;
     if (change.path.includes('spec.role'))
         return true;
@@ -2081,13 +1782,8 @@ async function handleMigrate(args) {
     const detectionResult = await versionDetectionService.detectVersion(manifest);
     const currentVersion = detectionResult.version || manifest.apiVersion || 'unknown';
     const targetVersion = input.target_version;
-    if (currentVersion === targetVersion ||
-        `ossa/${currentVersion}` === targetVersion) {
-        return okResponse({
-            migrated: false,
-            reason: `Already at ${targetVersion}`,
-            manifest_path: manifestPath,
-        });
+    if (currentVersion === targetVersion || `ossa/${currentVersion}` === targetVersion) {
+        return okResponse({ migrated: false, reason: `Already at ${targetVersion}`, manifest_path: manifestPath });
     }
     // Strip 'ossa/' prefix for MigrationTransformService (expects '0.3.3', not 'ossa/v0.3.3')
     const fromVer = currentVersion.replace(/^ossa\/v?/, '');
@@ -2117,26 +1813,11 @@ async function handleMigrate(args) {
         const outDir = resolvePath(input.output_dir);
         fs.mkdirSync(outDir, { recursive: true });
         const outPath = path.join(outDir, path.basename(manifestPath));
-        const output = yaml.dump(migrated, {
-            lineWidth: 120,
-            noRefs: true,
-        });
+        const output = yaml.dump(migrated, { lineWidth: 120, noRefs: true });
         fs.writeFileSync(outPath, output, 'utf8');
-        return okResponse({
-            migrated: true,
-            from: currentVersion,
-            to: targetVersion,
-            migrations,
-            written_to: outPath,
-        });
+        return okResponse({ migrated: true, from: currentVersion, to: targetVersion, migrations, written_to: outPath });
     }
-    return okResponse({
-        migrated: true,
-        from: currentVersion,
-        to: targetVersion,
-        migrations,
-        manifest: migrated,
-    });
+    return okResponse({ migrated: true, from: currentVersion, to: targetVersion, migrations, manifest: migrated });
 }
 // ---------------------------------------------------------------------------
 // Helpers
@@ -2166,12 +1847,7 @@ function okResponse(data) {
 }
 function errResponse(message) {
     return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({ error: message }, null, 2),
-            },
-        ],
+        content: [{ type: 'text', text: JSON.stringify({ error: message }, null, 2) }],
         isError: true,
     };
 }