@vibecheckai/cli 3.6.1 → 3.8.0

package/mcp-server/registry/tool-registry.js

@@ -1,358 +1,220 @@
 /**
- * Single Source of Truth for MCP Tool Registry
+ * MCP Tool Registry - Canonical Tools Only
  * 
- * Defines all MCP tools with:
- * - Input/output schemas (JSON Schema)
- * - Tier requirements (free/pro)
- * - Timeouts
- * - Rate limits
- * - Option-level gates
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * VERSION 4.0.0 - CLEAN & TIGHT
+ * ═══════════════════════════════════════════════════════════════════════════════
  * 
- * This registry is used for:
- * - Input validation
- * - Output validation (warnings)
- * - Tier enforcement
- * - Timeout configuration
- * - Rate limit configuration
+ * Single source of truth for all MCP tools.
+ * No legacy aliases. No deprecated mappings.
+ * 
+ * @version 4.1.0
  */
 
 const Ajv = require('ajv');
 const ajv = new Ajv({ allErrors: true, strict: false });
 
-// Note: Tool tier definitions are defined here in TOOL_REGISTRY
-// This is the single source of truth - tier-auth.js references this for consistency
-
-/**
- * Tool Definition Schema
- * @typedef {Object} ToolDefinition
- * @property {string} name - Tool name
- * @property {string} description - Tool description
- * @property {'free'|'pro'} tier - Required tier
- * @property {string} category - Tool category
- * @property {object} inputSchema - JSON Schema for input validation
- * @property {object} outputSchema - JSON Schema for output validation (optional)
- * @property {Array<{name: string, tier?: 'pro', description: string}>} options - Option-level gates
- * @property {{perMinute: number, perHour?: number}} rateLimit - Rate limit override (optional)
- * @property {number} timeout - Timeout in milliseconds
- */
-
 /**
- * Tool Registry - Single Source of Truth
+ * Tool Registry - Canonical Tools Only
  */
 const TOOL_REGISTRY = {
   // ═══════════════════════════════════════════════════════════════════════════
-  // FREE TOOLS
+  // SETUP (FREE)
   // ═══════════════════════════════════════════════════════════════════════════
   
-  'vibecheck.scan': {
-    name: 'vibecheck.scan',
-    description: 'Scan codebase for issues (routes, env, auth, security)',
-    tier: 'free',
-    category: 'analysis',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectPath: { type: 'string', description: 'Project path' },
-        categories: {
-          type: 'array',
-          items: { type: 'string' },
-          description: 'Categories: routes, env, auth, billing, security',
-        },
-        since: {
-          type: 'string',
-          description: 'ISO timestamp for incremental scan',
-        },
-        noCache: { type: 'boolean', default: false },
-      },
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        findings: { type: 'array' },
-        summary: { type: 'object' },
-        cacheStats: { type: 'object' },
-      },
-    },
-    options: [
-      { name: 'autofix', tier: 'pro', description: 'Auto-fix issues' },
-      { name: 'fix', tier: 'pro', description: 'Fix mode' },
-    ],
-    rateLimit: { perMinute: 10 },
-    timeout: 300000, // 5 min
-  },
-  
-  'vibecheck.ctx': {
-    name: 'vibecheck.ctx',
-    description: 'Generate truth context for AI agents',
-    tier: 'free',
-    category: 'context',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectPath: { type: 'string' },
-        scope: {
-          type: 'string',
-          enum: ['all', 'routes', 'env', 'auth', 'billing'],
-          default: 'all',
-        },
-      },
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        context: { type: 'object' },
-      },
-    },
-    timeout: 120000, // 2 min
-  },
-  
-  'vibecheck.verify': {
-    name: 'vibecheck.verify',
-    description: 'Verify AI-generated code before applying',
-    tier: 'free',
-    category: 'validation',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        code: { type: 'string', description: 'Code to verify' },
-        file: { type: 'string' },
-        projectPath: { type: 'string' },
-      },
-      required: ['code'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        verified: { type: 'boolean' },
-        issues: { type: 'array' },
-      },
-    },
-    timeout: 60000, // 1 min
-  },
-  
-  'vibecheck.report': {
-    name: 'vibecheck.report',
-    description: 'Generate reports',
+  'vibecheck.link': {
+    name: 'vibecheck.link',
+    description: 'One-time project setup: config, contracts, scripts',
     tier: 'free',
-    category: 'reporting',
+    category: 'setup',
     inputSchema: {
       type: 'object',
       properties: {
-        projectPath: { type: 'string' },
-        format: { type: 'string', enum: ['html', 'md', 'sarif', 'json'], default: 'html' },
-      },
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        report: { type: 'string' },
+        projectPath: { type: 'string', default: '.' },
+        force: { type: 'boolean', default: false },
       },
     },
-    timeout: 120000, // 2 min
+    timeout: 60000,
   },
   
