@bluefly/openstandardagents 0.4.3 → 0.4.5

package/dist/cli/commands/wizard-interactive.command.js

@@ -27,7 +27,8 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as yaml from 'yaml';
 import { getApiVersion } from '../../utils/version';
-import { printBanner, printWizardBanner, printTemplates, printCompletion, printProgress, printStep, printSuccess, printInfo, printError, } from '../banner.js';
+import { printBanner, printWizardBanner, printTemplates, printCompletion, printProgress, printStep, printSuccess, printInfo, printWarning, printError, } from '../banner.js';
+import { v5 as uuidv5 } from 'uuid';
 // =============================================================================
 // TEMPLATES & PRESETS
 // =============================================================================
@@ -74,8 +75,16 @@ Guidelines:
                     enabled: true,
                     enforcement_hooks: {
                         pre_write: { enabled: true, action: 'query' },
-                        pre_commit: { enabled: true, action: 'block', check_critical: true },
-                        pre_merge: { enabled: true, action: 'block', require_approval: true },
+                        pre_commit: {
+                            enabled: true,
+                            action: 'block',
+                            check_critical: true,
+                        },
+                        pre_merge: {
+                            enabled: true,
+                            action: 'block',
+                            require_approval: true,
+                        },
                         build: { enabled: true, fail_on_violations: true },
                     },
                 },
@@ -88,7 +97,12 @@ Guidelines:
         description: 'Extract data from websites intelligently',
         category: 'data',
         icon: '🕷️',
