@bluefly/openstandardagents 0.5.0 → 0.5.3

package/dist/mcp-server/index.js

@@ -1,2190 +0,0 @@
-#!/usr/bin/env node
-/**
- * OSSA MCP Server — Production-grade
- *
- * 10 tools: ossa_validate, ossa_scaffold, ossa_generate, ossa_publish,
- *           ossa_list, ossa_inspect, ossa_convert, ossa_workspace,
- *           ossa_diff, ossa_migrate
- * 4 prompts: create-agent, convert-for-platform, explain-manifest, what-is-ossa
- * 5 resources: schema, minimal template, full template, MCP→OSSA→A2A guide, platforms
- *
- * Open-source stack:
- *  - @modelcontextprotocol/sdk  — MCP protocol
- *  - zod                        — Input validation (runtime type safety)
- *  - pino                       — Structured logging
- *  - fast-glob                  — Workspace agent discovery
- *  - js-yaml                    — YAML parse/serialize
- *  - axios                      — HTTP client (registry publish)
- *  - semver                     — Version parsing and comparison
- */
-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 fg from 'fast-glob';
-import yaml from 'js-yaml';
-import { spawnSync } from 'node:child_process';
-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 { MigrationTransformService } from '../services/migration-transform.service.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 { CursorValidator } from '../services/validators/cursor.validator.js';
-import { KagentValidator } from '../services/validators/kagent.validator.js';
-import { LangChainValidator } from '../services/validators/langchain.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 { 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';
-// ---------------------------------------------------------------------------
-// Logging — pino (structured JSON to stderr so MCP stdio stays clean)
-// ---------------------------------------------------------------------------
-const log = pino({
-    name: 'ossa-mcp',
-    level: process.env.LOG_LEVEL || 'info',
-    transport: process.env.NODE_ENV !== 'production'
-        ? { target: 'pino/file', options: { destination: 2 } } // stderr
-        : undefined,
-});
-// ---------------------------------------------------------------------------
-// Zod input schemas (runtime validation for every tool call)
-// ---------------------------------------------------------------------------
-const ValidateInput = z.object({
-    path: z.string().min(1, 'path is required'),
-    platform: z
-        .enum([
-        'kagent',
-        'langchain',
-        'crewai',
-        'docker',
-        'kubernetes',
-        'gitlab-duo',
-        'anthropic',
-    ])
-        .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'),
-    output_dir: z.string().optional().default('.agents'),
-    description: z.string().optional(),
-    role: z.string().optional(),
-    type: z
-        .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'),
-    output_dir: z.string().optional(),
-});
-const PublishInput = z.object({
-    path: z.string().min(1, 'path is required'),
-    registry_url: z.string().optional(),
-    dry_run: z.boolean().optional().default(false),
-});
-const ListInput = z.object({
-    directory: z.string().optional().default('.'),
-    recursive: z.boolean().optional().default(true),
-    format: z.enum(['summary', 'detailed', 'json']).optional().default('summary'),
-});
-const InspectInput = z.object({
-    path: z.string().min(1, 'path is required'),
-});
-const ConvertInput = z.object({
-    path: z.string().min(1, 'path is required'),
-    target: z.enum([
-        'kagent',
-        'docker',
-        'langchain',
-        'crewai',
-        'gitlab-duo',
-        'anthropic',
-        'openai',
-        'autogen',
-        'semantic-kernel',
-        'a2a',
-        'agent-card',
-        'claude-agent-sdk',
-    ]),
-    output_dir: z.string().optional(),
-});
-const WorkspaceInput = z.object({
-    action: z.enum(['init', 'discover', 'status']),
-    directory: z.string().optional().default('.'),
-    name: z.string().optional(),
-});
-const DiffInput = z.object({
-    path_a: z.string().min(1, 'path_a is required'),
-    path_b: z.string().min(1, 'path_b is required'),
-});
-const MigrateInput = z.object({
-    path: z.string().min(1, 'path is required'),
-    target_version: z.string().optional().default('ossa/v0.4'),
-    output_dir: z.string().optional(),
-});
-// ---------------------------------------------------------------------------
-// DI — wire existing services (single source of truth for all logic)
-// ---------------------------------------------------------------------------
-const manifestRepo = container.get(ManifestRepository);
-const validationService = container.get(ValidationService);
-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
-// ---------------------------------------------------------------------------
-const pkgVersion = getVersion();
-const server = new Server({ name: 'ossa-mcp', version: pkgVersion }, {
-    capabilities: {
-        tools: {},
-        resources: {},
-        prompts: {},
-    },
-});
-// ---------------------------------------------------------------------------
-// Tool definitions
-// ---------------------------------------------------------------------------
-const tools = [
-    {
-        name: 'ossa_validate',
-        description: 'Validate an OSSA agent manifest against the OSSA v0.4 schema. Returns structured validation result with errors, warnings, and platform-specific checks.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                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',
-                    ],
-                    description: 'Optional platform-specific validation',
-                },
-                strict: {
-                    type: 'boolean',
-                    description: 'Enable strict mode (warnings become errors)',
-                    default: false,
-                },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'ossa_scaffold',
-        description: 'Scaffold a new OSSA agent: creates directory structure with manifest.ossa.yaml, prompts/, tools/ stubs, and AGENTS.md.',
-        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',
-                },
-                description: { type: 'string', description: 'Short description' },
-                role: { type: 'string', description: 'System prompt / role' },
-                type: {
-                    type: 'string',
-                    enum: [
-                        'worker',
-                        'orchestrator',
-                        'reviewer',
-                        'analyzer',
-                        'executor',
-                        'approver',
-                    ],
-                    default: 'worker',
-                },
-                version: {
-                    type: 'string',
-                    description: 'Initial version (default: 1.0.0)',
-                },
-            },
-            required: ['name'],
-        },
-    },
-    {
-        name: 'ossa_generate',
-        description: 'Generate .well-known/agent-card.json (A2A discovery) from an OSSA manifest. Optionally writes to disk.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Path to OSSA manifest file' },
-                output_dir: {
-                    type: 'string',
-                    description: 'Optional directory to write agent-card.json',
-                },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'ossa_publish',
-        description: 'Publish an OSSA agent to a registry. Supports: HTTP registry API, arctl CLI, or dry-run mode.',
-        inputSchema: {
-            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,
-                },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'ossa_list',
-        description: 'Discover OSSA agents in a workspace. Scans for manifest.ossa.yaml, agent.ossa.yaml, *.ossa.yaml files using fast-glob.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                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'],
-                    description: 'Output format',
-                    default: 'summary',
-                },
-            },
-        },
-    },
-    {
-        name: 'ossa_inspect',
-        description: 'Deep-inspect an OSSA manifest: metadata, capabilities, tools, access tiers, deployment targets, and dependency analysis.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Path to OSSA manifest file' },
-            },
-            required: ['path'],
-        },
-    },
-    {
-        name: 'ossa_convert',
-        description: 'Convert an OSSA manifest to any agent platform: kagent (K8s), docker-compose, LangChain, CrewAI, GitLab Duo, Anthropic Claude, OpenAI, AutoGen, Semantic Kernel, A2A agent-card (universal cross-platform).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                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',
-                    ],
-                    description: 'Target format',
-                },
-                output_dir: {
-                    type: 'string',
-                    description: 'Optional directory to write converted output',
-                },
-            },
-            required: ['path', 'target'],
-        },
-    },
-    {
-        name: 'ossa_workspace',
-        description: 'Manage OSSA agent workspace: init (create .agents-workspace), discover (scan for all agents), status (show workspace info).',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: {
-                    type: 'string',
-                    enum: ['init', 'discover', 'status'],
-                    description: 'Workspace action',
-                },
-                directory: {
-                    type: 'string',
-                    description: 'Root directory to scan (default: current dir)',
-                },
-                name: { type: 'string', description: 'Workspace name (for init)' },
-            },
-            required: ['action'],
-        },
-    },
-    {
-        name: 'ossa_diff',
-        description: 'Compare two OSSA manifests and show differences: added/removed/changed fields, tool changes, capability changes, breaking changes.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path_a: { type: 'string', description: 'Path to first manifest' },
-                path_b: { type: 'string', description: 'Path to second manifest' },
-            },
-            required: ['path_a', 'path_b'],
-        },
-    },
-    {
-        name: 'ossa_migrate',
-        description: 'Migrate an OSSA manifest to a newer spec version. Updates apiVersion, maps deprecated fields, and validates result.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                path: { type: 'string', description: 'Path to manifest to migrate' },
-                target_version: {
-                    type: 'string',
-                    description: 'Target OSSA version (default: ossa/v0.4)',
-                    default: 'ossa/v0.4',
-                },
-                output_dir: {
-                    type: 'string',
-                    description: 'Optional directory to write migrated manifest',
-                },
-            },
-            required: ['path'],
-        },
-    },
-];
-// ---------------------------------------------------------------------------
-// Resources — expose OSSA schema as an MCP resource
-// ---------------------------------------------------------------------------
-// ---------------------------------------------------------------------------
-// Resources — expose OSSA schemas, examples, and reference docs
-// ---------------------------------------------------------------------------
-server.setRequestHandler(ListResourcesRequestSchema, async () => ({
-    resources: [
-        {
-            uri: 'ossa://schema/v0.4/agent',
-            name: 'OSSA Agent Schema v0.4',
-            description: 'JSON Schema for OSSA v0.4 agent manifests',
-            mimeType: 'application/schema+json',
-        },
-        {
-            uri: 'ossa://template/minimal',
-            name: 'Minimal OSSA Manifest',
-            description: 'Minimal valid OSSA manifest template (copy-paste starter)',
-            mimeType: 'text/yaml',
-        },
-        {
-            uri: 'ossa://template/full',
-            name: 'Full OSSA Manifest Template',
-            description: 'Complete OSSA manifest with all fields (identity, tools, llm, autonomy, safety, observability, a2a, mcp)',
-            mimeType: 'text/yaml',
-        },
-        {
-            uri: 'ossa://guide/mcp-ossa-a2a',
-            name: 'MCP → OSSA → A2A Guide',
-            description: 'How OSSA bridges MCP (tools) and A2A (communication) — the missing agent contract',
-            mimeType: 'text/markdown',
-        },
-        {
-            uri: 'ossa://platforms/supported',
-            name: 'Supported Platforms',
-            description: 'All platforms OSSA converts to with SDK package references (npm/pip)',
-            mimeType: 'application/json',
-        },
-    ],
-}));
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const baseDir = import.meta.dirname ?? path.dirname(new URL(import.meta.url).pathname);
-    switch (request.params.uri) {
-        case 'ossa://schema/v0.4/agent': {
-            const schemaPath = path.resolve(baseDir, '../../spec/v0.4/agent.schema.json');
-            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,
-                    },
-                ],
-            };
-        }
-        case 'ossa://template/minimal':
-            return {
-                contents: [
-                    {
-                        uri: request.params.uri,
-                        mimeType: 'text/yaml',
-                        text: `apiVersion: ossa/v0.4
-kind: Agent
-metadata:
-  name: my-agent
-  version: 1.0.0
-  description: A helpful agent
-spec:
-  role: You are a helpful assistant.
-`,
-                    },
-                ],
-            };
-        case 'ossa://template/full':
-            return {
-                contents: [
-                    {
-                        uri: request.params.uri,
-                        mimeType: 'text/yaml',
-                        text: `apiVersion: ossa/v0.4
-kind: Agent
-metadata:
-  name: my-agent
-  version: 1.0.0
-  description: A production-ready agent
-  labels:
-    capability: analysis,code-review
-    framework: mcp
-  tags: [ai, agent, mcp]
-
-spec:
-  role: >-
-    You are an expert assistant that helps with analysis and code review.
-    Follow best practices and be thorough.
-
-  llm:
-    provider: anthropic
-    model: claude-sonnet-4-20250514
-    temperature: 0.7
-    maxTokens: 4096
-
-  tools:
-    - name: analyze
-      description: Analyze code for quality issues
-      type: mcp
-      server: code-analysis-server
-      inputSchema:
-        type: object
-        properties:
-          code: { type: string }
-          language: { type: string }
-        required: [code]
-
-  capabilities:
-    - id: code-analysis
-      description: Static code analysis
-    - id: review
-      description: Code review with suggestions
-
-  autonomy:
-    level: semi-autonomous
-    approval_required: true
-    allowed_actions: [read, analyze, suggest]
-    blocked_actions: [delete, deploy]
-
-  safety:
-    content_filters: true
-    pii_detection: true
-    max_output_tokens: 8192
-
-  observability:
-    tracing:
-      enabled: true
-      exporter: otlp
-    metrics:
-      enabled: true
-    logging:
-      level: info
-      format: json
-
-  access:
-    tier: tier_2_write_limited
-
-extensions:
-  mcp:
-    servers:
-      - name: code-analysis-server
-        transport:
-          type: stdio
-          command: npx
-          args: [code-analysis-mcp]
-
-  a2a:
-    protocol:
-      type: a2a
-      version: "1.0"
-    endpoints:
-      http: https://my-agent.example.com/a2a
-
-token_efficiency:
-  serialization_profile: compact
-  budget:
-    max_input_tokens: 100000
-  routing:
-    cascade:
-      - model: claude-haiku-4-5-20251001
-        max_tokens: 1000
-      - model: claude-sonnet-4-20250514
-        max_tokens: 4096
-`,
-                    },
-                ],
-            };
-        case 'ossa://guide/mcp-ossa-a2a':
-            return {
-                contents: [
-                    {
-                        uri: request.params.uri,
-                        mimeType: 'text/markdown',
-                        text: `# MCP → OSSA → A2A: The Agent Stack
-
-## The Problem
-Agent ecosystems have **tools** (MCP) and **communication** (A2A/Google), but no standard way to define **what an agent IS**.
-
-## The Solution: OSSA
-OSSA (Open Standard for Software Agents) is the missing contract layer:
-
-\`\`\`
-┌─────────────────────────────────────┐
-│         A2A (Communication)          │
-│   How agents talk to each other      │
-│   Skills, Tasks, Agent Cards         │
-├─────────────────────────────────────┤
-│         OSSA (Contract)              │
-│   What the agent IS                  │
-│   Identity, Capabilities, Governance │
-│   Safety, Autonomy, Deployment       │
-├─────────────────────────────────────┤
-│         MCP (Tools)                  │
-│   What the agent CAN DO             │
-│   Servers, Resources, Prompts        │
-└─────────────────────────────────────┘
-\`\`\`
-
-## How It Works
-
-1. **Define once** in OSSA manifest (YAML):
-   - Identity: name, version, role, capabilities
-   - Tools: MCP servers and tool definitions
-   - LLM: provider, model, parameters
-   - Governance: autonomy, safety, access tiers
-   - Observability: tracing, metrics, logging
-
-2. **Convert to any platform** via \`ossa_convert\`:
-   - **kagent** → Kubernetes CRDs (Agent + ModelConfig)
-   - **OpenAI** → Assistants API / function_calling
-   - **Anthropic** → Messages API with tool_use
-   - **LangChain** → Agent with StructuredTools
-   - **CrewAI** → Agent with role/goal/backstory
-   - **AutoGen** → ConversableAgent config
-   - **agent-card** → Universal cross-platform card
-
-3. **Discover via A2A** using generated agent-card.json:
-   - Skills from OSSA capabilities
-   - Endpoints from OSSA extensions.a2a
-   - MCP tools from OSSA spec.tools
-
-## Key Insight
-**MCP defines tools. A2A defines communication. OSSA defines the agent.**
-Without OSSA, you have tools and chat but no portable agent identity.
-
-## Get Started
-\`\`\`bash
-npm install @bluefly/openstandardagents
-npx ossa scaffold my-agent
-npx ossa validate .agents/my-agent/manifest.ossa.yaml
-npx ossa convert .agents/my-agent/manifest.ossa.yaml --target agent-card
-\`\`\`
-
-## Links
-- Spec: https://openstandardagents.org
-- npm: https://www.npmjs.com/package/@bluefly/openstandardagents
-- MCP Server: \`npx ossa-mcp\` (this server)
-`,
-                    },
-                ],
-            };
-        case 'ossa://platforms/supported':
-            return {
-                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)',
-                                },
-                            ],
-                            total: 15,
-                            ossa_version: 'ossa/v0.4',
-                        }, null, 2),
-                    },
-                ],
-            };
-        default:
-            throw new Error(`Unknown resource: ${request.params.uri}`);
-    }
-});
-// ---------------------------------------------------------------------------
-// Prompts — conversation starters for LLMs using OSSA
-// ---------------------------------------------------------------------------
-server.setRequestHandler(ListPromptsRequestSchema, async () => ({
-    prompts: [
-        {
-            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: 'convert-for-platform',
-            description: 'Convert an existing OSSA manifest to a target platform',
-            arguments: [
-                { name: 'path', description: 'Path to OSSA manifest', required: true },
-                { name: 'platform', description: 'Target platform', required: true },
-            ],
-        },
-        {
-            name: 'explain-manifest',
-            description: 'Explain what an OSSA manifest does in plain language',
-            arguments: [
-                { name: 'path', description: 'Path to OSSA manifest', required: true },
-            ],
-        },
-        {
-            name: 'what-is-ossa',
-            description: 'Explain OSSA and how it bridges MCP and A2A',
-        },
-    ],
-}));
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    switch (request.params.name) {
-        case 'create-agent':
-            return {
-                description: 'Create a new OSSA agent',
-                messages: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: `Create a new OSSA agent that does the following: ${request.params.arguments?.description || 'a helpful assistant'}.
-
-Use the ossa_scaffold tool to create the directory structure, then customize the manifest. The agent name should be: ${request.params.arguments?.name || 'auto-detect from description'}.
-
-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: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: `Convert the OSSA manifest at ${request.params.arguments?.path || './manifest.ossa.yaml'} to ${request.params.arguments?.platform || 'agent-card'} format.
-
-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: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: `Inspect the OSSA manifest at ${request.params.arguments?.path || './manifest.ossa.yaml'} using ossa_inspect and explain:
-1. What this agent does (role and capabilities)
-2. What tools it has access to
-3. What LLM it uses
-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: [
-                    {
-                        role: 'user',
-                        content: {
-                            type: 'text',
-                            text: `Explain OSSA (Open Standard for Software Agents) and how it bridges MCP and A2A.
-
-Read the ossa://guide/mcp-ossa-a2a resource for the full explanation. Key points:
-- MCP defines tools (what agents CAN DO)
-- A2A defines communication (how agents TALK)
-- OSSA defines the agent contract (what the agent IS)
-
-Show the supported platforms using the ossa://platforms/supported resource.`,
-                        },
-                    },
-                ],
-            };
-        default:
-            throw new Error(`Unknown prompt: ${request.params.name}`);
-    }
-});
-// ---------------------------------------------------------------------------
-// Tool handlers
-// ---------------------------------------------------------------------------
-server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    if (!args)
-        return errResponse('Missing arguments');
-    const startMs = Date.now();
-    log.info({ tool: name, args }, 'tool call');
-    try {
-        const result = await dispatch(name, args);
-        log.info({ tool: name, durationMs: Date.now() - startMs }, 'tool complete');
-        return result;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log.error({ tool: name, error: message }, 'tool failed');
-        return errResponse(message);
-    }
-});
-async function dispatch(name, args) {
-    switch (name) {
-        case 'ossa_validate':
-            return handleValidate(args);
-        case 'ossa_scaffold':
-            return handleScaffold(args);
-        case 'ossa_generate':
-            return handleGenerate(args);
-        case 'ossa_publish':
-            return handlePublish(args);
-        case 'ossa_list':
-            return handleList(args);
-        case 'ossa_inspect':
-            return handleInspect(args);
-        case 'ossa_convert':
-            return handleConvert(args);
-        case 'ossa_workspace':
-            return handleWorkspace(args);
-        case 'ossa_diff':
-            return handleDiff(args);
-        case 'ossa_migrate':
-            return handleMigrate(args);
-        default:
-            return errResponse(`Unknown tool: ${name}`);
-    }
-}
-// ---------------------------------------------------------------------------
-// Platform validator registry (maps platform names to validator instances)
-// ---------------------------------------------------------------------------
-const platformValidatorRegistry = new Map([
-    ['cursor', new CursorValidator()],
-    ['openai_agents', new OpenAIValidator()],
-    ['crewai', new CrewAIValidator()],
-    ['langchain', new LangChainValidator()],
-    ['anthropic', new AnthropicValidator()],
-    ['langflow', new LangflowValidator()],
-    ['autogen', new AutoGenValidator()],
-    ['vercel_ai', new VercelAIValidator()],
-    ['llamaindex', new LlamaIndexValidator()],
-    ['langgraph', new LangGraphValidator()],
-    ['kagent', new KagentValidator()],
-]);
-// ---------------------------------------------------------------------------
-// ossa_validate
-// ---------------------------------------------------------------------------
-async function handleValidate(args) {
-    const input = ValidateInput.parse(args);
-    const manifestPath = resolvePath(input.path);
-    const manifest = await manifestRepo.load(manifestPath);
-    const result = await validationService.validate(manifest);
-    // Platform-specific validation: when platform is specified, run the
-    // targeted validator explicitly and merge results
-    let platformErrors = [];
-    let platformWarnings = [];
-    if (input.platform) {
-        const validator = platformValidatorRegistry.get(input.platform);
-        if (validator) {
-            const platformResult = validator.validate(manifest);
-            platformErrors = platformResult.errors || [];
-            platformWarnings = platformResult.warnings || [];
-            // If no extension exists for this platform, add a warning
-            const extensions = manifest.extensions;
-            if (!extensions?.[input.platform]) {
-                platformWarnings.push(`Platform '${input.platform}': No extensions.${input.platform} section found in manifest. ` +
-                    `Add extensions.${input.platform} to enable platform-specific features.`);
-            }
-            // Merge platform results into base results
-            if (platformErrors.length) {
-                result.errors = [
-                    ...(result.errors || []),
-                    ...platformErrors,
-                ];
-                result.valid = false;
-            }
-            if (platformWarnings.length) {
-                result.warnings = [...(result.warnings || []), ...platformWarnings];
-            }
-        }
-    }
-    // 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.valid = !result.errors?.length;
-    }
-    return okResponse({
-        valid: result.valid,
-        errors: result.errors || [],
-        warnings: result.warnings || [],
-        manifest_path: manifestPath,
-        platform: input.platform || null,
-        platform_validation: input.platform
-            ? {
-                platform: input.platform,
-                errors: platformErrors,
-                warnings: platformWarnings,
-            }
-            : undefined,
-    });
-}
-// ---------------------------------------------------------------------------
-// ossa_scaffold
-// ---------------------------------------------------------------------------
-async function handleScaffold(args) {
-    const input = ScaffoldInput.parse(args);
-    const outputDir = resolvePath(input.output_dir);
-    const agentDir = path.join(outputDir, input.name);
-    if (fs.existsSync(agentDir)) {
-        return errResponse(`Directory already exists: ${agentDir}`);
-    }
-    const typeConfigs = getAgentTypeConfigs();
-    const typeConfig = typeConfigs[input.type] || typeConfigs.worker;
-    const manifest = {
-        apiVersion: getApiVersion(),
-        kind: getDefaultAgentKind(),
-        metadata: {
-            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 }]
-                : [],
-        },
-    };
-    // Create directory structure
-    fs.mkdirSync(agentDir, { recursive: true });
-    fs.mkdirSync(path.join(agentDir, 'prompts'), { recursive: true });
-    fs.mkdirSync(path.join(agentDir, 'tools'), { recursive: true });
-    // Write manifest
-    const manifestPath = path.join(agentDir, 'manifest.ossa.yaml');
-    await manifestRepo.save(manifestPath, manifest);
-    // Write AGENTS.md stub
-    const agentsMd = `# ${input.name}\n\n${manifest.metadata?.description || ''}\n\n## Tools\n\nTBD\n\n## Usage\n\n\`\`\`bash\nossa validate .agents/${input.name}/manifest.ossa.yaml\n\`\`\`\n`;
-    fs.writeFileSync(path.join(agentDir, 'AGENTS.md'), agentsMd, 'utf8');
-    return okResponse({
-        success: true,
-        manifest_path: manifestPath,
-        agent_dir: agentDir,
-        files_created: ['manifest.ossa.yaml', 'AGENTS.md', 'prompts/', 'tools/'],
-    });
-}
-// ---------------------------------------------------------------------------
-// ossa_generate
-// ---------------------------------------------------------------------------
-async function handleGenerate(args) {
-    const input = GenerateInput.parse(args);
-    const manifestPath = resolvePath(input.path);
-    const manifest = await manifestRepo.load(manifestPath);
-    const result = agentCardGenerator.generate(manifest);
-    if (!result.success) {
-        return errResponse(JSON.stringify({ errors: result.errors, warnings: result.warnings }));
-    }
-    // Optionally write to disk
-    if (input.output_dir) {
-        const outDir = resolvePath(input.output_dir);
-        const wellKnown = path.join(outDir, '.well-known');
-        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 });
-}
-// ---------------------------------------------------------------------------
-// ossa_publish
-// ---------------------------------------------------------------------------
-async function handlePublish(args) {
-    const input = PublishInput.parse(args);
-    const manifestPath = resolvePath(input.path);
-    const manifest = await manifestRepo.load(manifestPath);
-    const cardResult = agentCardGenerator.generate(manifest);
-    const payload = {
-        manifest,
-        agent_card: cardResult.success ? cardResult.card : undefined,
-        manifest_path: manifestPath,
-    };
-    // 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;
-        return okResponse({
-            dry_run: true,
-            payload,
-            local_publish: {
-                registry_path: path.join(process.cwd(), '.ossa-registry'),
-                agent_id: manifest.metadata?.name || 'unknown-agent',
-                version: manifest.metadata?.version || '1.0.0',
-            },
-            remote_publish: registryUrl
-                ? {
-                    registry_url: registryUrl,
-                    url: registryUrl.replace(/\/?$/, '/api/v1/agents'),
-                }
-                : null,
-            message: 'Payload that would be sent to local and/or remote registry',
-        });
-    }
-    // Always publish locally via RegistryService (DI)
-    let localResult = null;
-    try {
-        const publishRequest = {
-            manifest,
-            version: manifest.metadata?.version,
-        };
-        const entry = await registryService.publish(publishRequest);
-        localResult = {
-            success: true,
-            agent_id: entry.id,
-            version: entry.version,
-            manifest_url: entry.manifest_url,
-            published_at: entry.published_at,
-        };
-    }
-    catch (err) {
-        localResult = {
-            success: false,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-    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');
-        const res = await axios.post(url, payload, {
-            headers: { 'Content-Type': 'application/json' },
-            timeout: 15000,
-            validateStatus: () => true,
-        });
-        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.',
-        });
-    }
-    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,
-        ],
-    });
-}
-// ---------------------------------------------------------------------------
-// ossa_list — workspace discovery via shared manifest scanner
-// Uses src/utils/manifest-scanner.ts for consistent glob patterns and parsing.
-// ---------------------------------------------------------------------------
-async function handleList(args) {
-    const input = ListInput.parse(args);
-    const baseDir = resolvePath(input.directory);
-    const results = await scanManifests(baseDir, {
-        recursive: input.recursive,
-        includeAgentsDirs: true,
-        absolute: true,
-    });
-    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,
-        });
-    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,
-            scan_directory: baseDir,
-            patterns_used: patterns,
-        });
-    }
-    // summary
-    const summary = agents.map((a) => `${a.name}@${a.version} [${a.kind}] — ${a.path}`);
-    return okResponse({ count: agents.length, agents: summary });
-}
-// ---------------------------------------------------------------------------
-// ossa_inspect — deep manifest analysis
-// ---------------------------------------------------------------------------
-async function handleInspect(args) {
-    const input = InspectInput.parse(args);
-    const manifestPath = resolvePath(input.path);
-    // Single load — no double file read
-    const manifest = await manifestRepo.load(manifestPath);
-    const validation = await validationService.validate(manifest);
-    const fileStat = fs.statSync(manifestPath);
-    const meta = manifest.metadata;
-    const spec = manifest.spec;
-    const extensions = manifest.extensions;
-    // Version analysis with semver
-    const versionStr = meta?.version || '0.0.0';
-    const parsed = semver.parse(versionStr);
-    // Tool analysis
-    const specTools = spec?.tools || [];
-    const toolSummary = specTools.map((t) => ({
-        name: t.name || t.type,
-        type: t.type,
-    }));
-    // Access tier detection
-    const access = spec?.access;
-    const autonomy = spec?.autonomy;
-    // Deployment target detection
-    const deployTargets = [];
-    if (extensions) {
-        if (extensions.kagent)
-            deployTargets.push('kagent');
-        if (extensions.docker)
-            deployTargets.push('docker');
-        if (extensions.kubernetes)
-            deployTargets.push('kubernetes');
-    }
-    return okResponse({
-        name: meta?.name,
-        version: versionStr,
-        version_analysis: parsed
-            ? {
-                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,
-        llm: spec?.llm || null,
-        tools: toolSummary,
-        tool_count: specTools.length,
-        access_tier: access?.tier || null,
-        autonomy_level: autonomy?.level || autonomy?.humanInLoop || null,
-        deploy_targets: deployTargets,
-        has_extensions: !!extensions,
-        extension_keys: extensions ? Object.keys(extensions) : [],
-        validation: {
-            valid: validation.valid,
-            error_count: validation.errors?.length || 0,
-            warning_count: validation.warnings?.length || 0,
-        },
-        file_size_bytes: fileStat.size,
-        manifest_path: manifestPath,
-    });
-}
-// ---------------------------------------------------------------------------
-// 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).
-// ---------------------------------------------------------------------------
-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',
-    };
-    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);
-        }
-        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,
-                },
-            },
-        };
-        // 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);`,
-                },
-                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,
-                    },
-                    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) },
-                        ],
-                    },
-                    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)`,
-                },
-                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,
-                            },
-                        ],
-                    },
-                    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/',
-                    },
-                    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/',
-                    },
-                    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/',
-                    },
-                    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'])`,
-                },
-                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)`,
-                },
-                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 })),
-                    },
-                    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',
-                    },
-                    config: {
-                        systemPrompt: role,
-                        model: provider === 'anthropic' ? model : 'claude-sonnet-4-20250514',
-                        allowedTools: universalTools.map((t) => t.name),
-                    },
-                    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: {
-                        ...(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
-                ? {
-                    _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';
-        }
-        // 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) {
-            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) {
-        const outDir = resolvePath(input.output_dir);
-        fs.mkdirSync(outDir, { recursive: true });
-        const outPath = path.join(outDir, filename);
-        // Handle multi-resource YAML (kagent generates Agent + ModelConfig)
-        const multiRes = converted;
-        let content;
-        if (multiRes._ossa_multi_resource && Array.isArray(multiRes.resources)) {
-            content = multiRes.resources
-                .map((r) => yaml.dump(r, { lineWidth: 120, noRefs: true }))
-                .join('---\n');
-        }
-        else if (filename.endsWith('.yaml') || filename.endsWith('.yml')) {
-            content = yaml.dump(converted, { lineWidth: 120, noRefs: true });
-        }
-        else {
-            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, filename, content: converted });
-}
-// ---------------------------------------------------------------------------
-// ossa_workspace — init, discover, status
-// ---------------------------------------------------------------------------
-async function handleWorkspace(args) {
-    const input = WorkspaceInput.parse(args);
-    const dir = resolvePath(input.directory);
-    switch (input.action) {
-        case 'init': {
-            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,
-                });
-            }
-            fs.mkdirSync(registryDir, { recursive: true });
-            const wsName = input.name || path.basename(dir);
-            const indexYaml = yaml.dump({
-                workspace: wsName,
-                version: '1.0.0',
-                created: new Date().toISOString(),
-                agents: [],
-            });
-            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,
-            });
-        }
-        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 agents = [];
-            for (const f of files) {
-                try {
-                    const raw = fs.readFileSync(f, 'utf8');
-                    const m = yaml.load(raw);
-                    const meta = m?.metadata;
-                    agents.push({
-                        name: meta?.name || path.basename(path.dirname(f)),
-                        path: f,
-                        version: meta?.version || '0.0.0',
-                        kind: m?.kind || 'Agent',
-                        description: meta?.description || '',
-                    });
-                }
-                catch {
-                    // Skip unparseable files
-                }
-            }
-            // Write discovery output if .agents-workspace exists
-            const wsDir = path.join(dir, '.agents-workspace');
-            if (fs.existsSync(wsDir)) {
-                const registryDir = path.join(wsDir, 'registry');
-                fs.mkdirSync(registryDir, { recursive: true });
-                const index = {
-                    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,
-                    })),
-                };
-                fs.writeFileSync(path.join(registryDir, 'index.yaml'), yaml.dump(index));
-            }
-            return okResponse({ action: 'discover', count: agents.length, agents });
-        }
-        case 'status': {
-            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',
-                });
-            }
-            const indexContent = yaml.load(fs.readFileSync(indexPath, 'utf8'));
-            return okResponse({
-                action: 'status',
-                initialized: true,
-                workspace: indexContent,
-            });
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// ossa_diff — compare two manifests (recursive deepDiff, same as CLI)
-// ---------------------------------------------------------------------------
-/** 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 || {}),
-    ]);
-    for (const key of allKeys) {
-        const fieldPath = prefix ? `${prefix}.${key}` : key;
-        const val1 = obj1?.[key];
-        const val2 = obj2?.[key];
-        if (!(key in (obj1 || {}))) {
-            changes.push({ type: 'added', path: fieldPath, newValue: val2 });
-        }
-        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)) {
-            changes.push(...deepDiff(val1, val2, fieldPath));
-        }
-        else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
-            changes.push({
-                type: 'modified',
-                path: fieldPath,
-                oldValue: val1,
-                newValue: val2,
-            });
-        }
-    }
-    return changes;
-}
-/** Detect breaking changes (same rules as diff.command.ts) */
-function isBreakingChange(change) {
-    if (change.type === 'removed')
-        return true;
-    if (change.path.includes('metadata.name') ||
-        change.path.includes('metadata.version'))
-        return true;
-    if (change.path.includes('spec.role'))
-        return true;
-    if (change.path.includes('apiVersion'))
-        return true;
-    return false;
-}
-async function handleDiff(args) {
-    const input = DiffInput.parse(args);
-    const pathA = resolvePath(input.path_a);
-    const pathB = resolvePath(input.path_b);
-    if (!fs.existsSync(pathA))
-        return errResponse(`File not found: ${pathA}`);
-    if (!fs.existsSync(pathB))
-        return errResponse(`File not found: ${pathB}`);
-    const manifestA = await manifestRepo.load(pathA);
-    const manifestB = await manifestRepo.load(pathB);
-    // Full recursive diff (catches ALL nested field changes)
-    const allChanges = deepDiff(manifestA, manifestB);
-    const breakingChanges = allChanges.filter(isBreakingChange);
-    return okResponse({
-        path_a: pathA,
-        path_b: pathB,
-        name_a: manifestA.metadata?.name,
-        name_b: manifestB.metadata?.name,
-        total_changes: allChanges.length,
-        breaking_changes: breakingChanges.map((c) => `${c.path}: ${c.type}`),
-        changes: allChanges,
-        compatible: breakingChanges.length === 0,
-    });
-}
-// ---------------------------------------------------------------------------
-// ossa_migrate — delegates to MigrationTransformService (DRY with CLI)
-// ---------------------------------------------------------------------------
-async function handleMigrate(args) {
-    const input = MigrateInput.parse(args);
-    const manifestPath = resolvePath(input.path);
-    const manifest = await manifestRepo.load(manifestPath);
-    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,
-        });
-    }
-    // Strip 'ossa/' prefix for MigrationTransformService (expects '0.3.3', not 'ossa/v0.3.3')
-    const fromVer = currentVersion.replace(/^ossa\/v?/, '');
-    const toVer = targetVersion.replace(/^ossa\/v?/, '');
-    // Try registered transform first (handles all version-specific logic)
-    const transform = migrationTransformService.getTransform(fromVer, toVer);
-    let migrated;
-    const migrations = [];
-    if (transform) {
-        migrated = migrationTransformService.applyTransform(manifest, fromVer, toVer);
-        migrations.push(`${transform.description} (${fromVer} → ${toVer})`);
-        if (transform.breaking)
-            migrations.push('WARNING: This migration contains breaking changes');
-        // Validate migration preserved critical fields
-        const warnings = migrationTransformService.validateMigration(manifest, migrated);
-        if (warnings.length)
-            migrations.push(...warnings.map((w) => `WARN: ${w}`));
-    }
-    else {
-        // Fallback: update apiVersion only (no registered transform for this pair)
-        migrated = JSON.parse(JSON.stringify(manifest));
-        migrated.apiVersion = targetVersion;
-        migrations.push(`apiVersion: ${currentVersion} → ${targetVersion} (no registered transform — apiVersion updated only)`);
-    }
-    // Write output
-    if (input.output_dir) {
-        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,
-        });
-        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,
-        manifest: migrated,
-    });
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Resolve path with traversal guard.
- * Absolute paths are allowed (MCP clients are user-configured and trusted).
- * Relative paths are resolved from cwd and checked for traversal escapes.
- */
-function resolvePath(p) {
-    const s = p.trim();
-    if (path.isAbsolute(s)) {
-        return path.resolve(s);
-    }
-    // Relative path: resolve from cwd and reject if it escapes via ../
-    const resolved = path.resolve(process.cwd(), s);
-    const cwd = path.resolve(process.cwd());
-    if (!resolved.startsWith(cwd + path.sep) && resolved !== cwd) {
-        throw new Error(`Path traversal rejected: relative path "${p}" escapes working directory`);
-    }
-    return resolved;
-}
-function okResponse(data) {
-    return {
-        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
-    };
-}
-function errResponse(message) {
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify({ error: message }, null, 2),
-            },
-        ],
-        isError: true,
-    };
-}
-// ---------------------------------------------------------------------------
-// Main — stdio transport
-// ---------------------------------------------------------------------------
-async function main() {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    log.info({ tools: tools.map((t) => t.name), version: pkgVersion }, 'OSSA MCP server running on stdio');
-}
-main().catch((e) => {
-    log.fatal({ error: e }, 'Fatal error');
-    process.exit(1);
-});
-//# sourceMappingURL=index.js.map