-  'vibecheck.status': {
-    name: 'vibecheck.status',
-    description: 'Check vibecheck status and health',
+  'vibecheck.kickoff': {
+    name: 'vibecheck.kickoff',
+    description: 'Interactive guided onboarding experience',
     tier: 'free',
-    category: 'diagnostics',
+    category: 'setup',
     inputSchema: {
       type: 'object',
       properties: {
-        projectPath: { type: 'string' },
-      },
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        status: { type: 'object' },
+        projectPath: { type: 'string', default: '.' },
       },
     },
-    timeout: 30000, // 30s
+    timeout: 120000,
   },
   
   'vibecheck.doctor': {
     name: 'vibecheck.doctor',
-    description: 'Diagnose and fix environment issues',
+    description: 'Environment, dependency, and configuration health check',
     tier: 'free',
-    category: 'diagnostics',
+    category: 'setup',
     inputSchema: {
       type: 'object',
       properties: {
-        projectPath: { type: 'string' },
+        projectPath: { type: 'string', default: '.' },
         fix: { type: 'boolean', default: false },
-        noCache: { type: 'boolean', default: false },
+        verbose: { type: 'boolean', default: false },
       },
     },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        checks: { type: 'array' },
-        cacheStats: { type: 'object' },
-      },
-    },
-    timeout: 60000, // 1 min
+    timeout: 60000,
   },
   
-  'vibecheck.firewall': {
-    name: 'vibecheck.firewall',
-    description: 'Agent Firewall - observe mode (FREE) or enforce mode (PRO)',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ANALYSIS (FREE)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.audit': {
+    name: 'vibecheck.audit',
+    description: 'Analyze codebase for issues (routes, env, auth, security, dead code)',
     tier: 'free',
-    category: 'security',
+    category: 'analysis',
     inputSchema: {
       type: 'object',
       properties: {
-        action: { type: 'string', enum: ['check', 'status', 'log'] },
-        code: { type: 'string' },
-        file: { type: 'string' },
-      },
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        mode: { type: 'string', enum: ['observe', 'enforce'] },
-        checked: { type: 'boolean' },
-        violations: { type: 'array' },
+        projectPath: { type: 'string', default: '.' },
+        categories: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Categories: routes, env, auth, billing, security, dead-code',
+        },
+        profile: {
+          type: 'string',
+          enum: ['quick', 'standard', 'full'],
+          default: 'standard',
+        },
       },
     },
     options: [
-      { name: 'enforce', tier: 'pro', description: 'Enable enforce mode' },
-      { name: 'mode', tier: 'pro', description: 'Set mode to enforce' },
+      { name: 'fix', tier: 'pro', description: 'Auto-fix issues' },
     ],
-    timeout: 60000, // 1 min
+    rateLimit: { perMinute: 10 },
+    timeout: 300000,
   },
   
-  'authority.list': {
-    name: 'authority.list',
-    description: 'List available authorities',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // TRUTH (FREE)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.forge': {
+    name: 'vibecheck.forge',
+    description: 'Generate IDE rules and AI context (.cursorrules, MDC, Copilot)',
     tier: 'free',
-    category: 'authority',
+    category: 'truth',
     inputSchema: {
       type: 'object',
       properties: {
-        tier: { type: 'string', enum: ['free', 'pro'] },
-      },
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        authorities: { type: 'array' },
+        projectPath: { type: 'string', default: '.' },
+        format: {
+          type: 'string',
+          enum: ['cursor', 'copilot', 'windsurf', 'all'],
+          default: 'all',
+        },
       },
     },
-    timeout: 30000, // 30s
+    timeout: 60000,
   },
   