-        features: ['HTTP tools', 'Data extraction', 'Rate limiting', 'Error handling'],
+        features: [
+            'HTTP tools',
+            'Data extraction',
+            'Rate limiting',
+            'Error handling',
+        ],
         manifest: {
             metadata: {
                 name: 'web-scraper',
@@ -140,7 +154,12 @@ Best practices:
         description: 'Analyze datasets and generate insights',
         category: 'analytics',
         icon: '📊',
-        features: ['Data processing', 'Statistical analysis', 'Visualization', 'RAG'],
+        features: [
+            'Data processing',
+            'Statistical analysis',
+            'Visualization',
+            'RAG',
+        ],
         manifest: {
             metadata: {
                 name: 'data-analyst',
@@ -275,7 +294,12 @@ Guidelines:
         description: 'Blog posts, documentation, and marketing copy',
         category: 'content',
         icon: '✍️',
-        features: ['SEO optimization', 'Multi-format', 'Brand voice', 'Fact-checking'],
+        features: [
+            'SEO optimization',
+            'Multi-format',
+            'Brand voice',
+            'Fact-checking',
+        ],
         manifest: {
             metadata: {
                 name: 'content-generator',
@@ -368,7 +392,12 @@ Reporting:
         description: 'Automated test generation and execution',
         category: 'quality',
         icon: '🧪',
-        features: ['Test generation', 'Coverage analysis', 'E2E testing', 'Performance testing'],
+        features: [
+            'Test generation',
+            'Coverage analysis',
+            'E2E testing',
+            'Performance testing',
+        ],
         manifest: {
             metadata: {
                 name: 'testing-agent',
@@ -584,9 +613,36 @@ class OSSAWizardV2 {
             await this.selectTemplate();
             // Step 2: Basic Information
             await this.configureBasicInfo();
-            // Step 3: LLM Configuration
+            // Step 3: System Prompt (THE MOST IMPORTANT FIELD)
+            await this.configureSystemPrompt();
+            // Step 4: LLM Configuration
             await this.configureLLM();
-            // Step 4: Feature Selection
+            // Step 5: Tools Configuration (CRITICAL)
+            await this.configureToolsCore();
+            // Step 6: Autonomy & Constraints
+            await this.configureAutonomy();
+            await this.configureConstraints();
+            // Step 7: Identity & Access Control
+            await this.configureIdentity();
+            await this.configureAccessControl();
+            // Step 8: Agent Type & Taxonomy
+            await this.configureAgentType();
+            await this.configureTaxonomy();
+            // Step 9: Compliance & Governance
+            await this.configureCompliance();
+            // Step 10: Lifecycle Management
+            await this.configureLifecycle();
+            // Step 11: Token Efficiency (v0.4 REVOLUTIONARY)
+            await this.configureTokenEfficiency();
+            // Step 12: Agent-to-Agent Communication (A2A) - MAJOR SELLING POINT
+            await this.configureMessagingA2A();
+            // Step 13: Function Definitions (CRITICAL for function calling)
+            await this.configureFunctions();
+            // Step 14: Platform Adapters (Production integrations)
+            await this.configureAdapters();
+            // Step 15: Principal & Credentials (Security)
+            await this.configurePrincipal();
+            // Step 16: Feature Selection (Advanced/Optional)
             await this.selectFeatures();
             // Conditional steps based on features
             if (this.state.getState().features.skills) {
@@ -671,10 +727,11 @@ class OSSAWizardV2 {
                 type: 'input',
                 name: 'name',
                 message: 'Agent ID (DNS-1123 format):',
-                default: this.state.getAgent().metadata?.name || 'my-agent',
+                default: this.state.getAgent().metadata?.name || 'agent-smith',
                 validate: (input) => {
                     const valid = /^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(input);
-                    return valid || 'Must be DNS-1123 compliant (lowercase, alphanumeric, hyphens)';
+                    return (valid ||
+                        'Must be DNS-1123 compliant (lowercase, alphanumeric, hyphens)');
                 },
             },
             {
@@ -687,7 +744,8 @@ class OSSAWizardV2 {
                 type: 'input',
                 name: 'description',
                 message: 'Description:',
-                default: this.state.getAgent().metadata?.description || 'An OSSA-compliant agent',
+                default: this.state.getAgent().metadata?.description ||
+                    'An OSSA-compliant agent',
             },
             {
                 type: 'input',
@@ -700,120 +758,1349 @@ class OSSAWizardV2 {
                 },
             },
         ]);
-        this.state.updateAgent({
-            metadata: {
-                name: answers.name,
-                version: answers.version,
-                description: answers.description,
-                labels: {
-                    'ossa.io/created-by': 'wizard-v2',
+        this.state.updateAgent({
+            metadata: {
+                name: answers.name,
+                version: answers.version,
+                description: answers.description,
+                labels: {
+                    'ossa.io/created-by': 'wizard-v2',
+                },
+            },
+        });
+        printSuccess('Basic information configured');
+    }
+    async configureSystemPrompt() {
+        this.state.nextStep('System Prompt');
+        printStep(3, this.state.getState().totalSteps, 'System Prompt & Instructions', 'THE MOST IMPORTANT FIELD - Define your agent behavior');
+        printInfo("💡 The system prompt defines your agent's personality, capabilities, and behavior.");
+        printInfo('   This is required for all exports and agent execution.');
+        const answers = await inquirer.prompt([
+            {
+                type: 'editor',
+                name: 'systemPrompt',
+                message: 'System Prompt (opens in your default editor):',
+                default: `You are an AI assistant specialized in helping users.
+
+Your capabilities:
+- Analyze and understand user requests
+- Provide accurate, helpful responses
+- Follow best practices and guidelines
+
+Your responsibilities:
+- Be helpful, harmless, and honest
+- Provide clear, actionable guidance
+- Admit when you don't know something
+
+Guidelines:
+- Always prioritize user safety and privacy
+- Provide sources and references when possible
+- Be concise but thorough in explanations`,
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'System prompt is required - this defines your agent behavior!';
+                    }
+                    if (input.trim().length < 50) {
+                        return 'System prompt should be at least 50 characters for meaningful behavior';
+                    }
+                    return true;
+                },
+            },
+            {
+                type: 'input',
+                name: 'primaryGoal',
+                message: 'Primary Goal (one sentence):',
+                default: 'Help users accomplish their tasks efficiently',
+            },
+            {
+                type: 'list',
+                name: 'tone',
+                message: 'Agent Tone/Personality:',
+                choices: [
+                    { name: 'Professional', value: 'professional' },
+                    { name: 'Friendly', value: 'friendly' },
+                    { name: 'Technical', value: 'technical' },
+                    { name: 'Casual', value: 'casual' },
+                    { name: 'Formal', value: 'formal' },
+                ],
+                default: 'professional',
+            },
+        ]);
+        this.state.updateAgent({
+            spec: {
+                role: answers.systemPrompt,
+                prompts: {
+                    system: answers.systemPrompt,
+                },
+                metadata: {
+                    ...this.state.getAgent().metadata,
+                    annotations: {
+                        'ossa.io/primary-goal': answers.primaryGoal,
+                        'ossa.io/tone': answers.tone,
+                    },
+                },
+            },
+        });
+        printSuccess('System prompt configured - Your agent now has a personality!');
+    }
+    async configureLLM() {
+        this.state.nextStep('LLM Configuration');
+        printStep(4, this.state.getState().totalSteps, 'LLM Configuration', 'Configure primary LLM, fallbacks, and cost controls');
+        const { provider } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'provider',
+                message: 'Select LLM Provider:',
+                choices: [
+                    { name: 'Anthropic Claude (Recommended)', value: 'anthropic' },
+                    { name: 'OpenAI', value: 'openai' },
+                    { name: 'Google Gemini', value: 'google' },
+                    { name: 'Mistral AI', value: 'mistral' },
+                    { name: 'Cohere', value: 'cohere' },
+                    { name: 'Groq', value: 'groq' },
+                    { name: 'Together AI', value: 'together' },
+                ],
+                default: 'anthropic',
+            },
+        ]);
+        const modelChoices = {
+            anthropic: [
+                {
+                    name: 'Claude Sonnet 4 (Recommended)',
+                    value: 'claude-sonnet-4-20250514',
+                },
+                { name: 'Claude Opus 4', value: 'claude-opus-4-20250514' },
+                { name: 'Claude Haiku 4', value: 'claude-haiku-4-20250514' },
+            ],
+            openai: [
+                { name: 'GPT-4o (Recommended)', value: 'gpt-4o' },
+                { name: 'GPT-4 Turbo', value: 'gpt-4-turbo' },
+                { name: 'GPT-3.5 Turbo', value: 'gpt-3.5-turbo' },
+            ],
+            google: [
+                {
+                    name: 'Gemini 2.0 Flash (Recommended)',
+                    value: 'gemini-2.0-flash-exp',
+                },
+                { name: 'Gemini 1.5 Pro', value: 'gemini-1.5-pro' },
+            ],
+            mistral: [
+                { name: 'Mistral Large', value: 'mistral-large-latest' },
+                { name: 'Mixtral 8x7B', value: 'mixtral-8x7b-32768' },
+            ],
+            cohere: [
+                { name: 'Command R+', value: 'command-r-plus' },
+                { name: 'Command R', value: 'command-r' },
+            ],
+            groq: [{ name: 'Llama 3.1 70B', value: 'llama-3.1-70b-versatile' }],
+            together: [
+                {
+                    name: 'Llama 3.1 70B',
+                    value: 'meta-llama/Llama-3.1-70B-Instruct-Turbo',
+                },
+            ],
+        };
+        const llmAnswers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Select Model:',
+                choices: modelChoices[provider] || [
+                    { name: 'Default', value: 'default' },
+                ],
+            },
+            {
+                type: 'number',
+                name: 'temperature',
+                message: 'Temperature (0.0-2.0):',
+                default: 0.7,
+                validate: (input) => {
+                    return (input >= 0 && input <= 2) || 'Must be between 0.0 and 2.0';
+                },
+            },
+            {
+                type: 'confirm',
+                name: 'addFallback',
+                message: 'Add fallback LLM for reliability?',
+                default: false,
+            },
+        ]);
+        const llmConfig = {
+            provider,
+            model: llmAnswers.model,
+            temperature: llmAnswers.temperature,
+        };
+        if (llmAnswers.addFallback) {
+            const { fallbackProvider } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'fallbackProvider',
+                    message: 'Select fallback provider:',
+                    choices: [
+                        { name: 'OpenAI', value: 'openai' },
+                        { name: 'Google', value: 'google' },
+                        { name: 'Mistral', value: 'mistral' },
+                    ],
+                    default: provider === 'anthropic' ? 'openai' : 'anthropic',
+                },
+            ]);
+            llmConfig.fallback_models = [
+                {
+                    provider: fallbackProvider,
+                    model: modelChoices[fallbackProvider]?.[0]?.value || 'default',
+                },
+            ];
+            printSuccess('Fallback LLM configured for high availability');
+        }
+        this.state.updateAgent({
+            spec: {
+                llm: llmConfig,
+            },
+        });
+        printSuccess('LLM configuration complete');
+    }
+    async configureToolsCore() {
+        this.state.nextStep('Tools Configuration');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Tools & Capabilities', 'Define what your agent can do');
+        printInfo('💡 Tools are the actions your agent can perform (API calls, code execution, etc.)');
+        const { toolChoice } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'toolChoice',
+                message: 'Tool configuration approach:',
+                choices: [
+                    { name: 'Add tools manually (custom functions)', value: 'manual' },
+                    { name: 'Use MCP servers (Model Context Protocol)', value: 'mcp' },
+                    { name: 'Add tools later (skip for now)', value: 'skip' },
+                ],
+                default: 'mcp',
+            },
+        ]);
+        if (toolChoice === 'manual') {
+            const { toolCount } = await inquirer.prompt([
+                {
+                    type: 'number',
+                    name: 'toolCount',
+                    message: 'How many tools to add?',
+                    default: 1,
+                    validate: (input) => (input > 0 && input <= 20) || 'Must be between 1 and 20',
+                },
+            ]);
+            const tools = [];
+            for (let i = 0; i < toolCount; i++) {
+                const toolAnswers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'name',
+                        message: `Tool ${i + 1} - Name:`,
+                        validate: (input) => input.length > 0 || 'Tool name required',
+                    },
+                    {
+                        type: 'input',
+                        name: 'description',
+                        message: `Tool ${i + 1} - Description:`,
+                        validate: (input) => input.length > 0 || 'Description required',
+                    },
+                    {
+                        type: 'list',
+                        name: 'type',
+                        message: `Tool ${i + 1} - Type:`,
+                        choices: [
+                            { name: 'HTTP API', value: 'http' },
+                            { name: 'Function', value: 'function' },
+                            { name: 'MCP Server', value: 'mcp' },
+                            { name: 'Browser Automation', value: 'browser' },
+                            { name: 'Kubernetes', value: 'kubernetes' },
+                            { name: 'CLI Command', value: 'cli' },
+                        ],
+                    },
+                ]);
+                tools.push({
+                    name: toolAnswers.name,
+                    description: toolAnswers.description,
+                    type: toolAnswers.type,
+                });
+            }
+            this.state.updateAgent({
+                spec: {
+                    tools,
+                },
+            });
+            printSuccess(`${tools.length} tools configured`);
+        }
+        else if (toolChoice === 'mcp') {
+            printInfo('📡 MCP servers provide pre-built tools via Model Context Protocol');
+            printInfo('   Configure MCP servers in the extensions.mcp section');
+            printSuccess('MCP server configuration marked for later setup');
+        }
+        else {
+            printInfo('⏭️  Tools can be added later by editing the manifest');
+        }
+    }
+    async configureAutonomy() {
+        this.state.nextStep('Autonomy Configuration');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Autonomy & Decision-Making', 'Configure agent independence and human oversight');
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'level',
+                message: 'Autonomy Level:',
+                choices: [
+                    {
+                        name: 'Fully Autonomous - No human approval needed',
+                        value: 'full',
+                    },
+                    {
+                        name: 'Semi-Autonomous - Approval for critical actions',
+                        value: 'semi',
+                    },
+                    {
+                        name: 'Supervised - All actions require approval',
+                        value: 'supervised',
+                    },
+                ],
+                default: 'semi',
+            },
+            {
+                type: 'confirm',
+                name: 'enableHumanInLoop',
+                message: 'Enable human-in-the-loop for critical decisions?',
+                default: true,
+            },
+            {
+                type: 'number',
+                name: 'confidenceThreshold',
+                message: 'Minimum confidence threshold for autonomous actions (0.0-1.0):',
+                default: 0.7,
+                validate: (input) => (input >= 0 && input <= 1) || 'Must be between 0 and 1',
+            },
+        ]);
+        this.state.updateAgent({
+            spec: {
+                autonomy: {
+                    level: answers.level,
+                    approval_required: answers.level !== 'full',
+                    human_in_loop: answers.enableHumanInLoop,
+                    confidence_threshold: answers.confidenceThreshold,
+                    escalation: {
+                        enabled: answers.enableHumanInLoop,
+                        threshold: answers.confidenceThreshold,
+                    },
+                },
+            },
+        });
+        printSuccess('Autonomy configuration complete');
+    }
+    async configureConstraints() {
+        this.state.nextStep('Constraints Configuration');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Constraints & Limits', 'Define operational boundaries');
+        const answers = await inquirer.prompt([
+            {
+                type: 'number',
+                name: 'maxExecutionTime',
+                message: 'Maximum execution time (seconds, 0 for unlimited):',
+                default: 300,
+                validate: (input) => input >= 0 || 'Must be >= 0',
+            },
+            {
+                type: 'number',
+                name: 'maxCostPerExecution',
+                message: 'Maximum cost per execution (USD, 0 for unlimited):',
+                default: 0.5,
+                validate: (input) => input >= 0 || 'Must be >= 0',
+            },
+            {
+                type: 'confirm',
+                name: 'allowInternet',
+                message: 'Allow internet access?',
+                default: true,
+            },
+            {
+                type: 'confirm',
+                name: 'allowFileSystem',
+                message: 'Allow file system access?',
+                default: false,
+            },
+        ]);
+        this.state.updateAgent({
+            spec: {
+                constraints: {
+                    time: {
+                        max_execution_time: answers.maxExecutionTime > 0
+                            ? `${answers.maxExecutionTime}s`
+                            : undefined,
+                    },
+                    cost: {
+                        max_cost_per_execution: answers.maxCostPerExecution,
+                        currency: 'USD',
+                    },
+                    allowed_actions: {
+                        internet_access: answers.allowInternet,
+                        file_system_access: answers.allowFileSystem,
+                    },
+                },
+            },
+        });
+        printSuccess('Constraints configured');
+    }
+    async configureIdentity() {
+        this.state.nextStep('Identity Configuration');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Identity & Authentication', 'Configure agent identity and credentials');
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'serviceAccount',
+                message: 'Service Account Name (optional):',
+                default: '',
+            },
+            {
+                type: 'confirm',
+                name: 'enableDID',
+                message: 'Enable Decentralized Identity (DID)?',
+                default: false,
+            },
+        ]);
+        const identity = {};
+        if (answers.serviceAccount) {
+            identity.service_account = {
+                name: answers.serviceAccount,
+            };
+        }
+        if (answers.enableDID) {
+            printInfo('💡 DID enables cryptographic agent identity verification');
+            const didAnswers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'method',
+                    message: 'DID Method:',
+                    choices: [
+                        { name: 'did:key (Simple)', value: 'key' },
+                        { name: 'did:web (Web-based)', value: 'web' },
+                        { name: 'did:ethr (Ethereum)', value: 'ethr' },
+                    ],
+                    default: 'key',
+                },
+            ]);
+            identity.did = {
+                method: didAnswers.method,
+            };
+        }
+        if (Object.keys(identity).length > 0) {
+            this.state.updateAgent({
+                spec: {
+                    identity,
+                },
+            });
+            printSuccess('Identity configured');
+        }
+        else {
+            printInfo('⏭️  No identity configuration added');
+        }
+    }
+    async configureAccessControl() {
+        this.state.nextStep('Access Control');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Access Control & Permissions', 'Define what the agent can access');
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'accessTier',
+                message: 'Access Tier:',
+                choices: [
+                    { name: 'Tier 0 - Read-only (lowest privilege)', value: 'tier-0' },
+                    { name: 'Tier 1 - Read + Write (standard)', value: 'tier-1' },
+                    { name: 'Tier 2 - Read + Write + Delete', value: 'tier-2' },
+                    { name: 'Tier 3 - Admin operations', value: 'tier-3' },
+                ],
+                default: 'tier-1',
+            },
+            {
+                type: 'confirm',
+                name: 'enableSeparationOfDuties',
+                message: 'Enable separation of duties?',
+                default: false,
+            },
+        ]);
+        this.state.updateAgent({
+            spec: {
+                access: {
+                    tier: answers.accessTier,
+                },
+            },
+        });
+        if (answers.enableSeparationOfDuties) {
+            printInfo('💡 Separation of duties prevents conflicts of interest');
+            const sodAnswers = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'conflictingRoles',
+                    message: 'Select conflicting roles (agent cannot perform both):',
+                    choices: [
+                        { name: 'Approver + Executor', value: 'approver-executor' },
+                        { name: 'Auditor + Operator', value: 'auditor-operator' },
+                        { name: 'Reviewer + Author', value: 'reviewer-author' },
+                    ],
+                },
+            ]);
+            this.state.updateAgent({
+                spec: {
+                    separation: {
+                        enabled: true,
+                        conflicting_roles: sodAnswers.conflictingRoles,
+                    },
+                },
+            });
+        }
+        printSuccess('Access control configured');
+    }
+    async configureAgentType() {
+        this.state.nextStep('Agent Type');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Agent Type Classification', 'Define agent role in the system');
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Agent Type:',
+                choices: [
+                    { name: 'Analyzer - Data analysis and insights', value: 'analyzer' },
+                    { name: 'Worker - Task execution', value: 'worker' },
+                    { name: 'Operator - System operations', value: 'operator' },
+                    { name: 'Supervisor - Team coordination', value: 'supervisor' },
+                    { name: 'Orchestrator - Workflow management', value: 'orchestrator' },
+                    { name: 'Governor - Policy enforcement', value: 'governor' },
+                    { name: 'Specialist - Domain expertise', value: 'specialist' },
+                    { name: 'Critic - Review and feedback', value: 'critic' },
+                ],
+                default: 'worker',
+            },
+        ]);
+        this.state.updateAgent({
+            spec: {
+                type: answers.type,
+            },
+        });
+        printSuccess(`Agent type set to: ${answers.type}`);
+    }
+    async configureTaxonomy() {
+        this.state.nextStep('Taxonomy');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Taxonomy Classification', 'Categorize agent capabilities');
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'domain',
+                message: 'Primary Domain:',
+                choices: [
+                    {
+                        name: 'DevOps - CI/CD, deployment, infrastructure',
+                        value: 'devops',
+                    },
+                    {
+                        name: 'Data Science - ML, analytics, insights',
+                        value: 'data-science',
+                    },
+                    { name: 'Customer Support - Help desk, ticketing', value: 'support' },
+                    {
+                        name: 'Finance - Accounting, billing, invoicing',
+                        value: 'finance',
+                    },
+                    { name: 'HR - Recruiting, onboarding, management', value: 'hr' },
+                    { name: 'Sales & Marketing - CRM, campaigns', value: 'sales' },
+                    { name: 'Security - Scanning, compliance, audit', value: 'security' },
+                    { name: 'General Purpose', value: 'general' },
+                ],
+            },
+            {
+                type: 'checkbox',
+                name: 'crossCutting',
+                message: 'Cross-cutting Concerns:',
+                choices: [
+                    {
+                        name: 'Observability - Monitoring and logging',
+                        value: 'observability',
+                    },
+                    {
+                        name: 'Security - Authentication and authorization',
+                        value: 'security',
+                    },
+                    { name: 'Compliance - Regulatory requirements', value: 'compliance' },
+                    { name: 'Cost Management - Budget tracking', value: 'cost' },
+                ],
+            },
+        ]);
+        this.state.updateAgent({
+            spec: {
+                taxonomy: {
+                    domain: answers.domain,
+                    cross_cutting: answers.crossCutting,
+                },
+            },
+        });
+        printSuccess('Taxonomy configured');
+    }
+    async configureCompliance() {
+        this.state.nextStep('Compliance');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Compliance & Governance', 'Configure regulatory and audit requirements');
+        const answers = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'frameworks',
+                message: 'Select applicable compliance frameworks:',
+                choices: [
+                    { name: 'SOC2 - Service Organization Control 2', value: 'SOC2' },
+                    { name: 'HIPAA - Healthcare data protection', value: 'HIPAA' },
+                    { name: 'GDPR - European data privacy', value: 'GDPR' },
+                    { name: 'FedRAMP - US federal cloud security', value: 'FedRAMP' },
+                    { name: 'PCI-DSS - Payment card security', value: 'PCI-DSS' },
+                    { name: 'ISO27001 - Information security', value: 'ISO27001' },
+                ],
+            },
+            {
+                type: 'list',
+                name: 'auditLogging',
+                message: 'Audit Logging:',
+                choices: [
+                    { name: 'Required - All actions logged', value: 'required' },
+                    { name: 'Optional - Best effort logging', value: 'optional' },
+                    { name: 'Disabled - No audit logs', value: 'disabled' },
+                ],
+                default: 'optional',
+            },
+            {
+                type: 'list',
+                name: 'piiHandling',
+                message: 'PII (Personally Identifiable Information) Handling:',
+                choices: [
+                    { name: 'Encrypt at Rest', value: 'encrypt_at_rest' },
+                    { name: 'Anonymize', value: 'anonymize' },
+                    { name: 'Redact', value: 'redact' },
+                    { name: 'None', value: 'none' },
+                ],
+                default: 'none',
+            },
+        ]);
+        if (answers.frameworks.length > 0 || answers.auditLogging !== 'disabled') {
+            this.state.updateAgent({
+                spec: {
+                    compliance: {
+                        frameworks: answers.frameworks,
+                        audit_logging: answers.auditLogging,
+                        pii_handling: answers.piiHandling,
+                    },
+                },
+            });
+            printSuccess('Compliance configuration complete');
+        }
+        else {
+            printInfo('⏭️  No compliance requirements configured');
+        }
+    }
+    async configureLifecycle() {
+        this.state.nextStep('Lifecycle');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Lifecycle Management', 'Configure execution limits and behavior');
+        const answers = await inquirer.prompt([
+            {
+                type: 'number',
+                name: 'maxTurns',
+                message: 'Maximum agentic turns/iterations (0 for unlimited):',
+                default: 10,
+                validate: (input) => input >= 0 || 'Must be >= 0',
+            },
+            {
+                type: 'input',
+                name: 'turnTimeout',
+                message: 'Timeout per turn (e.g., "300s", "5m"):',
+                default: '300s',
+                validate: (input) => /^[0-9]+(s|m|h)$/.test(input) || 'Must be format like "300s" or "5m"',
+            },
+            {
+                type: 'confirm',
+                name: 'enableCheckpointing',
+                message: 'Enable state checkpointing?',
+                default: true,
+            },
+        ]);
+        const lifecycle = {};
+        if (answers.maxTurns > 0) {
+            lifecycle.max_turns = answers.maxTurns;
+        }
+        lifecycle.turn_timeout = answers.turnTimeout;
+        if (answers.enableCheckpointing) {
+            const checkpointAnswers = await inquirer.prompt([
+                {
+                    type: 'number',
+                    name: 'interval',
+                    message: 'Checkpoint every N turns:',
+                    default: 5,
+                    validate: (input) => input > 0 || 'Must be > 0',
+                },
+            ]);
+            lifecycle.checkpoint_interval = checkpointAnswers.interval;
+        }
+        this.state.updateAgent({
+            spec: {
+                lifecycle,
+            },
+        });
+        printSuccess('Lifecycle configuration complete');
+    }
+    async configureTokenEfficiency() {
+        this.state.nextStep('Token Efficiency');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Token Efficiency (v0.4 REVOLUTIONARY)', 'Enable 70-95% cost savings');
+        printInfo('💰 Token efficiency features can reduce LLM costs by 70-95%!');
+        printInfo('   - Prompt caching');
+        printInfo('   - Context pruning');
+        printInfo('   - Batched inference');
+        printInfo('   - Compression');
+        const answers = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'enable',
+                message: 'Enable token efficiency optimizations?',
+                default: true,
+            },
+        ]);
+        if (answers.enable) {
+            const options = await inquirer.prompt([
+                {
+                    type: 'checkbox',
+                    name: 'features',
+                    message: 'Select optimizations to enable:',
+                    choices: [
+                        {
+                            name: 'Prompt Caching - Cache repeated prompts (recommended)',
+                            value: 'prompt_caching',
+                            checked: true,
+                        },
+                        {
+                            name: 'Context Pruning - Remove less relevant context',
+                            value: 'context_pruning',
+                            checked: true,
+                        },
+                        {
+                            name: 'Batched Inference - Batch multiple requests',
+                            value: 'batched_inference',
+                            checked: false,
+                        },
+                        {
+                            name: 'Compression - Compress prompts/responses',
+                            value: 'compression',
+                            checked: false,
+                        },
+                    ],
+                },
+                {
+                    type: 'number',
+                    name: 'targetSavings',
+                    message: 'Target cost savings (0.0-0.95 = 0-95%):',
+                    default: 0.7,
+                    validate: (input) => (input >= 0 && input <= 0.95) || 'Must be between 0 and 0.95',
+                },
+            ]);
+            this.state.updateAgent({
+                spec: {
+                    token_efficiency: {
+                        enabled: true,
+                        strategies: options.features,
+                        target_savings: options.targetSavings,
+                    },
+                },
+            });
+            printSuccess(`Token efficiency enabled - targeting ${(options.targetSavings * 100).toFixed(0)}% cost savings!`);
+        }
+        else {
+            printInfo('⏭️  Token efficiency optimizations skipped');
+        }
+    }
+    async configureMessagingA2A() {
+        this.state.nextStep('Agent-to-Agent Communication');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, '🚀 A2A Communication (MAJOR SELLING POINT)', 'Enable multi-agent collaboration and messaging');
+        printInfo('💬 A2A (Agent-to-Agent) is one of the BIGGEST adoption drivers!');
+        printInfo('   - Multi-agent collaboration');
+        printInfo('   - Event-driven workflows');
+        printInfo('   - Distributed agent networks');
+        printInfo('   - Real-time agent coordination');
+        const answers = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'enable',
+                message: 'Enable Agent-to-Agent (A2A) communication?',
+                default: true,
+            },
+        ]);
+        if (answers.enable) {
+            const a2aConfig = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'protocol',
+                    message: 'A2A Protocol:',
+                    choices: [
+                        { name: 'NATS (High-performance messaging)', value: 'nats' },
+                        { name: 'RabbitMQ (Enterprise messaging)', value: 'rabbitmq' },
+                        { name: 'Redis Pub/Sub (Simple, fast)', value: 'redis' },
+                        { name: 'Kafka (High-throughput streaming)', value: 'kafka' },
+                        { name: 'MQTT (IoT/lightweight)', value: 'mqtt' },
+                        { name: 'Custom (Define your own)', value: 'custom' },
+                    ],
+                    default: 'nats',
+                },
+                {
+                    type: 'checkbox',
+                    name: 'capabilities',
+                    message: 'A2A Capabilities:',
+                    choices: [
+                        {
+                            name: 'Request/Response - Synchronous agent calls',
+                            value: 'request_response',
+                            checked: true,
+                        },
+                        {
+                            name: 'Publish/Subscribe - Event broadcasting',
+                            value: 'pub_sub',
+                            checked: true,
+                        },
+                        {
+                            name: 'Task Queue - Distributed work',
+                            value: 'task_queue',
+                            checked: false,
+                        },
+                        {
+                            name: 'Stream Processing - Real-time data',
+                            value: 'streaming',
+                            checked: false,
+                        },
+                    ],
+                },
+                {
+                    type: 'confirm',
+                    name: 'enableDiscovery',
+                    message: 'Enable agent discovery (find other agents)?',
+                    default: true,
+                },
+                {
+                    type: 'confirm',
+                    name: 'enableTeams',
+                    message: 'Enable team membership (multi-agent teams)?',
+                    default: true,
+                },
+            ]);
+            const messaging = {
+                enabled: true,
+                protocol: a2aConfig.protocol,
+                capabilities: a2aConfig.capabilities,
+            };
+            if (a2aConfig.enableDiscovery) {
+                messaging.discovery = {
+                    enabled: true,
+                    mechanism: 'dns',
+                };
+            }
+            if (a2aConfig.enableTeams) {
+                const teamAnswers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'teamName',
+                        message: 'Team Name (optional):',
+                        default: '',
+                    },
+                    {
+                        type: 'list',
+                        name: 'role',
+                        message: 'Agent Role in Team:',
+                        choices: [
+                            { name: 'Leader - Coordinates team', value: 'leader' },
+                            { name: 'Worker - Executes tasks', value: 'worker' },
+                            { name: 'Specialist - Domain expert', value: 'specialist' },
+                            { name: 'Observer - Monitors only', value: 'observer' },
+                        ],
+                        default: 'worker',
+                    },
+                ]);
+                messaging.team = {
+                    enabled: true,
+                };
+                if (teamAnswers.teamName) {
+                    messaging.team.name = teamAnswers.teamName;
+                }
+                messaging.team.role = teamAnswers.role;
+            }
+            // Add message routing and filtering
+            const routingAnswers = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'enableRouting',
+                    message: 'Configure message routing rules?',
+                    default: false,
+                },
+            ]);
+            if (routingAnswers.enableRouting) {
+                messaging.routing = {
+                    rules: [
+                        {
+                            pattern: '*',
+                            action: 'process',
+                        },
+                    ],
+                };
+            }
+            this.state.updateAgent({
+                spec: {
+                    messaging,
+                },
+            });
+            printSuccess(`A2A Communication configured with ${a2aConfig.protocol} protocol!`);
+            if (a2aConfig.enableTeams) {
+                printSuccess('✨ Multi-agent teams enabled - ready for collaboration!');
+            }
+        }
+        else {
+            printInfo('⏭️  A2A communication disabled (agent will work solo)');
+        }
+    }
+    async configureFunctions() {
+        this.state.nextStep('Function Definitions');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Function Definitions (Function Calling)', 'Define callable functions with JSON Schema for structured outputs');
+        printInfo('🔧 Function calling enables:');
+        printInfo('   - Structured tool execution');
+        printInfo('   - Type-safe function calls');
+        printInfo('   - JSON Schema validation');
+        printInfo('   - Predictable outputs');
+        const answers = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'enable',
+                message: 'Define callable functions for this agent?',
+                default: false,
+            },
+        ]);
+        if (answers.enable) {
+            const functions = [];
+            let addMore = true;
+            while (addMore) {
+                const funcConfig = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'name',
+                        message: 'Function Name (e.g., get_weather, search_documents):',
+                        validate: (input) => input.length > 0 || 'Name is required',
+                    },
+                    {
+                        type: 'input',
+                        name: 'description',
+                        message: 'Function Description:',
+                        validate: (input) => input.length > 0 || 'Description is required',
+                    },
+                    {
+                        type: 'list',
+                        name: 'schemaType',
+                        message: 'Define JSON Schema:',
+                        choices: [
+                            {
+                                name: 'Simple (string, number, boolean parameters)',
+                                value: 'simple',
+                            },
+                            {
+                                name: 'Complex (objects, arrays, nested structures)',
+                                value: 'complex',
+                            },
+                            { name: 'Skip (define schema later)', value: 'skip' },
+                        ],
+                        default: 'simple',
+                    },
+                ]);
+                const func = {
+                    name: funcConfig.name,
+                    description: funcConfig.description,
+                };
+                if (funcConfig.schemaType === 'simple') {
+                    const params = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'paramNames',
+                            message: 'Parameter names (comma-separated, e.g. location,units,date):',
+                            default: '',
+                        },
+                    ]);
+                    if (params.paramNames) {
+                        const paramList = params.paramNames
+                            .split(',')
+                            .map((p) => p.trim())
+                            .filter((p) => p);
+                        func.parameters = {
+                            type: 'object',
+                            properties: paramList.reduce((acc, param) => {
+                                acc[param] = {
+                                    type: 'string',
+                                    description: `${param} parameter`,
+                                };
+                                return acc;
+                            }, {}),
+                            required: paramList,
+                        };
+                    }
+                }
+                else if (funcConfig.schemaType === 'complex') {
+                    printWarning('⚠️  Complex JSON Schema definition requires manual editing after generation');
+                    func.parameters = {
+                        type: 'object',
+                        properties: {},
+                        description: 'TODO: Define complex schema in manifest YAML',
+                    };
+                }
+                functions.push(func);
+                const continueAnswer = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'continue',
+                        message: 'Add another function?',
+                        default: false,
+                    },
+                ]);
+                addMore = continueAnswer.continue;
+            }
+            this.state.updateAgent({
+                spec: {
+                    functions,
                 },
-            },
-        });
-        printSuccess('Basic information configured');
+            });
+            printSuccess(`✅ Added ${functions.length} function definition(s)`);
+        }
+        else {
+            printInfo('⏭️  No functions defined (agent will not support function calling)');
+        }
     }