-  'authority.classify': {
-    name: 'authority.classify',
-    description: 'Inventory Authority - analyze duplication and legacy code',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ENFORCEMENT (FREE base, PRO options)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.shield': {
+    name: 'vibecheck.shield',
+    description: 'Agent Firewall - intercept, validate, enforce AI actions',
     tier: 'free',
-    category: 'authority',
+    category: 'enforcement',
     inputSchema: {
       type: 'object',
       properties: {
+        action: {
+          type: 'string',
+          enum: ['status', 'verify', 'enforce', 'observe', 'lock', 'unlock', 'install', 'stats', 'check'],
+          default: 'status',
+        },
+        code: { type: 'string', description: 'Code to verify' },
+        file: { type: 'string', description: 'File path' },
+        claims: { type: 'boolean', default: false },
+        prompts: { type: 'boolean', default: false },
         projectPath: { type: 'string', default: '.' },
-        includeNear: { type: 'boolean', default: true },
-        format: { type: 'string', enum: ['json', 'table', 'markdown'], default: 'json' },
       },
     },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        classification: { type: 'object' },
-      },
-    },
-    timeout: 120000, // 2 min
+    options: [
+      { name: 'enforce', tier: 'pro', description: 'Enable enforce mode' },
+      { name: 'lock', tier: 'pro', description: 'Enable repo-lock mode' },
+      { name: 'install', tier: 'pro', description: 'Install IDE hooks' },
+      { name: 'check', tier: 'pro', description: 'v2 enforcement check' },
+    ],
+    timeout: 120000,
   },
   
-  'vibecheck_conductor_status': {
-    name: 'vibecheck_conductor_status',
-    description: 'Get multi-agent coordination status',
+  'vibecheck.intent': {
+    name: 'vibecheck.intent',
+    description: 'Declare and manage AI session intent for enforcement',
     tier: 'free',
-    category: 'conductor',
+    category: 'enforcement',
     inputSchema: {
       type: 'object',
       properties: {
-        projectRoot: { type: 'string' },
-        includeDetails: { type: 'boolean', default: false },
-      },
-      required: ['projectRoot'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        status: { type: 'object' },
+        action: {
+          type: 'string',
+          enum: ['set', 'show', 'clear', 'history'],
+          default: 'show',
+        },
+        summary: { type: 'string', description: 'Intent summary (for set action)' },
+        constraints: { type: 'array', items: { type: 'string' } },
+        projectPath: { type: 'string', default: '.' },
       },
     },
-    timeout: 30000, // 30s
+    timeout: 30000,
   },
   
   // ═══════════════════════════════════════════════════════════════════════════
-  // PRO TOOLS
+  // PROOF (PRO)
   // ═══════════════════════════════════════════════════════════════════════════
   
   'vibecheck.ship': {
     name: 'vibecheck.ship',
-    description: 'Get ship verdict: SHIP | WARN | BLOCK',
+    description: 'Verdict engine - SHIP/WARN/BLOCK with evidence-backed decision',
     tier: 'pro',
-    category: 'verdicts',
+    category: 'proof',
     inputSchema: {
       type: 'object',
       properties: {
-        projectPath: { type: 'string' },
-        strict: { type: 'boolean' },
-        since: { type: 'string' },
-        noCache: { type: 'boolean', default: false },
-      },
-      required: ['projectPath'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        verdict: { type: 'string', enum: ['SHIP', 'WARN', 'BLOCK'] },
-        reasons: { type: 'array' },
-        cacheStats: { type: 'object' },
+        projectPath: { type: 'string', default: '.' },
+        strict: { type: 'boolean', default: false },
+        badge: { type: 'boolean', default: false },
       },
     },
-    rateLimit: { perMinute: 10 },
-    timeout: 300000, // 5 min
+    timeout: 300000,
   },
   
   'vibecheck.fix': {
     name: 'vibecheck.fix',
-    description: 'AI-powered fixes with proof',
+    description: 'AI-powered auto-fix for detected findings',
     tier: 'pro',
-    category: 'fixes',
+    category: 'proof',
     inputSchema: {
       type: 'object',
       properties: {
-        projectPath: { type: 'string' },
-        mode: { type: 'string', enum: ['plan', 'apply', 'loop'], default: 'plan' },
+        projectPath: { type: 'string', default: '.' },
+        mode: {
+          type: 'string',
+          enum: ['plan', 'apply', 'loop'],
+          default: 'plan',
+        },
         findingIds: { type: 'array', items: { type: 'string' } },
-      },
-      required: ['projectPath'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        plan: { type: 'array' },
-        applied: { type: 'boolean' },
+        dryRun: { type: 'boolean', default: false },
       },
     },
-    options: [
-      { name: 'apply', tier: 'pro', description: 'Apply fixes' },
-      { name: 'loop', tier: 'pro', description: 'Loop mode' },
-    ],
-    timeout: 600000, // 10 min
+    timeout: 600000,
   },
   
   'vibecheck.prove': {
@@ -363,72 +225,18 @@ const TOOL_REGISTRY = {
     inputSchema: {
       type: 'object',
       properties: {
-        projectPath: { type: 'string' },
+        projectPath: { type: 'string', default: '.' },
         url: { type: 'string' },
         maxIterations: { type: 'number', default: 5 },
         recordVideo: { type: 'boolean', default: true },
       },
-      required: ['projectPath'],
     },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        proof: { type: 'object' },
-      },
-    },
-    timeout: 600000, // 10 min
-  },
-  
-  'vibecheck.gate': {
-    name: 'vibecheck.gate',
-    description: 'CI/CD enforcement - fail builds on issues',
-    tier: 'pro',
-    category: 'enforcement',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectPath: { type: 'string' },
-        strict: { type: 'boolean' },
-      },
-      required: ['projectPath'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        passed: { type: 'boolean' },
-      },
-    },
-    timeout: 300000, // 5 min
-  },
-  
-  'vibecheck.badge': {
-    name: 'vibecheck.badge',
-    description: 'Generate ship badge',
-    tier: 'pro',
-    category: 'reporting',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        projectPath: { type: 'string' },
-        outputPath: { type: 'string' },
-      },
-      required: ['projectPath'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        badge: { type: 'string' },
-      },
-    },
-    timeout: 120000, // 2 min
+    timeout: 900000,
   },
   
   'vibecheck.reality': {
     name: 'vibecheck.reality',
-    description: 'Full runtime verification with auth boundary testing',
+    description: 'Browser-based runtime verification with auth boundary testing',
     tier: 'pro',
     category: 'proof',
     inputSchema: {
@@ -436,263 +244,256 @@ const TOOL_REGISTRY = {
       properties: {
         url: { type: 'string' },
         auth: { type: 'string' },
-        headed: { type: 'boolean' },
+        headed: { type: 'boolean', default: false },
         maxPages: { type: 'number', default: 20 },
       },
       required: ['url'],
     },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        results: { type: 'array' },
-      },
-    },
-    options: [
-      { name: 'full', tier: 'pro', description: 'Full mode' },
-      { name: 'auth', tier: 'pro', description: 'Auth boundary testing' },
-    ],
-    timeout: 300000, // 5 min
+    timeout: 600000,
   },
   
-  'vibecheck.ai_test': {
-    name: 'vibecheck.ai_test',
-    description: 'AI agent testing - autonomous exploration',
+  'vibecheck.checkpoint': {
+    name: 'vibecheck.checkpoint',
+    description: 'Compare baseline vs current state',
     tier: 'pro',
-    category: 'testing',
+    category: 'proof',
     inputSchema: {
       type: 'object',
       properties: {
-        url: { type: 'string' },
-        goal: { type: 'string' },
-        maxActions: { type: 'number', default: 50 },
-      },
-      required: ['url'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        testResults: { type: 'array' },
+        projectPath: { type: 'string', default: '.' },
+        baseline: { type: 'string' },
       },
     },
-    timeout: 300000, // 5 min
+    timeout: 120000,
   },
   
-  'vibecheck.share': {
-    name: 'vibecheck.share',
-    description: 'Generate PR/review bundle',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // AUTOMATION (PRO)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.launch': {
+    name: 'vibecheck.launch',
+    description: 'CI/CD enforcement - preflight checks and deploy gates',
     tier: 'pro',
-    category: 'reporting',
+    category: 'automation',
     inputSchema: {
       type: 'object',
       properties: {
-        projectPath: { type: 'string' },
-        format: { type: 'string', enum: ['github', 'gitlab', 'slack', 'json'], default: 'github' },
-      },
-      required: ['projectPath'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        bundle: { type: 'object' },
+        projectPath: { type: 'string', default: '.' },
+        action: {
+          type: 'string',
+          enum: ['preflight', 'prelaunch', 'check'],
+          default: 'preflight',
+        },
+        strict: { type: 'boolean', default: false },
       },
     },
-    timeout: 120000, // 2 min
+    timeout: 300000,
   },
   
-  'authority.approve': {
-    name: 'authority.approve',
-    description: 'Execute authority & get verdict (PROCEED/STOP/DEFER)',
-    tier: 'pro',
-    category: 'authority',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // OUTPUT (FREE base, PRO options)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.packs': {
+    name: 'vibecheck.packs',
+    description: 'Generate shareable artifact packs: reports, evidence, proof graphs',
+    tier: 'free',
+    category: 'output',
     inputSchema: {
       type: 'object',
       properties: {
-        authority: { type: 'string' },
+        action: {
+          type: 'string',
+          enum: ['evidence', 'report', 'graph', 'permissions', 'manifest'],
+          default: 'evidence',
+        },
         projectPath: { type: 'string', default: '.' },
-        dryRun: { type: 'boolean', default: false },
-      },
-      required: ['authority'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        verdict: { type: 'string', enum: ['PROCEED', 'STOP', 'DEFER'] },
-        proof: { type: 'object' },
+        format: {
+          type: 'string',
+          enum: ['html', 'md', 'sarif', 'json', 'csv', 'pdf', 'dot', 'mermaid'],
+          default: 'html',
+        },
+        output: { type: 'string' },
       },
     },
-    timeout: 300000, // 5 min
+    timeout: 120000,
   },
   
-  'vibecheck_conductor_register': {
-    name: 'vibecheck_conductor_register',
-    description: 'Register AI agent for multi-agent coordination',
+  'vibecheck.seal': {
+    name: 'vibecheck.seal',
+    description: 'Generate verification seal/badge with cryptographic attestation',
     tier: 'pro',
-    category: 'conductor',
+    category: 'output',
     inputSchema: {
       type: 'object',
       properties: {
-        agentId: { type: 'string' },
-        projectRoot: { type: 'string' },
-        workingFiles: { type: 'array', items: { type: 'string' } },
-      },
-      required: ['agentId', 'projectRoot'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        sessionId: { type: 'string' },
+        projectPath: { type: 'string', default: '.' },
+        format: {
+          type: 'string',
+          enum: ['svg', 'png', 'json'],
+          default: 'svg',
+        },
+        output: { type: 'string' },
+        attest: { type: 'boolean', default: false },
       },
     },
-    timeout: 30000, // 30s
+    timeout: 60000,
   },
   
-  'vibecheck_conductor_acquire_lock': {
-    name: 'vibecheck_conductor_acquire_lock',
-    description: 'Acquire lock on file/folder for exclusive access',
-    tier: 'pro',
-    category: 'conductor',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // CONFIG (FREE)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.safelist': {
+    name: 'vibecheck.safelist',
+    description: 'Manage finding safelist for false positives',
+    tier: 'free',
+    category: 'config',
     inputSchema: {
       type: 'object',
       properties: {
-        sessionId: { type: 'string' },
-        path: { type: 'string' },
-        type: { type: 'string', enum: ['exclusive', 'shared'], default: 'exclusive' },
+        projectPath: { type: 'string', default: '.' },
+        action: {
+          type: 'string',
+          enum: ['list', 'add', 'remove'],
+          default: 'list',
+        },
+        id: { type: 'string' },
+        pattern: { type: 'string' },
         reason: { type: 'string' },
       },
-      required: ['sessionId', 'path'],
     },
-    outputSchema: {
+    timeout: 30000,
+  },
+  
+  // ═══════════════════════════════════════════════════════════════════════════
+  // ACCOUNT (FREE)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.auth': {
+    name: 'vibecheck.auth',
+    description: 'Authentication management: login, logout, whoami',
+    tier: 'free',
+    category: 'account',
+    inputSchema: {
       type: 'object',
       properties: {
-        success: { type: 'boolean' },
-        lockId: { type: 'string' },
+        action: {
+          type: 'string',
+          enum: ['login', 'logout', 'whoami', 'status'],
+          default: 'whoami',
+        },
+        apiKey: { type: 'string' },
       },
     },
-    timeout: 30000, // 30s
+    timeout: 30000,
   },
   
-  'vibecheck_conductor_release_lock': {
-    name: 'vibecheck_conductor_release_lock',
-    description: 'Release a previously acquired lock',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // AUTHORITY (PRO)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.approve': {
+    name: 'vibecheck.approve',
+    description: 'Authority verdicts - PROCEED/STOP/DEFER with proofs',
     tier: 'pro',
-    category: 'conductor',
+    category: 'authority',
     inputSchema: {
       type: 'object',
       properties: {
-        lockId: { type: 'string' },
-        sessionId: { type: 'string' },
-      },
-      required: ['lockId', 'sessionId'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
+        authority: { type: 'string' },
+        projectPath: { type: 'string', default: '.' },
+        dryRun: { type: 'boolean', default: false },
       },
+      required: ['authority'],
     },
-    timeout: 30000, // 30s
+    timeout: 300000,
   },
   
-  'vibecheck_conductor_propose': {
-    name: 'vibecheck_conductor_propose',
-    description: 'Submit change proposal for multi-agent coordination',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // QUALITY (PRO)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.polish': {
+    name: 'vibecheck.polish',
+    description: 'Code polish and cleanup',
     tier: 'pro',
-    category: 'conductor',
+    category: 'quality',
     inputSchema: {
       type: 'object',
       properties: {
-        sessionId: { type: 'string' },
-        proposalId: { type: 'string' },
-        intent: { type: 'string' },
-        operations: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              type: { type: 'string', enum: ['create', 'modify', 'delete', 'move'] },
-              path: { type: 'string' },
-              content: { type: 'string' },
-            },
-          },
+        projectPath: { type: 'string', default: '.' },
+        scope: {
+          type: 'string',
+          enum: ['all', 'lint', 'format', 'imports'],
+          default: 'all',
         },
-        projectRoot: { type: 'string' },
-      },
-      required: ['sessionId', 'proposalId', 'intent', 'operations', 'projectRoot'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
-        approved: { type: 'boolean' },
       },
     },
-    timeout: 60000, // 1 min
+    timeout: 300000,
   },
   