-    async configureLLM() {
-        this.state.nextStep('LLM Configuration');
-        printStep(3, this.state.getState().totalSteps, 'LLM Configuration', 'Configure primary LLM, fallbacks, and cost controls');
-        const { provider } = await inquirer.prompt([
+    async configureAdapters() {
+        this.state.nextStep('Platform Adapters');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Platform Adapters (Production Integrations)', 'Configure platform-specific adapters for SCM, runtime, cloud');
+        printInfo('🔌 Adapters enable production integrations:');
+        printInfo('   - SCM: GitHub, GitLab, Bitbucket');
+        printInfo('   - Runtime: Kubernetes (kagent), Docker, Serverless');
+        printInfo('   - Cloud: AWS, GCP, Azure');
+        printInfo('   - Databases: PostgreSQL, MongoDB, Redis');
+        const answers = await inquirer.prompt([
             {
-                type: 'list',
-                name: 'provider',
-                message: 'Select LLM Provider:',
-                choices: [
-                    { name: 'Anthropic Claude (Recommended)', value: 'anthropic' },
-                    { name: 'OpenAI', value: 'openai' },
-                    { name: 'Google Gemini', value: 'google' },
-                    { name: 'Mistral AI', value: 'mistral' },
-                    { name: 'Cohere', value: 'cohere' },
-                    { name: 'Groq', value: 'groq' },
-                    { name: 'Together AI', value: 'together' },
-                ],
-                default: 'anthropic',
+                type: 'confirm',
+                name: 'enable',
+                message: 'Configure platform adapters?',
+                default: false,
             },
         ]);
-        const modelChoices = {
-            anthropic: [
-                { name: 'Claude Sonnet 4 (Recommended)', value: 'claude-sonnet-4-20250514' },
-                { name: 'Claude Opus 4', value: 'claude-opus-4-20250514' },
-                { name: 'Claude Haiku 4', value: 'claude-haiku-4-20250514' },
-            ],
-            openai: [
-                { name: 'GPT-4o (Recommended)', value: 'gpt-4o' },
-                { name: 'GPT-4 Turbo', value: 'gpt-4-turbo' },
-                { name: 'GPT-3.5 Turbo', value: 'gpt-3.5-turbo' },
-            ],
-            google: [
-                { name: 'Gemini 2.0 Flash (Recommended)', value: 'gemini-2.0-flash-exp' },
-                { name: 'Gemini 1.5 Pro', value: 'gemini-1.5-pro' },
-            ],
-            mistral: [
-                { name: 'Mistral Large', value: 'mistral-large-latest' },
-                { name: 'Mixtral 8x7B', value: 'mixtral-8x7b-32768' },
-            ],
-            cohere: [
-                { name: 'Command R+', value: 'command-r-plus' },
-                { name: 'Command R', value: 'command-r' },
-            ],
-            groq: [{ name: 'Llama 3.1 70B', value: 'llama-3.1-70b-versatile' }],
-            together: [{ name: 'Llama 3.1 70B', value: 'meta-llama/Llama-3.1-70B-Instruct-Turbo' }],
-        };
-        const llmAnswers = await inquirer.prompt([
-            {
-                type: 'list',
-                name: 'model',
-                message: 'Select Model:',
-                choices: modelChoices[provider] || [{ name: 'Default', value: 'default' }],
-            },
-            {
-                type: 'number',
-                name: 'temperature',
-                message: 'Temperature (0.0-2.0):',
-                default: 0.7,
-                validate: (input) => {
-                    return (input >= 0 && input <= 2) || 'Must be between 0.0 and 2.0';
+        if (answers.enable) {
+            const adapters = [];
+            let addMore = true;
+            while (addMore) {
+                const adapterConfig = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'category',
+                        message: 'Adapter Category:',
+                        choices: [
+                            {
+                                name: 'SCM - Source Code Management (GitHub, GitLab)',
+                                value: 'scm',
+                            },
+                            {
+                                name: 'Runtime - Execution Environment (Kubernetes, Docker)',
+                                value: 'runtime',
+                            },
+                            {
+                                name: 'Cloud - Cloud Provider (AWS, GCP, Azure)',
+                                value: 'cloud',
+                            },
+                            { name: 'Database - Database Connection', value: 'database' },
+                            {
+                                name: 'Service - External Service Integration',
+                                value: 'service',
+                            },
+                        ],
+                    },
+                ]);
+                let typeChoices = [];
+                if (adapterConfig.category === 'scm') {
+                    typeChoices = [
+                        { name: 'GitHub', value: 'scm.github' },
+                        { name: 'GitLab', value: 'scm.gitlab' },
+                        { name: 'Bitbucket', value: 'scm.bitbucket' },
+                    ];
+                }
+                else if (adapterConfig.category === 'runtime') {
+                    typeChoices = [
+                        { name: 'Kubernetes (kagent)', value: 'runtime.kagent' },
+                        { name: 'Docker', value: 'runtime.docker' },
+                        {
+                            name: 'Serverless (Lambda, Cloud Functions)',
+                            value: 'runtime.serverless',
+                        },
+                    ];
+                }
+                else if (adapterConfig.category === 'cloud') {
+                    typeChoices = [
+                        { name: 'AWS', value: 'cloud.aws' },
+                        { name: 'Google Cloud Platform', value: 'cloud.gcp' },
+                        { name: 'Microsoft Azure', value: 'cloud.azure' },
+                    ];
+                }
+                else if (adapterConfig.category === 'database') {
+                    typeChoices = [
+                        { name: 'PostgreSQL', value: 'database.postgresql' },
+                        { name: 'MongoDB', value: 'database.mongodb' },
+                        { name: 'Redis', value: 'database.redis' },
+                    ];
+                }
+                else {
+                    typeChoices = [{ name: 'Custom Service', value: 'service.custom' }];
+                }
+                const typeAnswer = await inquirer.prompt([
+                    {
+                        type: 'list',
+                        name: 'type',
+                        message: 'Adapter Type:',
+                        choices: typeChoices,
+                    },
+                    {
+                        type: 'input',
+                        name: 'version',
+                        message: 'Adapter Version:',
+                        default: '1.0.0',
+                    },
+                ]);
+                const adapter = {
+                    type: typeAnswer.type,
+                    version: typeAnswer.version,
+                    config: {},
+                };
+                // Add basic config hints
+                if (adapterConfig.category === 'scm') {
+                    adapter.config = {
+                        repository: 'TODO: repository URL or name',
+                        branch: 'main',
+                    };
+                    adapter.secrets = {
+                        token: {
+                            type: 'secretRef',
+                            ref: `secrets://${adapterConfig.category}/token`,
+                        },
+                    };
+                }
+                else if (adapterConfig.category === 'runtime' &&
+                    typeAnswer.type === 'runtime.kagent') {
+                    adapter.config = {
+                        namespace: 'default',
+                        serviceAccount: 'agent-service-account',
+                    };
+                }
+                else if (adapterConfig.category === 'cloud') {
+                    adapter.config = {
+                        region: 'us-east-1',
+                    };
+                    adapter.secrets = {
+                        credentials: {
+                            type: 'secretRef',
+                            ref: `secrets://${adapterConfig.category}/credentials`,
+                        },
+                    };
+                }
+                else if (adapterConfig.category === 'database') {
+                    adapter.config = {
+                        host: 'localhost',
+                        port: 5432,
+                        database: 'default',
+                    };
+                    adapter.secrets = {
+                        password: {
+                            type: 'secretRef',
+                            ref: `secrets://${adapterConfig.category}/password`,
+                        },
+                    };
+                }
+                adapters.push(adapter);
+                printInfo(`✅ Added ${typeAnswer.type} adapter`);
+                const continueAnswer = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'continue',
+                        message: 'Add another adapter?',
+                        default: false,
+                    },
+                ]);
+                addMore = continueAnswer.continue;
+            }
+            this.state.updateAgent({
+                spec: {
+                    adapters,
                 },
-            },
+            });
+            printSuccess(`✅ Configured ${adapters.length} platform adapter(s)`);
+            printWarning('⚠️  Remember to configure secrets for adapter authentication');
+        }
+        else {
+            printInfo('⏭️  No adapters configured (agent will run standalone)');
+        }
+    }
+    async configurePrincipal() {
+        this.state.nextStep('Principal & Credentials');
+        printStep(this.state.getState().currentStep, this.state.getState().totalSteps, 'Principal & Credentials (Security)', 'Configure abstract identity and secure credential management');
+        printInfo('🔐 Principal defines agent identity and credentials:');
+        printInfo('   - Abstract credential management');
+        printInfo('   - Workload identity support');
+        printInfo('   - Policy-based access control');
+        printInfo('   - Secret rotation and lifecycle');
+        const answers = await inquirer.prompt([
             {
                 type: 'confirm',
-                name: 'addFallback',
-                message: 'Add fallback LLM for reliability?',
+                name: 'enable',
+                message: 'Configure principal (identity & credentials)?',
                 default: false,
             },
         ]);
-        const llmConfig = {
-            provider,
-            model: llmAnswers.model,
-            temperature: llmAnswers.temperature,
-        };
-        if (llmAnswers.addFallback) {
-            const { fallbackProvider } = await inquirer.prompt([
+        if (answers.enable) {
+            const principalConfig = await inquirer.prompt([
                 {
                     type: 'list',
-                    name: 'fallbackProvider',
-                    message: 'Select fallback provider:',
+                    name: 'category',
+                    message: 'Principal Category:',
                     choices: [
-                        { name: 'OpenAI', value: 'openai' },
-                        { name: 'Google', value: 'google' },
-                        { name: 'Mistral', value: 'mistral' },
+                        { name: 'SCM - Source Code Management', value: 'scm' },
+                        { name: 'Cloud - Cloud Provider', value: 'cloud' },
+                        { name: 'Database - Database Access', value: 'database' },
+                        { name: 'Service - Service Integration', value: 'service' },
                     ],
-                    default: provider === 'anthropic' ? 'openai' : 'anthropic',
+                },
+                {
+                    type: 'list',
+                    name: 'mode',
+                    message: 'Identity Mode:',
+                    choices: [
+                        {
+                            name: 'App - Application identity (OAuth app, service principal)',
+                            value: 'app',
+                        },
+                        {
+                            name: 'Service Account - Service account with IAM role',
+                            value: 'service_account',
+                        },
+                        {
+                            name: 'User - User identity (for testing/development)',
+                            value: 'user',
+                        },
+                        {
+                            name: 'Workload Identity - Cloud workload identity federation',
+                            value: 'workload_identity',
+                        },
+                    ],
+                    default: 'service_account',
+                },
+                {
+                    type: 'list',
+                    name: 'credentialType',
+                    message: 'Credential Source Type:',
+                    choices: [
+                        {
+                            name: 'Secret Reference - Reference to secrets manager (recommended)',
+                            value: 'secretRef',
+                        },
+                        {
+                            name: 'Workload Identity - Cloud-native identity federation',
+                            value: 'workloadIdentity',
+                        },
+                        {
+                            name: 'Environment Variable - From env vars (dev only)',
+                            value: 'env',
+                        },
+                        {
+                            name: 'External - External credential provider',
+                            value: 'external',
+                        },
+                    ],
+                    default: 'secretRef',
                 },
             ]);
-            llmConfig.fallback_models = [
+            const policyConfig = await inquirer.prompt([
                 {
-                    provider: fallbackProvider,
-                    model: modelChoices[fallbackProvider]?.[0]?.value || 'default',
+                    type: 'input',
+                    name: 'permissions',
+                    message: 'Permissions (comma-separated, e.g. contents.read,issues.write):',
+                    default: 'contents.read',
                 },
-            ];
-            printSuccess('Fallback LLM configured for high availability');
+                {
+                    type: 'input',
+                    name: 'resources',
+                    message: 'Resource Scope (optional, comma-separated repositories/resources):',
+                    default: '',
+                },
+            ]);
+            const securityConfig = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'rotationType',
+                    message: 'Credential Rotation Policy:',
+                    choices: [
+                        {
+                            name: 'Managed - Cloud provider manages rotation',
+                            value: 'managed',
+                        },
+                        { name: 'Automatic - Rotate on schedule', value: 'automatic' },
+                        { name: 'Manual - Manual rotation required', value: 'manual' },
+                    ],
+                    default: 'managed',
+                },
+                {
+                    type: 'number',
+                    name: 'ttlDays',
+                    message: 'Credential TTL (time-to-live in days):',
+                    default: 90,
+                    validate: (input) => input > 0 || 'Must be > 0',
+                },
+            ]);
+            const credentialRef = principalConfig.credentialType === 'secretRef'
+                ? `secrets://${principalConfig.category}/credentials`
+                : principalConfig.credentialType === 'env'
+                    ? `env:${principalConfig.category.toUpperCase()}_CREDENTIALS`
+                    : 'workload-identity://default';
+            const permissions = policyConfig.permissions
+                .split(',')
+                .map((p) => p.trim())
+                .filter((p) => p);
+            const resources = policyConfig.resources
+                ? policyConfig.resources
+                    .split(',')
+                    .map((r) => r.trim())
+                    .filter((r) => r)
+                : undefined;
+            const principal = {
+                category: principalConfig.category,
+                mode: principalConfig.mode,
+                credentialSource: {
+                    type: principalConfig.credentialType,
+                    ref: credentialRef,
+                },
+                policy: {
+                    permissions,
+                },
+                controls: {
+                    rotationPolicy: {
+                        type: securityConfig.rotationType,
+                        intervalDays: securityConfig.ttlDays,
+                    },
+                    ttl: `${securityConfig.ttlDays}d`,
+                },
+            };
+            if (resources && resources.length > 0) {
+                principal.policy.scope = {
+                    resources,
+                };
+            }
+            this.state.updateAgent({
+                spec: {
+                    principal,
+                },
+            });
+            printSuccess('✅ Principal configured');
+            printInfo(`   Mode: ${principalConfig.mode}`);
+            printInfo(`   Permissions: ${permissions.join(', ')}`);
+            printInfo(`   Rotation: ${securityConfig.rotationType} (${securityConfig.ttlDays} days)`);
+        }
+        else {
+            printInfo('⏭️  No principal configured (agent will use default credentials)');
         }
-        this.state.updateAgent({
-            spec: {
-                llm: llmConfig,
-            },
-        });
-        printSuccess('LLM configuration complete');
     }
     async selectFeatures() {
         this.state.nextStep('Feature Selection');
@@ -913,8 +2200,7 @@ class OSSAWizardV2 {
                     name: 'description',
                     message: 'Skill description:',
                     validate: (input) => {
-                        return (input.length >= 10 ||
-                            'Description must be at least 10 characters');
+                        return (input.length >= 10 || 'Description must be at least 10 characters');
                     },
                 },
                 {
@@ -1490,7 +2776,8 @@ class OSSAWizardV2 {
                         type: 'input',
                         name: 'moduleName',
                         message: 'Drupal module name:',
-                        default: this.state.getAgent().metadata?.name?.replace(/-/g, '_') || 'ossa_agent',
+                        default: this.state.getAgent().metadata?.name?.replace(/-/g, '_') ||
+                            'ossa_agent',
                         validate: (input) => {
                             const valid = /^[a-z][a-z0-9_]*$/.test(input);
                             return valid || 'Must be lowercase alphanumeric with underscores';
@@ -1517,8 +2804,9 @@ class OSSAWizardV2 {
                         type: 'input',
                         name: 'bundleName',
                         message: 'Symfony bundle name:',
-                        default: (this.state.getAgent().metadata?.name
-                            ?.split('-')
+                        default: (this.state
+                            .getAgent()
+                            .metadata?.name?.split('-')
                             .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
                             .join('') || 'Ossa') + 'Bundle',
                     },
@@ -1691,6 +2979,40 @@ class OSSAWizardV2 {
                 message: 'Output file path:',
                 default: this.options.output || 'agent.ossa.yaml',
             },
+            {
+                type: 'confirm',
+                name: 'generate_gaid',
+                message: '🆔 Generate Global Agent ID (GAID)?',
+                default: true,
+            },
+            {
+                type: 'input',
+                name: 'organization',
+                message: '  Organization name (for GAID):',
+                default: 'blueflyio',
+                when: (answers) => answers.generate_gaid,
+            },
+            {
+                type: 'input',
+                name: 'serial_prefix',
+                message: '  Serial number prefix (e.g., "AG", "BOT", "SYS"):',
+                default: 'AG',
+                when: (answers) => answers.generate_gaid,
+            },
+            {
+                type: 'confirm',
+                name: 'register_agent',
+                message: '📡 Register agent to platform registry?',
+                default: false,
+                when: (answers) => answers.generate_gaid,
+            },
+            {
+                type: 'input',
+                name: 'api_url',
+                message: '  Registry API URL:',
+                default: 'https://mesh.blueflyagents.com',
+                when: (answers) => answers.register_agent,
+            },
         ]);
         const agent = this.state.getAgent();
         const outputPath = outputAnswers.output_path;
@@ -1701,6 +3023,65 @@ class OSSAWizardV2 {
         });
         fs.writeFileSync(outputPath, yamlContent, 'utf-8');
         printSuccess(`Agent manifest written to: ${outputPath}`);
+        // Generate GAID if requested
+        if (outputAnswers.generate_gaid) {
+            printInfo('\n🆔 Generating Global Agent ID (GAID)...');
+            const org = outputAnswers.organization || 'blueflyio';
+            const prefix = outputAnswers.serial_prefix || 'AG';
+            // Generate deterministic UUID v5 based on agent metadata
+            const OSSA_NAMESPACE = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+            const agentIdentity = JSON.stringify({
+                name: agent.metadata?.name || 'unnamed',
+                version: agent.metadata?.version || '0.1.0',
+                created: agent.metadata?.created || new Date().toISOString(),
+                organization: org,
+            });
+            const uuid = uuidv5(agentIdentity, OSSA_NAMESPACE);
+            const orgSanitized = org.toLowerCase().replace(/[^a-z0-9]/g, '');
+            const gaid = `did:ossa:${orgSanitized}:${uuid.replace(/-/g, '')}`;
+            // Generate serial number (prefix + timestamp + random)
+            const timestamp = Date.now().toString(36).toUpperCase();
+            const random = Math.random().toString(36).substring(2, 6).toUpperCase();
+            const serialNumber = `${prefix}-${timestamp}-${random}`;
+            // Update agent manifest with GAID and serial number
+            if (!agent.metadata)
+                agent.metadata = {};
+            if (!agent.metadata.annotations)
+                agent.metadata.annotations = {};
+            agent.metadata.annotations['ossa.org/gaid'] = gaid;
+            agent.metadata.annotations['ossa.org/serial-number'] = serialNumber;
+            agent.metadata.annotations['ossa.org/organization'] = org;
+            agent.metadata.annotations['ossa.org/registered-at'] =
+                new Date().toISOString();
+            // Rewrite manifest with GAID
+            const updatedYamlContent = yaml.stringify(agent, {
+                indent: 2,
+                lineWidth: 0,
+            });
+            fs.writeFileSync(outputPath, updatedYamlContent, 'utf-8');
+            printSuccess(`GAID generated: ${gaid}`);
+            printSuccess(`Serial Number: ${serialNumber}`);
+            printInfo(`  Organization: ${org}`);
+            // Registration removed - AgentProtocolClient migrated to @bluefly/agent-protocol
+            if (outputAnswers.register_agent) {
+                printWarning('Agent registration requires @bluefly/agent-protocol package (not included in OSSA spec).');
+                printInfo('Use: npx @bluefly/agent-protocol register <manifest-file>');
+            }
+            // Save GAID info to separate file
+            const gaidInfoPath = outputPath.replace(/\.ossa\.yaml$/, '.gaid.json');
+            const gaidInfo = {
+                gaid,
+                serialNumber,
+                organization: org,
+                generatedAt: new Date().toISOString(),
+                agentName: agent.metadata?.name,
+                agentVersion: agent.metadata?.version,
+                registered: outputAnswers.register_agent &&
+                    agent.metadata?.annotations?.['ossa.org/registered'] === 'true',
+            };
+            fs.writeFileSync(gaidInfoPath, JSON.stringify(gaidInfo, null, 2), 'utf-8');
+            printInfo(`  GAID info saved to: ${gaidInfoPath}`);
+        }
         // Generate AGENTS.md if requested
         if (outputAnswers.generate_agents_md) {
             await this.generateAgentsMd(path.dirname(outputPath));
@@ -1738,7 +3119,9 @@ ${agent.spec?.tools?.map((t) => `- ${t.name || t.type}`).join('\n') || 'No tools
 
 ### Features
 
-${this.state.getState().features.rag ? '- ✅ RAG & Vector Database\n' : ''}${this.state.getState().features.communication ? '- ✅ Agent Communication (A2A)\n' : ''}${this.state.getState().features.state_management ? '- ✅ State Management\n' : ''}${this.state.getState().features.observability ? '- ✅ Observability\n' : ''}${this.state.getState().features.cost_management ? '- ✅ Cost Management\n' : ''}
+${this.state.getState().features.rag ? '- ✅ RAG & Vector Database\n' : ''}${this.state.getState().features.communication
+            ? '- ✅ Agent Communication (A2A)\n'
+            : ''}${this.state.getState().features.state_management ? '- ✅ State Management\n' : ''}${this.state.getState().features.observability ? '- ✅ Observability\n' : ''}${this.state.getState().features.cost_management ? '- ✅ Cost Management\n' : ''}
 
 ## Usage
 
@@ -1836,21 +3219,23 @@ For more information, see AGENTS.md
         console.log(chalk.cyan('Next Steps:'));
         console.log(chalk.gray(`\n1. Review your agent:`));
         console.log(chalk.white(`   cat ${outputPath}`));
-        console.log(chalk.gray(`\n2. Validate the manifest:`));
+        console.log(chalk.gray(`\n2. Verify agent identity (if GAID generated):`));
+        console.log(chalk.white(`   ossa verify <GAID>`));
+        console.log(chalk.gray(`\n3. Validate the manifest:`));
         console.log(chalk.white(`   ossa validate ${outputPath}`));
-        console.log(chalk.gray(`\n3. Test the agent:`));
+        console.log(chalk.gray(`\n4. Test the agent:`));
         console.log(chalk.white(`   ossa run ${outputPath}`));
         if (this.state.getState().features.rag) {
-            console.log(chalk.gray(`\n4. Set up vector database (RAG):`));
+            console.log(chalk.gray(`\n5. Set up vector database (RAG):`));
             console.log(chalk.white(`   # Configure your Qdrant/Pinecone instance`));
         }
         if (this.state.getState().features.communication) {
-            console.log(chalk.gray(`\n5. Set up message broker (A2A):`));
+            console.log(chalk.gray(`\n6. Set up message broker (A2A):`));
             console.log(chalk.white(`   # Start Redis/NATS for agent communication`));
         }
-        console.log(chalk.gray(`\n6. Export to platform:`));
+        console.log(chalk.gray(`\n7. Export to platform:`));
         console.log(chalk.white(`   ossa export ${outputPath} --platform langchain`));
-        console.log(chalk.gray(`\n7. Deploy:`));
+        console.log(chalk.gray(`\n8. Deploy:`));
         console.log(chalk.white(`   # Follow platform-specific deployment guide`));
         console.log('');
         console.log(chalk.green.bold('🎉 Your agent is ready for production!'));