-  'vibecheck_conductor_terminate': {
-    name: 'vibecheck_conductor_terminate',
-    description: 'Terminate agent session and release all locks',
-    tier: 'pro',
-    category: 'conductor',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // LABS (FREE)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.labs': {
+    name: 'vibecheck.labs',
+    description: 'Access experimental features',
+    tier: 'free',
+    category: 'experimental',
     inputSchema: {
       type: 'object',
       properties: {
-        sessionId: { type: 'string' },
-      },
-      required: ['sessionId'],
-    },
-    outputSchema: {
-      type: 'object',
-      properties: {
-        success: { type: 'boolean' },
+        feature: { type: 'string' },
+        projectPath: { type: 'string', default: '.' },
       },
     },
-    timeout: 30000, // 30s
+    timeout: 60000,
   },
   
-  'vibecheck_agent_firewall_intercept': {
-    name: 'vibecheck_agent_firewall_intercept',
-    description: 'Agent Firewall (Sentinel) - ENFORCE MODE',
-    tier: 'pro',
-    category: 'security',
+  // ═══════════════════════════════════════════════════════════════════════════
+  // MCP SERVER (FREE)
+  // ═══════════════════════════════════════════════════════════════════════════
+  
+  'vibecheck.health': {
+    name: 'vibecheck.health',
+    description: 'MCP server health check - returns server status, version, and diagnostics',
+    tier: 'free',
+    category: 'setup',
     inputSchema: {
       type: 'object',
-      properties: {
-        agentId: { type: 'string' },
-        filePath: { type: 'string' },
-        content: { type: 'string' },
-        operation: { type: 'string', enum: ['create', 'modify', 'delete'], default: 'modify' },
-        intent: { type: 'string' },
-        projectRoot: { type: 'string' },
-      },
-      required: ['agentId', 'filePath', 'content'],
+      properties: {},
     },
-    outputSchema: {
+    timeout: 5000,
+  },
+  
+  'vibecheck.manifest': {
+    name: 'vibecheck.manifest',
+    description: 'Get the complete tool manifest with schemas and documentation',
+    tier: 'free',
+    category: 'setup',
+    inputSchema: {
       type: 'object',
       properties: {
-        allowed: { type: 'boolean' },
-        violations: { type: 'array' },
-        proof: { type: 'object' },
+        format: {
+          type: 'string',
+          enum: ['json', 'summary'],
+          default: 'summary',
+        },
       },
     },
-    timeout: 120000, // 2 min
+    timeout: 5000,
   },
 };
 
 // ============================================================================
-// VALIDATION FUNCTIONS
+// HELPER FUNCTIONS
 // ============================================================================
 
 /**
  * Validate tool input against JSON Schema
- * @param {string} toolName - Tool name
- * @param {unknown} input - Input to validate
- * @returns {{ valid: boolean, errors?: string[] }}
  */
 function validateToolInput(toolName, input) {
   const tool = TOOL_REGISTRY[toolName];
@@ -701,7 +502,6 @@ function validateToolInput(toolName, input) {
   }
   
   const validate = ajv.compile(tool.inputSchema);
-  
   if (!validate(input)) {
     return {
       valid: false,
@@ -712,62 +512,29 @@ function validateToolInput(toolName, input) {
   return { valid: true };
 }
 
-/**
- * Validate tool output against JSON Schema (warns on mismatch, doesn't fail)
- * @param {string} toolName - Tool name
- * @param {unknown} output - Output to validate
- * @returns {{ valid: boolean, errors?: string[] }}
- */
-function validateToolOutput(toolName, output) {
-  const tool = TOOL_REGISTRY[toolName];
-  if (!tool || !tool.outputSchema) {
-    return { valid: true }; // Unknown tool or no schema, skip validation
-  }
-  
-  const validate = ajv.compile(tool.outputSchema);
-  
-  if (!validate(output)) {
-    // Log warning but don't fail - output validation is advisory
-    console.warn(`[MCP] Tool ${toolName} output validation failed:`, validate.errors);
-    return {
-      valid: false,
-      errors: validate.errors?.map((e) => `${e.instancePath || '/'} ${e.message}`) || ['Validation failed'],
-    };
-  }
-  
-  return { valid: true };
-}
-
 /**
  * Get tool tier requirement
- * @param {string} toolName - Tool name
- * @returns {'free'|'pro'} Tier requirement (defaults to 'pro' for unknown tools)
  */
 function getToolTier(toolName) {
-  return TOOL_REGISTRY[toolName]?.tier || 'pro'; // Default to PRO for unknown tools
+  return TOOL_REGISTRY[toolName]?.tier || 'pro';
 }
 
 /**
  * Get tool timeout
- * @param {string} toolName - Tool name
- * @returns {number} Timeout in milliseconds (defaults to 30000)
  */
 function getToolTimeout(toolName) {
-  return TOOL_REGISTRY[toolName]?.timeout || 30000; // Default 30s
+  return TOOL_REGISTRY[toolName]?.timeout || 30000;
 }
 
 /**
- * Get tool rate limit override (if any)
- * @param {string} toolName - Tool name
- * @returns {{perMinute: number, perHour?: number}|null} Rate limit override or null
+ * Get tool rate limit
  */
 function getToolRateLimit(toolName) {
   return TOOL_REGISTRY[toolName]?.rateLimit || null;
 }
 
 /**
- * Get all registered tool names
- * @returns {string[]} Array of tool names
+ * Get all tool names
  */
 function getAllToolNames() {
   return Object.keys(TOOL_REGISTRY);
@@ -775,20 +542,45 @@ function getAllToolNames() {
 
 /**
  * Get tool definition
- * @param {string} toolName - Tool name
- * @returns {ToolDefinition|undefined} Tool definition
  */
 function getToolDefinition(toolName) {
   return TOOL_REGISTRY[toolName];
 }
 
+/**
+ * Check if tool exists
+ */
+function isValidTool(toolName) {
+  return toolName in TOOL_REGISTRY;
+}
+
+/**
+ * Get tools by tier
+ */
+function getToolsByTier(tier) {
+  return Object.entries(TOOL_REGISTRY)
+    .filter(([, tool]) => tool.tier === tier)
+    .map(([name]) => name);
+}
+
+/**
+ * Get tools by category
+ */
+function getToolsByCategory(category) {
+  return Object.entries(TOOL_REGISTRY)
+    .filter(([, tool]) => tool.category === category)
+    .map(([name]) => name);
+}
+
 module.exports = {
   TOOL_REGISTRY,
   validateToolInput,
-  validateToolOutput,
   getToolTier,
   getToolTimeout,
   getToolRateLimit,
   getAllToolNames,
   getToolDefinition,
+  isValidTool,
+  getToolsByTier,
+  getToolsByCategory,
 };