agentaudit 3.12.0 → 3.12.2

package/cli.mjs

@@ -150,6 +150,36 @@ const USER_CRED_DIR = path.join(xdgConfig, 'agentaudit');
 const USER_CRED_FILE = path.join(USER_CRED_DIR, 'credentials.json');
 const SKILL_CRED_FILE = path.join(SKILL_DIR, 'config', 'credentials.json');
 const PROFILE_CACHE_FILE = path.join(USER_CRED_DIR, 'profile-cache.json');
+const HISTORY_DIR = path.join(USER_CRED_DIR, 'history');
+
+function saveHistory(report) {
+  try {
+    fs.mkdirSync(HISTORY_DIR, { recursive: true });
+    const slug = report.skill_slug || 'unknown';
+    const model = (report.audit_model || 'unknown').replace(/[^a-z0-9-]/gi, '-').slice(0, 30);
+    const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const filename = `${ts}_${slug}_${model}.json`;
+    fs.writeFileSync(path.join(HISTORY_DIR, filename), JSON.stringify(report, null, 2));
+  } catch {}
+}
+
+function loadHistory(limit = 20) {
+  try {
+    if (!fs.existsSync(HISTORY_DIR)) return [];
+    const files = fs.readdirSync(HISTORY_DIR)
+      .filter(f => f.endsWith('.json'))
+      .sort()
+      .reverse()
+      .slice(0, limit);
+    return files.map(f => {
+      try {
+        const data = JSON.parse(fs.readFileSync(path.join(HISTORY_DIR, f), 'utf8'));
+        data._file = f;
+        return data;
+      } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
 
 function loadCredentials() {
   for (const f of [SKILL_CRED_FILE, USER_CRED_FILE]) {
@@ -222,6 +252,37 @@ function resolveProvider() {
   return LLM_PROVIDERS.find(p => process.env[p.key]) || null;
 }
 
+function resolveModel(modelName) {
+  // model with '/' → OpenRouter
+  if (modelName.includes('/')) {
+    const p = LLM_PROVIDERS.find(p => p.provider === 'openrouter' && process.env[p.key]);
+    if (p) return { ...p, model: modelName };
+    return null;
+  }
+  // Known prefix → native provider
+  const prefixes = [
+    ['claude', 'anthropic'], ['gemini', 'google'], ['gpt', 'openai'],
+    ['deepseek', 'deepseek'], ['mistral', 'mistral'], ['grok', 'xai'], ['glm', 'zhipu'],
+  ];
+  for (const [prefix, prov] of prefixes) {
+    if (modelName.toLowerCase().startsWith(prefix)) {
+      const p = LLM_PROVIDERS.find(p => p.provider === prov && process.env[p.key]);
+      if (p) return { ...p, model: modelName };
+    }
+  }
+  // Check PROVIDER_MODELS for exact match
+  for (const [prov, models] of Object.entries(PROVIDER_MODELS)) {
+    if (models.some(m => m.value === modelName)) {
+      const p = LLM_PROVIDERS.find(p => p.provider === prov && process.env[p.key]);
+      if (p) return { ...p, model: modelName };
+    }
+  }
+  // Last resort: OpenRouter
+  const or = LLM_PROVIDERS.find(p => p.provider === 'openrouter' && process.env[p.key]);
+  if (or) return { ...or, model: modelName };
+  return null;
+}
+
 function saveCredentials(data) {
   const json = JSON.stringify(data, null, 2);
   fs.mkdirSync(USER_CRED_DIR, { recursive: true });
@@ -643,15 +704,17 @@ function padLeft(str, len) {
 
 function drawBox(title, contentLines, width) {
   const inner = width - 4; // 2 for "│ " + 2 for " │"
+  const totalDash = inner + 2; // total horizontal line chars between corners
   const lines = [];
   const titleStr = title ? ` ${title} ` : '';
   const titleLen = visLen(titleStr);
-  const topDash = BOX.h.repeat(Math.max(1, inner + 2 - titleLen));
-  lines.push(`  ${BOX.tl}${c.dim}─${c.reset}${c.bold}${titleStr}${c.reset}${c.dim}${topDash}${c.reset}${BOX.tr}`);
+  // Top: ╭─ Title ────────────╮  (1 dash before title + title + remaining dashes)
+  const topDash = BOX.h.repeat(Math.max(1, totalDash - 1 - titleLen));
+  lines.push(`  ${BOX.tl}${c.dim}${BOX.h}${c.reset}${c.bold}${titleStr}${c.reset}${c.dim}${topDash}${c.reset}${BOX.tr}`);
   for (const line of contentLines) {
     lines.push(`  ${BOX.v} ${padRight(line, inner + 1)}${BOX.v}`);
   }
-  lines.push(`  ${BOX.bl}${c.dim}${BOX.h.repeat(inner + 2)}${c.reset}${BOX.br}`);
+  lines.push(`  ${BOX.bl}${c.dim}${BOX.h.repeat(totalDash)}${c.reset}${BOX.br}`);
   return lines;
 }
 
@@ -929,24 +992,38 @@ function detectPackageInfo(repoPath, files) {
     info.type = 'library';
   }
   
-  // Extract MCP tools (look for tool definitions)
+  // Extract MCP tools — only from files that reference MCP SDK
+  const mcpKeywords = ['modelcontextprotocol', 'FastMCP', 'mcp.server', 'mcp_server', '@mcp.tool', '@server.tool', '.tool(', 'ListTools', 'CallTool'];
+  const mcpFiles = files.filter(f => mcpKeywords.some(kw => f.content.includes(kw)));
+  // Fallback: if no MCP-specific files found, try entrypoint files
+  if (mcpFiles.length === 0) {
+    const entryNames = ['index.js', 'index.ts', 'index.mjs', 'main.py', 'server.py', 'app.py', 'src/index.ts', 'src/main.ts', 'src/index.js'];
+    for (const f of files) {
+      if (entryNames.includes(f.path)) mcpFiles.push(f);
+    }
+  }
+
   const toolPatterns = [
-    // JS/TS: name: 'tool_name' or "tool_name" in tool definitions
-    /(?:name|tool_name)['":\s]+['"]([a-z_][a-z0-9_]*)['"]/gi,
-    // Python: @mcp.tool() def func_name or Tool(name="...")
-    /(?:@(?:mcp|server)\.tool\(\)[\s\S]*?def\s+([a-z_][a-z0-9_]*))|(?:Tool\s*\(\s*name\s*=\s*['"]([a-z_][a-z0-9_]*)['"])/gi,
-    // Direct: tool names in ListTools handlers
-    /['"]name['"]\s*:\s*['"]([a-z_][a-z0-9_]*)['"]/gi,
+    // JS/TS MCP SDK: server.tool('name', ...) or .setTool('name', ...)
+    /\.tool\s*\(\s*['"]([a-z_][a-z0-9_]*)['"]/gi,
+    // Python: @mcp.tool() / @server.tool() followed by def name
+    /@(?:mcp|server)\.tool\s*\(.*?\)[\s\S]*?def\s+([a-z_][a-z0-9_]*)/gi,
+    // Python: Tool(name="xxx")
+    /Tool\s*\(\s*name\s*=\s*['"]([a-z_][a-z0-9_]*)['"]/gi,
+    // ListTools handler: { name: "tool_name", description: ... }
+    /{\s*(?:['"]?)name(?:['"]?)\s*:\s*['"]([a-z_][a-z0-9_]*)['"]\s*,\s*(?:['"]?)description(?:['"]?)\s*:/gi,
   ];
-  
+
+  const toolBlacklist = new Set(['type', 'name', 'string', 'object', 'number', 'boolean', 'array', 'required', 'description', 'default', 'null', 'true', 'false', 'none', 'test', 'self', 'args', 'kwargs', 'input', 'output', 'result', 'data', 'error', 'value', 'index', 'item', 'list', 'dict', 'set', 'map', 'key', 'url', 'env', 'config', 'options']);
+
   const toolSet = new Set();
-  for (const file of files) {
+  for (const file of mcpFiles) {
     for (const pattern of toolPatterns) {
       pattern.lastIndex = 0;
       let m;
       while ((m = pattern.exec(file.content)) !== null) {
         const name = m[1] || m[2];
-        if (name && name.length > 2 && name.length < 50 && !['type', 'name', 'string', 'object', 'number', 'boolean', 'array', 'required', 'description', 'default', 'null', 'true', 'false', 'none'].includes(name)) {
+        if (name && name.length > 2 && name.length < 50 && !toolBlacklist.has(name)) {
           toolSet.add(name);
         }
       }
@@ -1566,6 +1643,235 @@ function findMcpConfigs() {
   return found;
 }
 
+// ── Skill Discovery & Validation ─────────────────────────
+
+/**
+ * Parse YAML frontmatter from a SKILL.md file.
+ * Returns { meta: {...}, body: string, errors: string[] }
+ */
+function parseSkillFrontmatter(content) {
+  const errors = [];
+  const lines = content.split('\n');
+
+  // Must start with ---
+  if (lines[0].trim() !== '---') {
+    return { meta: null, body: content, errors: ['Missing YAML frontmatter (file must start with ---)'] };
+  }
+
+  // Find closing ---
+  let endIdx = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') { endIdx = i; break; }
+  }
+  if (endIdx === -1) {
+    return { meta: null, body: content, errors: ['Unclosed frontmatter (missing closing ---)'] };
+  }
+
+  // Parse YAML-like key: value pairs
+  const meta = {};
+  const yamlLines = lines.slice(1, endIdx);
+  for (let i = 0; i < yamlLines.length; i++) {
+    const line = yamlLines[i];
+    if (line.trim() === '' || line.trim().startsWith('#')) continue;
+
+    // Check for tabs
+    if (line.includes('\t')) {
+      errors.push(`Line ${i + 2}: Tab character found (use spaces)`);
+    }
+
+    const match = line.match(/^([a-z][a-z0-9_-]*):\s*(.*)/i);
+    if (!match) {
+      // Could be a continuation line (YAML multiline)
+      continue;
+    }
+    const key = match[1].toLowerCase();
+    let value = match[2].trim();
+
+    // Handle YAML lists on next lines
+    if (value === '' && i + 1 < yamlLines.length && yamlLines[i + 1].match(/^\s+-\s/)) {
+      const items = [];
+      let j = i + 1;
+      while (j < yamlLines.length && yamlLines[j].match(/^\s+-\s/)) {
+        items.push(yamlLines[j].replace(/^\s+-\s*/, '').trim());
+        j++;
+      }
+      value = items;
+    }
+
+    // Strip surrounding quotes
+    if (typeof value === 'string' && ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))) {
+      value = value.slice(1, -1);
+    }
+
+    meta[key] = value;
+  }
+
+  const body = lines.slice(endIdx + 1).join('\n').trim();
+  return { meta, body, errors };
+}
+
+/**
+ * Validate a parsed skill against the Claude Code SKILL.md spec.
+ * Returns { errors: [...], warnings: [...], info: {...} }
+ */
+function validateSkill(parsed) {
+  const { meta, body, errors: parseErrors } = parsed;
+  const errors = [...parseErrors];
+  const warnings = [];
+  const info = {};
+
+  if (!meta) return { errors, warnings, info };
+
+  // Known fields
+  const knownFields = new Set([
+    'name', 'description', 'allowed-tools', 'user-invocable', 'user-invokable',
+    'disable-model-invocation', 'license', 'metadata', 'argument-hint',
+    'compatibility', 'version', 'author',
+  ]);
+
+  // Check for unknown fields
+  for (const key of Object.keys(meta)) {
+    if (!knownFields.has(key)) {
+      warnings.push(`Unknown frontmatter field: "${key}"`);
+    }
+  }
+
+  // Required: name
+  if (!meta.name) {
+    errors.push('Missing required field: name');
+  } else {
+    info.name = meta.name;
+    if (meta.name.length > 64) errors.push(`name exceeds 64 chars (${meta.name.length})`);
+    if (/<[^>]+>/.test(meta.name)) errors.push('name contains XML/HTML tags');
+  }
+
+  // Required: description
+  if (!meta.description) {
+    errors.push('Missing required field: description');
+  } else {
+    info.description = typeof meta.description === 'string' ? meta.description.slice(0, 120) : String(meta.description).slice(0, 120);
+    if (typeof meta.description === 'string' && meta.description.length > 1024) {
+      warnings.push(`description is ${meta.description.length} chars (recommended max: 1024)`);
+    }
+    if (/<[^>]+>/.test(meta.description)) warnings.push('description contains XML/HTML tags');
+  }
+
+  // Security: allowed-tools
+  if (!meta['allowed-tools']) {
+    warnings.push('No allowed-tools set — skill has access to ALL tools (security risk)');
+    info.allowedTools = null;
+  } else {
+    const tools = typeof meta['allowed-tools'] === 'string'
+      ? meta['allowed-tools'].split(',').map(t => t.trim()).filter(Boolean)
+      : Array.isArray(meta['allowed-tools']) ? meta['allowed-tools'] : [];
+    info.allowedTools = tools;
+    // Check for wildcard/dangerous patterns
+    if (tools.some(t => t === '*' || t === 'Bash' || t === 'Bash(*)')) {
+      warnings.push('allowed-tools includes unrestricted Bash access');
+    }
+  }
+
+  // Boolean fields
+  for (const boolField of ['user-invocable', 'user-invokable', 'disable-model-invocation']) {
+    if (meta[boolField] !== undefined) {
+      const val = String(meta[boolField]).toLowerCase();
+      if (!['true', 'false'].includes(val)) {
+        errors.push(`${boolField} must be true or false (got: "${meta[boolField]}")`);
+      }
+    }
+  }
+
+  // Typo detection
+  if (meta['user-invokable'] && !meta['user-invocable']) {
+    warnings.push('Using "user-invokable" (known typo variant) — both spellings work');
+  }
+
+  // Body checks
+  if (body) {
+    const bodyLines = body.split('\n').length;
+    info.bodyLines = bodyLines;
+    if (bodyLines > 500) warnings.push(`Body is ${bodyLines} lines (recommended max: 500)`);
+
+    // Check for potential prompt injection patterns in body
+    const injectionPatterns = [
+      { pattern: /ignore\s+(all\s+)?previous\s+(instructions|rules)/i, label: 'Prompt injection pattern' },
+      { pattern: /<IMPORTANT>/i, label: 'Suspicious <IMPORTANT> tag' },
+      { pattern: /system\s*:\s*you\s+are/i, label: 'System prompt override attempt' },
+    ];
+    for (const { pattern, label } of injectionPatterns) {
+      if (pattern.test(body)) {
+        warnings.push(`${label} detected in body`);
+      }
+    }
+  }
+
+  // Extract MCP tool references
+  const mcpRefs = [];
+  const mcpPattern = /mcp__([a-z0-9_-]+)__([a-z0-9_]+)/gi;
+  const fullText = (meta.description || '') + ' ' + (typeof meta['allowed-tools'] === 'string' ? meta['allowed-tools'] : '') + ' ' + (body || '');
+  let mcpMatch;
+  while ((mcpMatch = mcpPattern.exec(fullText)) !== null) {
+    mcpRefs.push({ server: mcpMatch[1], tool: mcpMatch[2] });
+  }
+  info.mcpRefs = mcpRefs;
+
+  // Deduplicate MCP server names
+  info.mcpServers = [...new Set(mcpRefs.map(r => r.server))];
+
+  return { errors, warnings, info };
+}
+
+/**
+ * Find all SKILL.md files in known skill directories.
+ */
+function findSkills() {
+  const home = process.env.HOME || process.env.USERPROFILE || '';
+  const cwd = process.cwd();
+  const found = [];
+
+  const skillDirs = [
+    // Global skill dirs
+    { name: 'Claude Code (global)', base: path.join(home, '.claude', 'skills') },
+    { name: 'Cursor (global)', base: path.join(home, '.cursor', 'skills') },
+    { name: 'Antigravity (global)', base: path.join(home, '.agent', 'skills') },
+    // Project-level skill dirs
+    { name: 'Claude Code (project)', base: path.join(cwd, '.claude', 'skills') },
+    { name: 'Cursor (project)', base: path.join(cwd, '.cursor', 'skills') },
+    { name: 'GitHub Skills (project)', base: path.join(cwd, '.github', 'skills') },
+    { name: 'Antigravity (project)', base: path.join(cwd, '.agent', 'skills') },
+  ];
+
+  for (const dir of skillDirs) {
+    if (!fs.existsSync(dir.base)) continue;
+    try {
+      const entries = fs.readdirSync(dir.base, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+        const skillPath = path.join(dir.base, entry.name, 'SKILL.md');
+        if (!fs.existsSync(skillPath)) continue;
+        try {
+          const content = fs.readFileSync(skillPath, 'utf8');
+          const parsed = parseSkillFrontmatter(content);
+          const validation = validateSkill(parsed);
+          found.push({
+            source: dir.name,
+            dir: path.join(dir.base, entry.name),
+            path: skillPath,
+            dirName: entry.name,
+            parsed,
+            validation,
+            isSymlink: entry.isSymbolicLink(),
+          });
+        } catch {}
+      }
+    } catch {}
+  }
+
+  return found;
+}
+
+// ── Server Config Extraction ─────────────────────────────
+
 function extractServersFromConfig(config) {
   // Handle both { mcpServers: {...} } and { servers: {...} } formats
   const servers = config.mcpServers || config.servers || {};
@@ -1627,7 +1933,10 @@ function extractServersFromConfig(config) {
         }
       } catch {}
     }
-    
+
+    // Resolve local installation directory
+    info.localDir = resolveLocalDir(info);
+
     result.push(info);
   }
   return result;
@@ -1640,6 +1949,196 @@ function serverSlug(server) {
   return server.name.toLowerCase().replace(/[^a-z0-9-]/gi, '-');
 }
 
+/**
+ * Resolve the local installation directory for a discovered MCP server.
+ * Returns an absolute path or null if not found.
+ */
+function resolveLocalDir(server) {
+  const home = os.homedir();
+  const isWin = process.platform === 'win32';
+
+  // node /path/to/file → walk up to project root (package.json or .git)
+  const allArgs = [server.command, ...server.args].filter(Boolean).join(' ');
+  const nodePathMatch = allArgs.match(/node\s+["']?([^"'\s]+)/);
+  if (nodePathMatch) {
+    let dir = path.dirname(path.resolve(nodePathMatch[1]));
+    for (let i = 0; i < 5; i++) {
+      if (fs.existsSync(path.join(dir, 'package.json')) || fs.existsSync(path.join(dir, '.git'))) return dir;
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    // Fallback: use the script's directory
+    return path.dirname(path.resolve(nodePathMatch[1]));
+  }
+
+  // python /path/to/file → same approach
+  const pyPathMatch = allArgs.match(/python[3]?\s+["']?([^"'\s]+\.py)/);
+  if (pyPathMatch) {
+    let dir = path.dirname(path.resolve(pyPathMatch[1]));
+    for (let i = 0; i < 5; i++) {
+      if (fs.existsSync(path.join(dir, 'pyproject.toml')) || fs.existsSync(path.join(dir, 'setup.py')) || fs.existsSync(path.join(dir, '.git'))) return dir;
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return path.dirname(path.resolve(pyPathMatch[1]));
+  }
+
+  // npm/npx package → check global node_modules
+  if (server.npmPackage) {
+    const pkgName = server.npmPackage.replace(/@latest$/, '').replace(/@[\d.]+$/, '');
+    const candidates = [];
+    // Global npm
+    try {
+      const globalRoot = execFileSync('npm', ['root', '-g'], { timeout: 5000, stdio: 'pipe' }).toString().trim();
+      candidates.push(path.join(globalRoot, pkgName));
+    } catch {}
+    // Local node_modules (cwd)
+    candidates.push(path.join(process.cwd(), 'node_modules', pkgName));
+    for (const dir of candidates) {
+      if (fs.existsSync(dir)) return dir;
+    }
+  }
+
+  // uvx/pip package → check uv tools cache and site-packages
+  if (server.pyPackage) {
+    const pkgName = server.pyPackage.replace(/@latest$/, '').replace(/@[\d.]+$/, '');
+    const candidates = [];
+    if (isWin) {
+      const localAppData = process.env.LOCALAPPDATA || path.join(home, 'AppData', 'Local');
+      candidates.push(path.join(localAppData, 'uv', 'tools', pkgName));
+    } else {
+      candidates.push(path.join(home, '.local', 'share', 'uv', 'tools', pkgName));
+    }
+    // Also try pip show
+    try {
+      const pipOut = execFileSync('pip', ['show', pkgName, '-f'], { timeout: 5000, stdio: 'pipe' }).toString();
+      const locMatch = pipOut.match(/Location:\s*(.+)/);
+      if (locMatch) {
+        const normalized = pkgName.replace(/-/g, '_');
+        const pkgDir = path.join(locMatch[1].trim(), normalized);
+        if (fs.existsSync(pkgDir)) candidates.push(pkgDir);
+      }
+    } catch {}
+    for (const dir of candidates) {
+      if (fs.existsSync(dir)) return dir;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Scan a local directory (like scanRepo but without cloning).
+ */
+async function scanLocalDir(localDir, serverName) {
+  const start = Date.now();
+  const slug = serverName.toLowerCase().replace(/[^a-z0-9-]/gi, '-');
+
+  if (!jsonMode) process.stdout.write(`${icons.scan}  Scanning ${c.bold}${slug}${c.reset} ${c.dim}(local)${c.reset} ${c.dim}...${c.reset}`);
+
+  // Collect files from local dir
+  const files = collectFiles(localDir);
+  if (files.length === 0) {
+    if (!jsonMode) process.stdout.write(`  ${c.yellow}no scannable files found${c.reset}\n`);
+    return null;
+  }
+
+  // Detect info
+  const info = detectPackageInfo(localDir, files);
+
+  // Quick checks
+  const findings = quickChecks(files);
+
+  // Registry lookup
+  const registryData = await checkRegistry(slug);
+
+  const duration = elapsed(start);
+
+  if (!jsonMode) {
+    process.stdout.write('\r\x1b[K');
+    printScanResult(`local://${localDir}`, info, files, findings, registryData, duration);
+  }
+
+  return { slug, url: `local://${localDir}`, info, files: files.length, findings, registryData, duration };
+}
+
+/**
+ * Download package source from PyPI or npm to a temp dir and scan it.
+ * Used as last resort when git clone fails and no local install exists.
+ */
+async function downloadAndScan(server) {
+  const start = Date.now();
+  const slug = server.name.toLowerCase().replace(/[^a-z0-9-]/gi, '-');
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agentaudit-pkg-'));
+
+  try {
+    if (server.pyPackage) {
+      const pkgName = server.pyPackage.replace(/@latest$/, '').replace(/@[\d.]+$/, '');
+      if (!jsonMode) process.stdout.write(`${icons.scan}  Downloading ${c.bold}${pkgName}${c.reset} ${c.dim}from PyPI...${c.reset}`);
+      // Download sdist/wheel without installing
+      execFileSync('pip', ['download', '--no-deps', '-d', tmpDir, pkgName], { timeout: 30000, stdio: 'pipe' });
+      // Extract any .tar.gz or .whl (zip) files
+      const downloaded = fs.readdirSync(tmpDir);
+      const extractDir = path.join(tmpDir, 'src');
+      fs.mkdirSync(extractDir, { recursive: true });
+      for (const f of downloaded) {
+        const fp = path.join(tmpDir, f);
+        if (f.endsWith('.whl') || f.endsWith('.zip')) {
+          execFileSync('python', ['-m', 'zipfile', '-e', fp, extractDir], { timeout: 10000, stdio: 'pipe' });
+        } else if (f.endsWith('.tar.gz') || f.endsWith('.tgz')) {
+          execFileSync('tar', ['xzf', fp, '-C', extractDir], { timeout: 10000, stdio: 'pipe' });
+        }
+      }
+      const files = collectFiles(extractDir);
+      if (files.length === 0) return null;
+      const info = detectPackageInfo(extractDir, files);
+      const findings = quickChecks(files);
+      const registryData = await checkRegistry(slug);
+      const duration = elapsed(start);
+      if (!jsonMode) {
+        process.stdout.write('\r\x1b[K');
+        printScanResult(`pypi://${pkgName}`, info, files, findings, registryData, duration);
+      }
+      return { slug, url: `pypi://${pkgName}`, info, files: files.length, findings, registryData, duration };
+    }
+
+    if (server.npmPackage) {
+      const pkgName = server.npmPackage.replace(/@latest$/, '').replace(/@[\d.]+$/, '');
+      if (!jsonMode) process.stdout.write(`${icons.scan}  Downloading ${c.bold}${pkgName}${c.reset} ${c.dim}from npm...${c.reset}`);
+      // npm pack downloads tarball without installing
+      execFileSync('npm', ['pack', pkgName, '--pack-destination', tmpDir], { timeout: 30000, stdio: 'pipe' });
+      const tarballs = fs.readdirSync(tmpDir).filter(f => f.endsWith('.tgz'));
+      if (tarballs.length === 0) return null;
+      const extractDir = path.join(tmpDir, 'src');
+      fs.mkdirSync(extractDir, { recursive: true });
+      execFileSync('tar', ['xzf', path.join(tmpDir, tarballs[0]), '-C', extractDir], { timeout: 10000, stdio: 'pipe' });
+      const files = collectFiles(extractDir);
+      if (files.length === 0) return null;
+      const info = detectPackageInfo(extractDir, files);
+      const findings = quickChecks(files);
+      const registryData = await checkRegistry(slug);
+      const duration = elapsed(start);
+      if (!jsonMode) {
+        process.stdout.write('\r\x1b[K');
+        printScanResult(`npm://${pkgName}`, info, files, findings, registryData, duration);
+      }
+      return { slug, url: `npm://${pkgName}`, info, files: files.length, findings, registryData, duration };
+    }
+  } catch (err) {
+    if (!jsonMode) {
+      process.stdout.write('\r\x1b[K');
+      process.stdout.write(`${icons.scan}  ${c.bold}${slug}${c.reset}  ${c.yellow}download failed${c.reset}\n`);
+      const msg = err.stderr?.toString().trim().split('\n')[0] || err.message?.split('\n')[0] || '';
+      if (msg) console.log(`    ${c.dim}${msg}${c.reset}`);
+    }
+  } finally {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  }
+  return null;
+}
+
 async function searchGitHub(query) {
   try {
     const res = await fetch(`https://api.github.com/search/repositories?q=${encodeURIComponent(query)}&per_page=1`, {
@@ -1822,14 +2321,17 @@ async function discoverCommand(options = {}) {
         const hasOfficial = regData.has_official_audit;
         console.log(`${branch}  ${c.bold}${server.name}${c.reset}    ${sourceLabel}`);
         console.log(`${pipe}  ${riskBadge(riskScore)}  ${hasOfficial ? `${c.green}✔ official${c.reset}  ` : ''}${c.dim}${REGISTRY_URL}/packages/${slug}${c.reset}`);
-        if (resolvedUrl) allServersWithUrls.push({ name: server.name, sourceUrl: resolvedUrl, hasAudit: true, regData });
+        if (resolvedUrl || server.localDir || server.pyPackage || server.npmPackage) allServersWithUrls.push({ name: server.name, sourceUrl: resolvedUrl, localDir: server.localDir, pyPackage: server.pyPackage, npmPackage: server.npmPackage, hasAudit: true, regData });
       } else {
         unauditedServers++;
         console.log(`${branch}  ${c.bold}${server.name}${c.reset}    ${sourceLabel}`);
         if (resolvedUrl) {
           console.log(`${pipe}  ${c.yellow}⚠ not audited${c.reset}  ${c.dim}Run: ${c.cyan}agentaudit audit ${resolvedUrl}${c.reset}`);
           unauditedWithUrls.push({ name: server.name, sourceUrl: resolvedUrl });
-          allServersWithUrls.push({ name: server.name, sourceUrl: resolvedUrl, hasAudit: false });
+          allServersWithUrls.push({ name: server.name, sourceUrl: resolvedUrl, localDir: server.localDir, pyPackage: server.pyPackage, npmPackage: server.npmPackage, hasAudit: false });
+        } else if (server.localDir || server.pyPackage || server.npmPackage) {
+          console.log(`${pipe}  ${c.yellow}⚠ not audited${c.reset}  ${c.dim}${server.localDir ? 'local install found' : 'package registry available'} — will scan${c.reset}`);
+          allServersWithUrls.push({ name: server.name, sourceUrl: null, localDir: server.localDir, pyPackage: server.pyPackage, npmPackage: server.npmPackage, hasAudit: false });
         } else {
           console.log(`${pipe}  ${c.yellow}⚠ not audited${c.reset}  ${c.dim}Source URL unknown — check the package's GitHub/npm page${c.reset}`);
         }
@@ -1854,29 +2356,115 @@ async function discoverCommand(options = {}) {
   }
   console.log();
   
-  // --scan: automatically scan all servers with resolved source URLs (git-cloneable only)
+  // ── Skill Discovery ──────────────────────────────────
+  const skills = findSkills();
+  if (skills.length > 0) {
+    console.log(sectionHeader(`Skills — ${skills.length} found`));
+    console.log();
+
+    // Group by source
+    const bySource = {};
+    for (const skill of skills) {
+      (bySource[skill.source] || (bySource[skill.source] = [])).push(skill);
+    }
+
+    for (const [source, sourceSkills] of Object.entries(bySource)) {
+      console.log(`${icons.bullet}  ${c.bold}${source}${c.reset}`);
+      console.log();
+
+      for (let i = 0; i < sourceSkills.length; i++) {
+        const skill = sourceSkills[i];
+        const isLast = i === sourceSkills.length - 1;
+        const branch = isLast ? icons.treeLast : icons.tree;
+        const pipe = isLast ? '   ' : `${icons.pipe}  `;
+        const { errors, warnings, info } = skill.validation;
+        const name = info.name || skill.dirName;
+        const hasErrors = errors.length > 0;
+        const hasWarnings = warnings.length > 0;
+
+        // Status indicator
+        let status;
+        if (hasErrors) status = `${c.red}✖ ${errors.length} error${errors.length !== 1 ? 's' : ''}${c.reset}`;
+        else if (hasWarnings) status = `${c.yellow}⚠ ${warnings.length} warning${warnings.length !== 1 ? 's' : ''}${c.reset}`;
+        else status = `${c.green}✔ valid${c.reset}`;
+
+        console.log(`${branch}  ${c.bold}${name}${c.reset}    ${status}`);
+
+        // Description (truncated)
+        if (info.description) {
+          const desc = info.description.length > 70 ? info.description.slice(0, 67) + '...' : info.description;
+          console.log(`${pipe}  ${c.dim}${desc}${c.reset}`);
+        }
+
+        // MCP tool references
+        if (info.mcpServers && info.mcpServers.length > 0) {
+          const serverList = info.mcpServers.map(s => `${c.cyan}${s}${c.reset}`).join(', ');
+          console.log(`${pipe}  ${c.dim}uses MCP:${c.reset} ${serverList}`);
+        }
+
+        // Allowed tools summary
+        if (info.allowedTools === null) {
+          console.log(`${pipe}  ${c.yellow}⚠ no allowed-tools — unrestricted access${c.reset}`);
+        } else if (info.allowedTools && info.allowedTools.length > 0) {
+          const toolCount = info.allowedTools.length;
+          console.log(`${pipe}  ${c.dim}${toolCount} allowed tool${toolCount !== 1 ? 's' : ''}${c.reset}`);
+        }
+
+        // Show errors/warnings inline
+        if (hasErrors) {
+          for (const err of errors.slice(0, 3)) {
+            console.log(`${pipe}  ${c.red}  ✖ ${err}${c.reset}`);
+          }
+        }
+        if (hasWarnings && !hasErrors) {
+          for (const warn of warnings.slice(0, 2)) {
+            console.log(`${pipe}  ${c.yellow}  ⚠ ${warn}${c.reset}`);
+          }
+        }
+      }
+      console.log();
+    }
+  }
+
+  // --scan: automatically scan all servers (git clone + local fallback)
   if (autoScan) {
     const isCloneable = (url) => /^https?:\/\/(github\.com|gitlab\.com|bitbucket\.org)\//i.test(url);
-    const scanTargets = allServersWithUrls.filter(s => s.sourceUrl && isCloneable(s.sourceUrl));
-    // Deduplicate by sourceUrl
+    // Include servers that are cloneable OR have a local dir OR a known package
+    const scanTargets = allServersWithUrls.filter(s =>
+      (s.sourceUrl && isCloneable(s.sourceUrl)) || s.localDir || s.pyPackage || s.npmPackage
+    );
+    // Deduplicate by sourceUrl or localDir
     const seen = new Set();
     const dedupedTargets = scanTargets.filter(s => {
-      if (seen.has(s.sourceUrl)) return false;
-      seen.add(s.sourceUrl);
+      const key = (s.sourceUrl && isCloneable(s.sourceUrl)) ? s.sourceUrl : s.localDir;
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
       return true;
     });
-    const skipped = allServersWithUrls.filter(s => s.sourceUrl && !isCloneable(s.sourceUrl));
+    const skippedCount = allServersWithUrls.length - scanTargets.length;
     if (dedupedTargets.length > 0) {
       console.log(sectionHeader(`Auto-scanning ${dedupedTargets.length} server${dedupedTargets.length !== 1 ? 's' : ''}`));
       console.log(`  ${c.bold}${icons.scan}  Starting scans...${c.reset}`);
-      if (skipped.length > 0) {
-        console.log(`  ${c.dim}(${skipped.length} skipped — no cloneable source URL)${c.reset}`);
+      if (skippedCount > 0) {
+        console.log(`  ${c.dim}(${skippedCount} skipped — remote-only, no local source)${c.reset}`);
       }
       console.log();
-      
+
       const scanResults = [];
       for (const target of dedupedTargets) {
-        const result = await scanRepo(target.sourceUrl);
+        let result = null;
+        // Try git clone first if URL is cloneable
+        if (target.sourceUrl && isCloneable(target.sourceUrl)) {
+          result = await scanRepo(target.sourceUrl);
+        }
+        // Fallback 1: scan local installation
+        if (!result && target.localDir) {
+          result = await scanLocalDir(target.localDir, target.name);
+        }
+        // Fallback 2: download from PyPI/npm and scan
+        if (!result && (target.pyPackage || target.npmPackage)) {
+          result = await downloadAndScan(target);
+        }
         if (result) scanResults.push({ ...result, serverName: target.name });
       }
       
@@ -1969,7 +2557,7 @@ async function discoverCommand(options = {}) {
   }
   
   if (!autoScan && !interactiveAudit && !jsonMode) {
-    console.log(`  ${c.dim}Looking for general package scanning? Try ${c.cyan}pip audit${c.dim} or ${c.cyan}npm audit${c.dim}.${c.reset}`);
+    console.log(`  ${c.dim}Run ${c.cyan}agentaudit discover --quick${c.dim} to auto-scan all servers${c.reset}`);
     console.log();
   }
 }
@@ -1982,6 +2570,91 @@ function loadAuditPrompt() {
   return null;
 }
 
+async function callLlm(llmConfig, systemPrompt, userMessage) {
+  const apiKey = process.env[llmConfig.key];
+  if (!apiKey) return { error: `Missing API key: ${llmConfig.key}` };
+  const start = Date.now();
+  let _text = '';
+  try {
+    let data;
+    if (llmConfig.type === 'anthropic') {
+      const res = await fetch(llmConfig.url, {
+        method: 'POST',
+        headers: { 'x-api-key': apiKey, 'anthropic-version': '2023-06-01', 'content-type': 'application/json' },
+        body: JSON.stringify({ model: llmConfig.model, max_tokens: 8192, system: systemPrompt, messages: [{ role: 'user', content: userMessage }] }),
+        signal: AbortSignal.timeout(120_000),
+      });
+      data = await res.json();
+      if (data.error) {
+        const friendly = formatApiError(data.error, llmConfig.provider, res.status);
+        return { error: friendly?.text || data.error.message || JSON.stringify(data.error), hint: friendly?.hint, duration: Date.now() - start };
+      }
+      _text = data.content?.[0]?.text || '';
+      const report = extractJSON(_text);
+      if (report) {
+        report.audit_model = data.model || llmConfig.model;
+        report.audit_provider = llmConfig.provider;
+        if (data.id) report.provider_msg_id = data.id;
+        if (data.usage) { report.input_tokens = data.usage.input_tokens; report.output_tokens = data.usage.output_tokens; }
+      }
+      return { report, text: _text, duration: Date.now() - start };
+    } else if (llmConfig.type === 'gemini') {
+      const res = await fetch(`${llmConfig.url}/${llmConfig.model}:generateContent?key=${apiKey}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          systemInstruction: { parts: [{ text: systemPrompt }] },
+          contents: [{ role: 'user', parts: [{ text: userMessage }] }],
+          generationConfig: { maxOutputTokens: 8192 },
+        }),
+        signal: AbortSignal.timeout(120_000),
+      });
+      data = await res.json();
+      if (data.error) {
+        const friendly = formatApiError(data.error, llmConfig.provider, res.status);
+        return { error: friendly?.text || data.error.message || JSON.stringify(data.error), hint: friendly?.hint, duration: Date.now() - start };
+      }
+      _text = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+      const report = extractJSON(_text);
+      if (report) {
+        report.audit_model = data.modelVersion || llmConfig.model;
+        report.audit_provider = llmConfig.provider;
+        if (data.usageMetadata) { report.input_tokens = data.usageMetadata.promptTokenCount; report.output_tokens = data.usageMetadata.candidatesTokenCount; }
+      }
+      return { report, text: _text, duration: Date.now() - start };
+    } else {
+      const headers = { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' };
+      if (llmConfig.provider === 'openrouter') { headers['HTTP-Referer'] = 'https://agentaudit.dev'; headers['X-Title'] = 'AgentAudit CLI'; }
+      const res = await fetch(llmConfig.url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ model: llmConfig.model, max_tokens: 8192, messages: [{ role: 'system', content: systemPrompt }, { role: 'user', content: userMessage }] }),
+        signal: AbortSignal.timeout(120_000),
+      });
+      data = await res.json();
+      if (data.error) {
+        const friendly = formatApiError(data.error, llmConfig.provider, res.status);
+        return { error: friendly?.text || data.error.message || JSON.stringify(data.error), hint: friendly?.hint, duration: Date.now() - start };
+      }
+      _text = data.choices?.[0]?.message?.content || '';
+      const report = extractJSON(_text);
+      if (report) {
+        report.audit_model = data.model || llmConfig.model;
+        report.audit_provider = llmConfig.provider;
+        if (data.id) report.provider_msg_id = data.id;
+        if (data.system_fingerprint) report.provider_fingerprint = data.system_fingerprint;
+        if (data.usage) { report.input_tokens = data.usage.prompt_tokens; report.output_tokens = data.usage.completion_tokens; }
+      }
+      return { report, text: _text, duration: Date.now() - start };
+    }
+  } catch (err) {
+    const dur = Date.now() - start;
+    if (err.name === 'TimeoutError' || err.message?.includes('timeout')) return { error: 'Request timed out (120s)', hint: 'Try again or use a faster model', duration: dur };
+    if (err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED' || err.message?.includes('fetch failed')) return { error: `Network error: could not reach ${llmConfig.provider}`, hint: 'Check your internet connection', duration: dur };
+    return { error: err.message, duration: dur };
+  }
+}
+
 async function auditRepo(url) {
   const start = Date.now();
   const slug = slugFromUrl(url);
@@ -2020,72 +2693,24 @@ async function auditRepo(url) {
   }
   console.log(` ${c.green}done${c.reset}`);
   
-  // Step 4: LLM Analysis
-  // Resolve provider: preferred_provider from config → first match fallback
-  const activeLlm = resolveProvider();
-  const llmApiKey = activeLlm ? process.env[activeLlm.key] : null;
-  const activeProvider = activeLlm ? activeLlm.name : null;
-
-  // Model override: --model flag > AGENTAUDIT_MODEL env > credentials.json > provider default
-  const modelArgIdx = process.argv.indexOf('--model');
-  const modelFlag = modelArgIdx !== -1 ? process.argv[modelArgIdx + 1] : null;
-  const modelEnv = process.env.AGENTAUDIT_MODEL;
-  const modelConfig = loadLlmConfig()?.llm_model;
-  const modelOverride = modelFlag || modelEnv || modelConfig || null;
-  if (activeLlm && modelOverride) {
-    activeLlm.model = modelOverride;
-  }
-  
-  if (!activeLlm) {
-    // No LLM API key — compact explanation
-    console.log();
-    console.log(`  ${c.yellow}No LLM API key found.${c.reset} The ${c.bold}audit${c.reset} command needs an LLM to analyze code.`);
-    console.log();
-    console.log(`  ${c.bold}Set an API key${c.reset} (e.g. ${c.cyan}export OPENROUTER_API_KEY=sk-or-...${c.reset})`);
-    console.log(`  ${c.dim}Run "agentaudit model" to configure provider + model interactively${c.reset}`);
-    console.log();
-    console.log(`  ${c.bold}Or export for manual review:${c.reset} ${c.cyan}agentaudit audit ${url} --export${c.reset}`);
-    console.log(`  ${c.bold}Or use as MCP server${c.reset} in Cursor/Claude ${c.dim}(no extra API key needed)${c.reset}`);
-    console.log(`  ${c.dim}{ "agentaudit": { "command": "npx", "args": ["-y", "agentaudit"] } }${c.reset}`);
-    console.log();
-    
-    // Check if --export flag
-    if (process.argv.includes('--export')) {
-      const exportPath = path.join(process.cwd(), `audit-${slug}.md`);
-      const exportContent = [
-        `# Security Audit: ${slug}`,
-        `**Source:** ${url}`,
-        `**Files:** ${files.length}`,
-        ``,
-        `## Audit Instructions`,
-        ``,
-        auditPrompt || '(audit prompt not found)',
-        ``,
-        `## Report Format`,
-        ``,
-        `After analysis, produce a JSON report:`,
-        '```json',
-        `{ "skill_slug": "${slug}", "source_url": "${url}", "risk_score": 0, "result": "safe", "findings": [] }`,
-        '```',
-        ``,
-        `## Source Code`,
-        ``,
-        codeBlock,
-      ].join('\n');
-      fs.writeFileSync(exportPath, exportContent);
-      console.log(`  ${icons.safe}  Exported to ${c.bold}${exportPath}${c.reset}`);
-      console.log(`  ${c.dim}Paste this into any LLM (Claude, ChatGPT, etc.) for analysis${c.reset}`);
-    }
-    
-    // Cleanup
-    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
-    return null;
-  }
-  
-  // We have an API key — run LLM audit
-  const modelLabel = modelOverride ? `${activeProvider} → ${activeLlm.model}` : activeProvider;
-  process.stdout.write(`  ${stepProgress(4, 4)} Running LLM analysis ${c.dim}(${modelLabel})${c.reset}...`);
+  // Step 4: Provenance + type detection (needs repoPath on disk)
+  let commitSha = '';
+  try { commitSha = execSync('git rev-parse HEAD', { cwd: repoPath, encoding: 'utf8' }).trim(); } catch {}
+  const sourceHash = crypto.createHash('sha256').update(
+    files.slice().sort((a, b) => a.path.localeCompare(b.path))
+      .map(f => f.path + '\n' + f.content).join('\n')
+  ).digest('hex');
+  const pkgInfo = detectPackageInfo(repoPath, files);
+  const KNOWN_MCP_LIBS = new Set(['fastmcp', 'jlowin-fastmcp', 'mcp-go', 'fastapi-mcp', 'fastapi_mcp', 'mcp-use', 'mcp-agent']);
+  const KNOWN_CLI = new Set(['mcp-cli', 'mcp-scan', 'inspector']);
+  let detectedType = pkgInfo.type === 'unknown' ? 'other' : pkgInfo.type;
+  if (KNOWN_MCP_LIBS.has(slug)) detectedType = 'library';
+  if (KNOWN_CLI.has(slug)) detectedType = 'cli-tool';
 
+  // Cleanup repo (files in memory, provenance captured)
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+
+  // Build prompts
   const systemPrompt = auditPrompt || 'You are a security auditor. Analyze the code and report findings as JSON.';
   const userMessage = [
     `Audit this package: **${slug}** (${url})`,
@@ -2101,205 +2726,278 @@ async function auditRepo(url) {
     codeBlock,
   ].join('\n');
 
-  let report = null;
-  let _lastLlmText = '';
+  // Helper: add provenance to a report
+  const enrichReport = (report, duration) => {
+    report.skill_slug = slug;
+    report.package_type = detectedType;
+    report.audit_duration_ms = duration || (Date.now() - start);
+    report.files_scanned = files.length;
+    if (commitSha) report.commit_sha = commitSha;
+    report.source_hash = sourceHash;
+  };
 
-  try {
-    let data;
-    if (activeLlm.type === 'anthropic') {
-      // Anthropic Messages API (unique format)
-      const res = await fetch(activeLlm.url, {
+  // Helper: upload one report
+  const uploadReport = async (report, creds) => {
+    if (!creds) return;
+    process.stdout.write(`  Uploading report${report.audit_model ? ` (${report.audit_model})` : ''}...`);
+    try {
+      const res = await fetch(`${REGISTRY_URL}/api/reports`, {
         method: 'POST',
-        headers: {
-          'x-api-key': llmApiKey,
-          'anthropic-version': '2023-06-01',
-          'content-type': 'application/json',
-        },
-        body: JSON.stringify({
-          model: activeLlm.model,
-          max_tokens: 8192,
-          system: systemPrompt,
-          messages: [{ role: 'user', content: userMessage }],
-        }),
-        signal: AbortSignal.timeout(120_000),
+        headers: { 'Authorization': `Bearer ${creds.api_key}`, 'Content-Type': 'application/json' },
+        body: JSON.stringify(report),
+        signal: AbortSignal.timeout(15_000),
       });
-      data = await res.json();
-      if (data.error) {
-        console.log(` ${c.red}failed${c.reset}`);
-        const friendly = formatApiError(data.error, activeLlm.provider, res.status);
-        if (friendly) {
-          console.log(`  ${c.red}${friendly.text}${c.reset}`);
-          console.log(`  ${c.dim}${friendly.hint}${c.reset}`);
-        } else {
-          console.log(`  ${c.red}API error: ${data.error.message || JSON.stringify(data.error)}${c.reset}`);
-        }
-        try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
-        return null;
+      if (res.ok) {
+        console.log(` ${c.green}done${c.reset}`);
+      } else {
+        let errBody = ''; try { errBody = await res.text(); } catch {}
+        console.log(` ${c.yellow}failed (HTTP ${res.status})${c.reset}`);
+        if (errBody && process.argv.includes('--debug')) console.log(`  ${c.dim}Server: ${errBody.slice(0, 300)}${c.reset}`);
       }
-      _lastLlmText = data.content?.[0]?.text || '';
-      report = extractJSON(_lastLlmText);
-      if (report) {
-        report.audit_model = data.model || activeLlm.model;
-        report.audit_provider = activeLlm.provider;
-        if (data.id) report.provider_msg_id = data.id;
-        if (data.usage) {
-          report.input_tokens = data.usage.input_tokens;
-          report.output_tokens = data.usage.output_tokens;
-        }
+    } catch { console.log(` ${c.yellow}failed${c.reset}`); }
+  };
+
+  // Step 5: Resolve models
+  const modelsArgIdx = process.argv.indexOf('--models');
+  const modelsFlag = modelsArgIdx !== -1 ? process.argv[modelsArgIdx + 1] : null;
+  const modelNames = modelsFlag ? modelsFlag.split(',').map(m => m.trim()).filter(Boolean) : [];
+  const isMultiModel = modelNames.length > 1;
+
+  // ── Multi-Model Path ─────────────────────────────────────
+  if (isMultiModel) {
+    const resolvedModels = [];
+    const failedModels = [];
+    for (const name of modelNames) {
+      const config = resolveModel(name);
+      if (!config) { failedModels.push(name); continue; }
+      resolvedModels.push({ name, config });
+    }
+
+    if (resolvedModels.length === 0) {
+      console.log();
+      console.log(`  ${c.red}No API keys available for requested models${c.reset}`);
+      for (const name of failedModels) console.log(`    ${c.dim}${name}: no matching API key${c.reset}`);
+      console.log(`  ${c.dim}Run "agentaudit model" to configure providers${c.reset}`);
+      return null;
+    }
+
+    // Progress
+    const totalSteps = resolvedModels.length;
+    console.log(`  ${stepProgress(4, 4)} Running LLM analysis ${c.dim}(${totalSteps} models in parallel)${c.reset}`);
+    if (failedModels.length > 0) {
+      for (const name of failedModels) console.log(`    ${c.yellow}⚠${c.reset} ${name.padEnd(30)} ${c.dim}skipped (no API key)${c.reset}`);
+    }
+
+    // Parallel LLM calls
+    const results = await Promise.allSettled(
+      resolvedModels.map(async ({ name, config }) => {
+        const result = await callLlm(config, systemPrompt, userMessage);
+        return { name, ...result };
+      })
+    );
+
+    // Process results
+    const reports = [];
+    for (let i = 0; i < results.length; i++) {
+      const name = resolvedModels[i].name;
+      const r = results[i];
+      if (r.status === 'rejected') {
+        console.log(`    ${c.red}✗${c.reset} ${name.padEnd(30)} ${c.red}error${c.reset}`);
+        continue;
       }
-    } else if (activeLlm.type === 'gemini') {
-      // Google Gemini API (unique format)
-      const res = await fetch(`${activeLlm.url}/${activeLlm.model}:generateContent?key=${llmApiKey}`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-          systemInstruction: { parts: [{ text: systemPrompt }] },
-          contents: [{ role: 'user', parts: [{ text: userMessage }] }],
-          generationConfig: { maxOutputTokens: 8192 },
-        }),
-        signal: AbortSignal.timeout(120_000),
-      });
-      data = await res.json();
-      if (data.error) {
-        console.log(` ${c.red}failed${c.reset}`);
-        const friendly = formatApiError(data.error, activeLlm.provider, res.status);
-        if (friendly) {
-          console.log(`  ${c.red}${friendly.text}${c.reset}`);
-          console.log(`  ${c.dim}${friendly.hint}${c.reset}`);
-        } else {
-          console.log(`  ${c.red}API error: ${data.error.message || JSON.stringify(data.error)}${c.reset}`);
+      const { report, text, error, hint, duration } = r.value;
+      if (error) {
+        console.log(`    ${c.red}✗${c.reset} ${name.padEnd(30)} ${c.red}${error}${c.reset}`);
+        if (hint) console.log(`      ${c.dim}${hint}${c.reset}`);
+        continue;
+      }
+      if (!report) {
+        console.log(`    ${c.yellow}✗${c.reset} ${name.padEnd(30)} ${c.yellow}JSON parse failed${c.reset}`);
+        if (process.argv.includes('--debug') && text) {
+          console.log(`      ${c.dim}${text.slice(0, 200)}...${c.reset}`);
         }
-        try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
-        return null;
+        continue;
       }
-      _lastLlmText = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
-      report = extractJSON(_lastLlmText);
-      if (report) {
-        report.audit_model = data.modelVersion || activeLlm.model;
-        report.audit_provider = activeLlm.provider;
-        if (data.usageMetadata) {
-          report.input_tokens = data.usageMetadata.promptTokenCount;
-          report.output_tokens = data.usageMetadata.candidatesTokenCount;
+      const durSec = Math.round((duration || 0) / 1000);
+      console.log(`    ${c.green}✓${c.reset} ${name.padEnd(30)} ${c.green}done${c.reset} ${c.dim}(${durSec}s)${c.reset}`);
+      enrichReport(report, duration);
+      saveHistory(report);
+      reports.push({ name, report });
+    }
+
+    if (reports.length === 0) {
+      console.log();
+      console.log(`  ${c.red}No models returned valid results${c.reset}`);
+      return null;
+    }
+
+    // Display per-model results
+    console.log();
+    for (const { name, report } of reports) {
+      console.log(sectionHeader(name));
+      console.log(`  ${riskBadge(report.risk_score || 0)}`);
+      const fc = report.findings?.length || 0;
+      if (fc > 0) {
+        const counts = {};
+        for (const f of report.findings) { const s = (f.severity || 'info').toLowerCase(); counts[s] = (counts[s] || 0) + 1; }
+        const parts = [];
+        for (const sev of ['critical', 'high', 'medium', 'low', 'info']) { if (counts[sev]) parts.push(`${counts[sev]} ${sev}`); }
+        console.log(`  ${c.dim}${fc} findings: ${parts.join(', ')}${c.reset}`);
+      } else {
+        console.log(`  ${c.green}No findings${c.reset}`);
+      }
+      console.log();
+    }
+
+    // Consensus comparison
+    if (reports.length > 1) {
+      console.log(sectionHeader('Consensus'));
+
+      // Risk range
+      const risks = reports.map(r => r.report.risk_score || 0);
+      const minRisk = Math.min(...risks);
+      const maxRisk = Math.max(...risks);
+      const avgRisk = Math.round(risks.reduce((a, b) => a + b, 0) / risks.length);
+      console.log(`  Risk: ${riskBadge(avgRisk)} ${c.dim}(range ${minRisk}–${maxRisk})${c.reset}`);
+      console.log();
+
+      // Severity agreement
+      const severities = reports.map(r => (r.report.max_severity || 'none').toLowerCase());
+      const allSameSev = severities.every(s => s === severities[0]);
+      if (allSameSev) {
+        console.log(`  ${c.green}${reports.length}/${reports.length} models agree:${c.reset} ${severities[0].toUpperCase()}`);
+      } else {
+        console.log(`  ${c.yellow}Models disagree on severity:${c.reset}`);
+        for (const { name, report } of reports) {
+          const sev = (report.max_severity || 'none').toUpperCase();
+          const sc = severityColor(report.max_severity);
+          console.log(`    ${sc}${sev.padEnd(10)}${c.reset} ${c.dim}${name}${c.reset}`);
         }
       }
-    } else {
-      // OpenAI-compatible API (OpenAI, Mistral, Groq, OpenRouter, etc.)
-      const headers = {
-        'Authorization': `Bearer ${llmApiKey}`,
-        'Content-Type': 'application/json',
-      };
-      // OpenRouter requires additional headers
-      if (activeLlm.provider === 'openrouter') {
-        headers['HTTP-Referer'] = 'https://agentaudit.dev';
-        headers['X-Title'] = 'AgentAudit CLI';
+      console.log();
+
+      // Finding intersection (match by normalized title)
+      const findingsByTitle = new Map();
+      for (const { name, report } of reports) {
+        for (const f of (report.findings || [])) {
+          const key = (f.title || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+          if (!key) continue;
+          if (!findingsByTitle.has(key)) findingsByTitle.set(key, { title: f.title, severity: f.severity, models: [] });
+          findingsByTitle.get(key).models.push(name);
+        }
       }
-      const res = await fetch(activeLlm.url, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({
-          model: activeLlm.model,
-          max_tokens: 8192,
-          messages: [
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: userMessage },
-          ],
-        }),
-        signal: AbortSignal.timeout(120_000),
-      });
-      data = await res.json();
-      if (data.error) {
-        console.log(` ${c.red}failed${c.reset}`);
-        const friendly = formatApiError(data.error, activeLlm.provider, res.status);
-        if (friendly) {
-          console.log(`  ${c.red}${friendly.text}${c.reset}`);
-          console.log(`  ${c.dim}${friendly.hint}${c.reset}`);
-        } else {
-          console.log(`  ${c.red}API error: ${data.error.message || JSON.stringify(data.error)}${c.reset}`);
+
+      const shared = [...findingsByTitle.values()].filter(f => f.models.length > 1);
+      const unique = [...findingsByTitle.values()].filter(f => f.models.length === 1);
+
+      if (shared.length > 0) {
+        console.log(`  ${c.bold}Shared findings (${shared.length}):${c.reset}`);
+        for (const f of shared) {
+          const sc = severityColor(f.severity);
+          console.log(`    ${sc}┃${c.reset} ${sc}${(f.severity || '').toUpperCase().padEnd(8)}${c.reset} ${f.title} ${c.dim}(${f.models.length}/${reports.length})${c.reset}`);
         }
-        try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
-        return null;
+        console.log();
       }
-      _lastLlmText = data.choices?.[0]?.message?.content || '';
-      report = extractJSON(_lastLlmText);
-      if (report) {
-        report.audit_model = data.model || activeLlm.model;
-        report.audit_provider = activeLlm.provider;
-        if (data.id) report.provider_msg_id = data.id;
-        if (data.system_fingerprint) report.provider_fingerprint = data.system_fingerprint;
-        if (data.usage) {
-          report.input_tokens = data.usage.prompt_tokens;
-          report.output_tokens = data.usage.completion_tokens;
+
+      if (unique.length > 0) {
+        console.log(`  ${c.bold}Unique findings (${unique.length}):${c.reset}`);
+        for (const f of unique) {
+          const sc = severityColor(f.severity);
+          console.log(`    ${sc}┃${c.reset} ${sc}${(f.severity || '').toUpperCase().padEnd(8)}${c.reset} ${f.title} ${c.dim}(${f.models[0]} only)${c.reset}`);
         }
+        console.log();
       }
     }
-    
-    console.log(` ${c.green}done${c.reset} ${c.dim}(${elapsed(start)})${c.reset}`);
-  } catch (err) {
-    console.log(` ${c.red}failed${c.reset}`);
-    if (err.name === 'TimeoutError' || err.message?.includes('timeout')) {
-      console.log(`  ${c.red}Request timed out (120s)${c.reset}`);
-      console.log(`  ${c.dim}The provider took too long to respond. Try again or use a faster model${c.reset}`);
-    } else if (err.code === 'ENOTFOUND' || err.code === 'ECONNREFUSED' || err.message?.includes('fetch failed')) {
-      console.log(`  ${c.red}Network error: could not reach ${activeProvider}${c.reset}`);
-      console.log(`  ${c.dim}Check your internet connection or provider status${c.reset}`);
-    } else {
-      console.log(`  ${c.red}${err.message}${c.reset}`);
+
+    // Upload each report
+    const noUpload = process.argv.includes('--no-upload');
+    const creds = loadCredentials();
+    if (!noUpload && creds) {
+      for (const { report } of reports) await uploadReport(report, creds);
+      console.log(`  ${c.dim}Reports: ${REGISTRY_URL}/packages/${slug}${c.reset}`);
+    } else if (!noUpload && !creds) {
+      console.log(`  ${c.dim}Run ${c.cyan}agentaudit setup${c.dim} to upload reports to agentaudit.dev${c.reset}`);
+    }
+
+    console.log();
+    return reports.map(r => r.report);
+  }
+
+  // ── Single-Model Path ────────────────────────────────────
+  // If --models has exactly 1 model, use it; otherwise resolve via --model / config / env
+  let activeLlm;
+  if (modelNames.length === 1) {
+    activeLlm = resolveModel(modelNames[0]);
+  } else {
+    activeLlm = resolveProvider();
+    // Model override: --model flag > AGENTAUDIT_MODEL env > credentials.json > provider default
+    const modelArgIdx2 = process.argv.indexOf('--model');
+    const modelFlag2 = modelArgIdx2 !== -1 ? process.argv[modelArgIdx2 + 1] : null;
+    const modelOverride = modelFlag2 || process.env.AGENTAUDIT_MODEL || loadLlmConfig()?.llm_model || null;
+    if (activeLlm && modelOverride) activeLlm.model = modelOverride;
+  }
+
+  if (!activeLlm) {
+    console.log();
+    console.log(`  ${c.yellow}No LLM API key found.${c.reset} The ${c.bold}audit${c.reset} command needs an LLM to analyze code.`);
+    console.log();
+    console.log(`  ${c.bold}Set an API key${c.reset} (e.g. ${c.cyan}export OPENROUTER_API_KEY=sk-or-...${c.reset})`);
+    console.log(`  ${c.dim}Run "agentaudit model" to configure provider + model interactively${c.reset}`);
+    console.log();
+    console.log(`  ${c.bold}Or export for manual review:${c.reset} ${c.cyan}agentaudit audit ${url} --export${c.reset}`);
+    console.log(`  ${c.bold}Or use as MCP server${c.reset} in Cursor/Claude ${c.dim}(no extra API key needed)${c.reset}`);
+    console.log(`  ${c.dim}{ "agentaudit": { "command": "npx", "args": ["-y", "agentaudit"] } }${c.reset}`);
+    console.log();
+    if (process.argv.includes('--export')) {
+      const exportPath = path.join(process.cwd(), `audit-${slug}.md`);
+      const exportContent = [
+        `# Security Audit: ${slug}`, `**Source:** ${url}`, `**Files:** ${files.length}`, ``,
+        `## Audit Instructions`, ``, auditPrompt || '(audit prompt not found)', ``,
+        `## Report Format`, ``, `After analysis, produce a JSON report:`,
+        '```json', `{ "skill_slug": "${slug}", "source_url": "${url}", "risk_score": 0, "result": "safe", "findings": [] }`, '```',
+        ``, `## Source Code`, ``, codeBlock,
+      ].join('\n');
+      fs.writeFileSync(exportPath, exportContent);
+      console.log(`  ${icons.safe}  Exported to ${c.bold}${exportPath}${c.reset}`);
+      console.log(`  ${c.dim}Paste this into any LLM (Claude, ChatGPT, etc.) for analysis${c.reset}`);
     }
-    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
     return null;
   }
-  
-  // Provenance: compute BEFORE cleanup (needs repoPath on disk)
-  let commitSha = '';
-  try {
-    commitSha = execSync('git rev-parse HEAD', { cwd: repoPath, encoding: 'utf8' }).trim();
-  } catch { /* shallow clone without HEAD — unlikely but safe */ }
-  const sourceHash = crypto.createHash('sha256').update(
-    files.slice().sort((a, b) => a.path.localeCompare(b.path))
-      .map(f => f.path + '\n' + f.content).join('\n')
-  ).digest('hex');
-  // Code-based type detection (uses files array in memory + repoPath for context)
-  const pkgInfo = detectPackageInfo(repoPath, files);
-  // Known MCP frameworks are libraries, not servers (they contain MCP patterns but ARE the SDK)
-  const KNOWN_MCP_LIBS = new Set(['fastmcp', 'jlowin-fastmcp', 'mcp-go', 'fastapi-mcp', 'fastapi_mcp', 'mcp-use', 'mcp-agent']);
-  const KNOWN_CLI = new Set(['mcp-cli', 'mcp-scan', 'inspector']);
-  let detectedType = pkgInfo.type === 'unknown' ? 'other' : pkgInfo.type;
-  if (KNOWN_MCP_LIBS.has(slug)) detectedType = 'library';
-  if (KNOWN_CLI.has(slug)) detectedType = 'cli-tool';
 
-  // Cleanup repo (safe now — provenance data captured above)
-  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  // Single LLM call via callLlm()
+  const modelLabel = `${activeLlm.name} → ${activeLlm.model}`;
+  process.stdout.write(`  ${stepProgress(4, 4)} Running LLM analysis ${c.dim}(${modelLabel})${c.reset}...`);
+
+  const llmResult = await callLlm(activeLlm, systemPrompt, userMessage);
+
+  if (llmResult.error) {
+    console.log(` ${c.red}failed${c.reset}`);
+    console.log(`  ${c.red}${llmResult.error}${c.reset}`);
+    if (llmResult.hint) console.log(`  ${c.dim}${llmResult.hint}${c.reset}`);
+    return null;
+  }
+
+  console.log(` ${c.green}done${c.reset} ${c.dim}(${elapsed(start)})${c.reset}`);
 
+  const report = llmResult.report;
   if (!report) {
     console.log(`  ${c.red}Could not parse LLM response as JSON${c.reset}`);
     console.log(`  ${c.dim}Hint: run with --debug to see the raw LLM response${c.reset}`);
     if (process.argv.includes('--debug')) {
       console.log(`  ${c.dim}--- Raw LLM response (first 2000 chars) ---${c.reset}`);
-      console.log((typeof _lastLlmText === 'string' ? _lastLlmText : '(empty)').slice(0, 2000));
+      console.log((llmResult.text || '(empty)').slice(0, 2000));
       console.log(`  ${c.dim}--- end ---${c.reset}`);
     }
     return null;
   }
 
-  // Force slug from URL — never trust LLM-provided skill_slug
-  report.skill_slug = slug;
-
-  // Force package_type from code detection — never trust LLM-provided type
-  report.package_type = detectedType;
-
-  // Add scan metadata for benchmarking
-  report.audit_duration_ms = Date.now() - start;
-  report.files_scanned = files.length;
-
-  // Set provenance data
-  if (commitSha) report.commit_sha = commitSha;
-  report.source_hash = sourceHash;
+  enrichReport(report);
+  saveHistory(report);
 
   // Display results
   console.log();
-  const riskScore = report.risk_score || 0;
   console.log(sectionHeader('Result'));
-  console.log(`  ${riskBadge(riskScore)}`);
+  console.log(`  ${riskBadge(report.risk_score || 0)}`);
   console.log();
 
   if (report.findings && report.findings.length > 0) {
@@ -2312,8 +3010,6 @@ async function auditRepo(url) {
       if (f.description) console.log(`  ${sc}┃${c.reset}           ${c.dim}${f.description.slice(0, 120)}${c.reset}`);
       console.log();
     }
-
-    // Severity histogram
     const histLines = severityHistogram(report.findings);
     if (histLines.length > 1) {
       console.log(sectionHeader('Severity'));
@@ -2324,41 +3020,16 @@ async function auditRepo(url) {
     console.log(`  ${c.green}No findings — package looks clean.${c.reset}`);
     console.log();
   }
-  
-  // Upload to registry (skip with --no-upload)
+
+  // Upload to registry
   const noUpload = process.argv.includes('--no-upload');
   let creds = loadCredentials();
   if (noUpload) {
     // Skip silently
   } else if (creds) {
-    process.stdout.write(`  Uploading report to registry...`);
-    try {
-      const res = await fetch(`${REGISTRY_URL}/api/reports`, {
-        method: 'POST',
-        headers: {
-          'Authorization': `Bearer ${creds.api_key}`,
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify(report),
-        signal: AbortSignal.timeout(15_000),
-      });
-      if (res.ok) {
-        const data = await res.json();
-        console.log(` ${c.green}done${c.reset}`);
-        console.log(`  ${c.dim}Report: ${REGISTRY_URL}/packages/${slug}${c.reset}`);
-      } else {
-        let errBody = '';
-        try { errBody = await res.text(); } catch {}
-        console.log(` ${c.yellow}failed (HTTP ${res.status})${c.reset}`);
-        if (errBody && process.argv.includes('--debug')) {
-          console.log(`  ${c.dim}Server: ${errBody.slice(0, 300)}${c.reset}`);
-        }
-      }
-    } catch (err) {
-      console.log(` ${c.yellow}failed${c.reset}`);
-    }
+    await uploadReport(report, creds);
+    console.log(`  ${c.dim}Report: ${REGISTRY_URL}/packages/${slug}${c.reset}`);
   } else if (process.stdin.isTTY) {
-    // No credentials — prompt to paste key or set up
     console.log();
     console.log(`  ${c.bold}Want to upload this report to agentaudit.dev?${c.reset}`);
     console.log(`  ${c.dim}Create an API key at ${c.cyan}${REGISTRY_URL}/profile${c.dim} (sign in with GitHub)${c.reset}`);
@@ -2372,27 +3043,8 @@ async function auditRepo(url) {
         saveCredentials({ api_key: pastedKey.trim(), agent_name: agentName });
         creds = { api_key: pastedKey.trim(), agent_name: agentName };
         console.log(` ${c.green}valid!${c.reset}`);
-        process.stdout.write(`  Uploading report...`);
-        try {
-          const res = await fetch(`${REGISTRY_URL}/api/reports`, {
-            method: 'POST',
-            headers: {
-              'Authorization': `Bearer ${creds.api_key}`,
-              'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(report),
-            signal: AbortSignal.timeout(15_000),
-          });
-          if (res.ok) {
-            console.log(` ${c.green}done${c.reset}`);
-            console.log(`  ${c.dim}Report: ${REGISTRY_URL}/packages/${slug}${c.reset}`);
-          } else {
-            console.log(` ${c.yellow}failed (HTTP ${res.status})${c.reset}`);
-          }
-        } catch (err) {
-          console.log(` ${c.red}failed${c.reset}`);
-          console.log(`  ${c.dim}${err.message}${c.reset}`);
-        }
+        await uploadReport(report, creds);
+        console.log(`  ${c.dim}Report: ${REGISTRY_URL}/packages/${slug}${c.reset}`);
       } else {
         console.log(` ${c.red}invalid key${c.reset}`);
         console.log(`  ${c.dim}Run ${c.cyan}agentaudit setup${c.dim} to configure.${c.reset}`);
@@ -2401,7 +3053,7 @@ async function auditRepo(url) {
   } else {
     console.log(`  ${c.dim}Run ${c.cyan}agentaudit setup${c.dim} to configure your API key and upload reports${c.reset}`);
   }
-  
+
   console.log();
   return report;
 }
@@ -2594,20 +3246,22 @@ function renderBenchmarkTab(data, width) {
   lines.push(`  ${c.bold}${fmtNum(benchmark.models.length)}${c.reset} models ${c.dim}│${c.reset} ${c.bold}${fmtNum(overview.total_reports || 0)}${c.reset} audits ${c.dim}│${c.reset} ${c.bold}${fmtNum(overview.total_findings || 0)}${c.reset} findings`);
   lines.push('');
 
-  // Header
-  const nameW = 28;
-  const hdr = `  ${padRight(`${c.bold}Model${c.reset}`, nameW + 9)}  ${padRight('Audits', 7)} ${padRight('Risk', 5)} ${padRight('Detection', 16)}  Severity`;
-  lines.push(hdr);
+  // Header — fixed column widths for alignment
+  const nameW = 30;
+  const auditsW = 6;
+  const riskW = 5;
+  const hdr = `  ${padRight('Model', nameW)}  ${padLeft('Audits', auditsW)}  ${padLeft('Risk', riskW)}  ${'Detection'.padEnd(14)}  Severity`;
+  lines.push(`  ${c.bold}${stripAnsi(hdr).trim()}${c.reset}`);
   lines.push(`  ${c.dim}${'─'.repeat(Math.min(width - 4, 86))}${c.reset}`);
 
   for (const m of benchmark.models) {
     const name = (m.audit_model || 'unknown').slice(0, nameW - 2);
-    const audits = padLeft(fmtNum(m.total_audits), 5);
+    const audits = padLeft(fmtNum(m.total_audits), auditsW);
     const riskVal = parseFloat(m.avg_risk_score) || 0;
     const riskColor = riskVal <= 20 ? c.green : riskVal <= 40 ? c.yellow : c.red;
-    const risk = `${riskColor}${padLeft(String(Math.round(riskVal)), 3)}${c.reset}`;
+    const risk = `${riskColor}${padLeft(String(Math.round(riskVal)), riskW)}${c.reset}`;
     const detection = renderGauge(m.detection_rate || 0, 100, 10);
-    // Severity as compact text instead of dots
+    // Severity as compact text
     const sev = m.severity_breakdown || {};
     const sevParts = [];
     if (sev.critical) sevParts.push(`${c.red}${sev.critical}C${c.reset}`);
@@ -2615,7 +3269,7 @@ function renderBenchmarkTab(data, width) {
     if (sev.medium) sevParts.push(`${c.yellow}${sev.medium}M${c.reset}`);
     if (sev.low) sevParts.push(`${c.blue}${sev.low}L${c.reset}`);
     const sevStr = sevParts.length > 0 ? sevParts.join(' ') : `${c.dim}—${c.reset}`;
-    lines.push(`  ${padRight(name, nameW)} ${audits}  ${risk}  ${detection}  ${sevStr}`);
+    lines.push(`  ${padRight(name, nameW)}  ${audits}  ${risk}  ${detection}  ${sevStr}`);
   }
 
   // Vulnerability landscape
@@ -3283,9 +3937,11 @@ async function main() {
   // Strip global flags from args (including --model <value>)
   const globalFlags = new Set(['--json', '--quiet', '-q', '--no-color', '--no-upload']);
   let args = rawArgs.filter(a => !globalFlags.has(a));
-  // Remove --model <value> pair
+  // Remove --model <value> and --models <value> pairs
   const modelIdx = args.indexOf('--model');
   if (modelIdx !== -1) args.splice(modelIdx, 2);
+  const modelsIdx = args.indexOf('--models');
+  if (modelsIdx !== -1) args.splice(modelsIdx, 2);
   
   // Detect per-command --help BEFORE stripping (e.g. `agentaudit model --help`)
   const wantsHelp = args.includes('--help') || args.includes('-h');
@@ -3335,15 +3991,16 @@ async function main() {
       `Deep LLM-powered 3-pass security audit (~30s). Requires an LLM API key.`,
       ``,
       `${c.bold}Options:${c.reset}`,
-      `  --model <name>   Override LLM model for this run`,
-      `  --no-upload      Skip uploading report to registry`,
-      `  --export         Export audit payload as markdown (for manual LLM review)`,
-      `  --debug          Show raw LLM response on parse errors`,
+      `  --model <name>     Override LLM model for this run`,
+      `  --models <a,b,c>   Multi-model audit (parallel calls, consensus comparison)`,
+      `  --no-upload        Skip uploading report to registry`,
+      `  --export           Export audit payload as markdown (for manual LLM review)`,
+      `  --debug            Show raw LLM response on parse errors`,
       ``,
       `${c.bold}Examples:${c.reset}`,
       `  agentaudit audit https://github.com/owner/repo`,
-      `  agentaudit audit https://github.com/owner/repo --no-upload`,
       `  agentaudit audit https://github.com/owner/repo --model gpt-4o`,
+      `  agentaudit audit https://github.com/owner/repo --models gemini-2.5-flash,claude-sonnet-4-20250514`,
       `  agentaudit audit https://github.com/owner/repo --export`,
     ],
     lookup: [
@@ -3457,10 +4114,32 @@ async function main() {
       `  agentaudit benchmark --json`,
     ],
     bench: null, // alias → benchmark
+    consensus: [
+      `${c.bold}agentaudit consensus${c.reset} <package-name>`,
+      ``,
+      `View multi-model consensus status from the AgentAudit registry.`,
+      `Shows agreement across different LLM models and peer reviewers.`,
+      ``,
+      `${c.bold}Options:${c.reset}`,
+      `  --json          Machine-readable JSON output`,
+      ``,
+      `${c.bold}Examples:${c.reset}`,
+      `  agentaudit consensus nanobanana-mcp-server`,
+      `  agentaudit consensus fastmcp --json`,
+    ],
+    history: [
+      `${c.bold}agentaudit history${c.reset} [options]`,
+      ``,
+      `Show your local audit history. Results are stored in ~/.config/agentaudit/history/`,
+      `after every audit run. No internet connection required.`,
+      ``,
+      `${c.bold}Options:${c.reset}`,
+      `  --json          Machine-readable JSON output`,
+    ],
     activity: [
       `${c.bold}agentaudit activity${c.reset} [options]`,
       ``,
-      `Show your recent audits and findings from the AgentAudit registry.`,
+      `Show your recent audits and findings from the AgentAudit registry (online).`,
       `Requires being logged in (run ${c.cyan}agentaudit setup${c.reset} first).`,
       ``,
       `${c.bold}Options:${c.reset}`,
@@ -3553,16 +4232,19 @@ async function main() {
     console.log(`    agentaudit <command> [options]`);
     console.log();
     console.log(`  ${c.bold}SCAN & AUDIT${c.reset}`);
-    console.log(`    ${c.cyan}discover${c.reset}              Find MCP servers in your AI editors`);
+    console.log(`    ${c.cyan}discover${c.reset}              Find MCP servers & skills in your AI tools`);
     console.log(`    ${c.cyan}scan${c.reset} <url> [url...]   Quick static scan (regex, ~2s)`);
     console.log(`    ${c.cyan}audit${c.reset} <url> [url...]  Deep LLM-powered security audit (~30s)`);
+    console.log(`    ${c.cyan}validate${c.reset} [path]       Validate SKILL.md format & security`);
     console.log(`    ${c.cyan}lookup${c.reset} <name>         Look up package in registry`);
+    console.log(`    ${c.cyan}consensus${c.reset} <name>      View multi-model consensus for a package`);
     console.log();
     console.log(`  ${c.bold}COMMUNITY${c.reset}`);
     console.log(`    ${c.cyan}dashboard${c.reset}             Interactive dashboard (full-screen)`);
     console.log(`    ${c.cyan}leaderboard${c.reset}           Top contributors ranking`);
     console.log(`    ${c.cyan}benchmark${c.reset}             LLM model performance comparison`);
-    console.log(`    ${c.cyan}activity${c.reset}              Your recent audits & findings`);
+    console.log(`    ${c.cyan}history${c.reset}               Your local audit history`);
+    console.log(`    ${c.cyan}activity${c.reset}              Your recent audits & findings (online)`);
     console.log(`    ${c.cyan}search${c.reset} <query>        Search packages in registry`);
     console.log();
     console.log(`  ${c.bold}CONFIGURATION${c.reset}`);
@@ -3576,6 +4258,7 @@ async function main() {
     console.log(`    ${c.dim}--quiet            Suppress banner${c.reset}`);
     console.log(`    ${c.dim}--no-color         Disable ANSI colors (also: NO_COLOR env)${c.reset}`);
     console.log(`    ${c.dim}--model <name>     Override LLM model for this run${c.reset}`);
+    console.log(`    ${c.dim}--models <a,b,c>   Multi-model audit (parallel, with consensus)${c.reset}`);
     console.log(`    ${c.dim}--no-upload        Skip uploading report to registry${c.reset}`);
     console.log(`    ${c.dim}--export           Export audit payload as markdown${c.reset}`);
     console.log(`    ${c.dim}--debug            Show raw LLM response on parse errors${c.reset}`);
@@ -3584,6 +4267,7 @@ async function main() {
     console.log(`    agentaudit discover --quick`);
     console.log(`    agentaudit scan https://github.com/owner/repo`);
     console.log(`    agentaudit audit https://github.com/owner/repo`);
+    console.log(`    agentaudit audit <url> --models gemini-2.5-flash,claude-sonnet-4-20250514`);
     console.log(`    agentaudit lookup fastmcp --json`);
     console.log();
     console.log(`  ${c.bold}LEARN MORE${c.reset}`);
@@ -3610,6 +4294,37 @@ async function main() {
     await benchmarkCommand(targets);
     return;
   }
+  if (command === 'history') {
+    banner();
+    const entries = loadHistory(30);
+    if (entries.length === 0) {
+      console.log(`  ${c.dim}No local audit history yet. Run ${c.cyan}agentaudit audit <url>${c.dim} to start.${c.reset}`);
+      console.log();
+      return;
+    }
+
+    if (jsonMode) {
+      console.log(JSON.stringify(entries, null, 2));
+      return;
+    }
+
+    console.log(sectionHeader(`Local History (${entries.length})`));
+    console.log();
+
+    for (const entry of entries) {
+      const slug = entry.skill_slug || 'unknown';
+      const risk = entry.risk_score ?? '?';
+      const sev = entry.max_severity || 'none';
+      const sc = severityColor(sev);
+      const model = entry.audit_model || '?';
+      const fc = entry.findings?.length || 0;
+      const ts = entry._file?.slice(0, 10) || '';
+      console.log(`  ${sc}┃${c.reset} ${c.bold}${slug.padEnd(30)}${c.reset} ${riskBadge(risk)}  ${c.dim}${model}${c.reset}`);
+      console.log(`  ${sc}┃${c.reset} ${c.dim}${ts}  ${fc} findings  ${sev.toUpperCase()}${c.reset}`);
+      console.log();
+    }
+    return;
+  }
   if (command === 'activity' || command === 'my') {
     await activityCommand(targets);
     return;
@@ -3618,6 +4333,73 @@ async function main() {
     await searchCommand(targets);
     return;
   }
+  if (command === 'consensus') {
+    banner();
+    const pkg = targets[0];
+    if (!pkg) {
+      console.log(`  ${c.red}Error: package name required${c.reset}`);
+      console.log(`  ${c.dim}Usage: ${c.cyan}agentaudit consensus <package-name>${c.reset}`);
+      process.exitCode = 2;
+      return;
+    }
+    const slug = pkg.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    if (!jsonMode) console.log(`  Fetching consensus for ${c.bold}${slug}${c.reset}...`);
+    try {
+      const res = await fetch(`${REGISTRY_URL}/api/packages/${slug}/consensus`, { signal: AbortSignal.timeout(10_000) });
+      if (!res.ok) {
+        if (res.status === 404) {
+          console.log(`  ${c.yellow}Not found${c.reset} — "${slug}" hasn't been audited yet.`);
+          console.log(`  ${c.dim}Run: ${c.cyan}agentaudit audit <repo-url>${c.dim} to create the first audit${c.reset}`);
+        } else {
+          console.log(`  ${c.red}API error (HTTP ${res.status})${c.reset}`);
+        }
+        return;
+      }
+      const data = await res.json();
+      if (jsonMode) { console.log(JSON.stringify(data, null, 2)); return; }
+
+      console.log();
+      console.log(sectionHeader(`Consensus: ${slug}`));
+      console.log();
+
+      // Status
+      const status = data.consensus_status || data.status || 'pending';
+      const statusColor = status === 'reached' ? c.green : status === 'disputed' ? c.yellow : c.dim;
+      console.log(`  Status:   ${statusColor}${status.toUpperCase()}${c.reset}`);
+
+      // Risk + Severity
+      if (data.consensus_risk_score != null) console.log(`  Risk:     ${riskBadge(data.consensus_risk_score)}`);
+      if (data.consensus_severity) {
+        const sc = severityColor(data.consensus_severity);
+        console.log(`  Severity: ${sc}${data.consensus_severity.toUpperCase()}${c.reset}`);
+      }
+
+      // Models
+      if (data.models && data.models.length > 0) {
+        console.log();
+        console.log(`  ${c.bold}Models (${data.models.length}):${c.reset}`);
+        for (const m of data.models) {
+          const sc = severityColor(m.severity || m.max_severity);
+          const risk = m.risk_score ?? '?';
+          console.log(`    ${sc}┃${c.reset} ${(m.model || m.audit_model || '?').padEnd(30)} ${c.dim}risk ${risk}${c.reset}  ${sc}${(m.severity || m.max_severity || '').toUpperCase()}${c.reset}`);
+        }
+      }
+
+      // Reviewers
+      if (data.reviews != null || data.reviewer_count != null) {
+        const count = data.reviewer_count || data.reviews?.length || 0;
+        console.log();
+        console.log(`  ${c.dim}Reviews: ${count}  |  Threshold: 5 reviewers, >60% agreement${c.reset}`);
+      }
+
+      console.log();
+      console.log(`  ${c.dim}Full details: ${REGISTRY_URL}/packages/${slug}${c.reset}`);
+      console.log();
+    } catch (err) {
+      console.log(`  ${c.red}Failed: ${err.message}${c.reset}`);
+    }
+    return;
+  }
 
   banner();
 
@@ -3988,6 +4770,124 @@ async function main() {
     return;
   }
   
+  if (command === 'validate') {
+    const paths = targets.filter(t => !t.startsWith('--'));
+
+    // If no path given, find all skills and validate them
+    if (paths.length === 0) {
+      const skills = findSkills();
+      if (skills.length === 0) {
+        console.log(`  ${c.yellow}No SKILL.md files found${c.reset}`);
+        console.log(`  ${c.dim}Searched: ~/.claude/skills/, ~/.cursor/skills/, .claude/skills/, .cursor/skills/${c.reset}`);
+        console.log();
+        console.log(`  ${c.dim}Usage: ${c.cyan}agentaudit validate [path/to/SKILL.md]${c.reset}`);
+        return;
+      }
+
+      console.log(`  ${c.bold}Validating ${skills.length} skill${skills.length !== 1 ? 's' : ''}${c.reset}`);
+      console.log();
+
+      let totalErrors = 0;
+      let totalWarnings = 0;
+
+      for (const skill of skills) {
+        const { errors, warnings, info } = skill.validation;
+        totalErrors += errors.length;
+        totalWarnings += warnings.length;
+
+        const name = info.name || skill.dirName;
+        const hasErrors = errors.length > 0;
+        const hasWarnings = warnings.length > 0;
+
+        if (hasErrors) {
+          console.log(`  ${c.red}✖${c.reset} ${c.bold}${name}${c.reset}  ${c.dim}${skill.path}${c.reset}`);
+          for (const err of errors) console.log(`    ${c.red}✖ ${err}${c.reset}`);
+          for (const warn of warnings) console.log(`    ${c.yellow}⚠ ${warn}${c.reset}`);
+        } else if (hasWarnings) {
+          console.log(`  ${c.yellow}⚠${c.reset} ${c.bold}${name}${c.reset}  ${c.dim}${skill.path}${c.reset}`);
+          for (const warn of warnings) console.log(`    ${c.yellow}⚠ ${warn}${c.reset}`);
+        } else {
+          console.log(`  ${c.green}✔${c.reset} ${c.bold}${name}${c.reset}  ${c.dim}${skill.path}${c.reset}`);
+        }
+
+        // Show MCP references
+        if (info.mcpServers && info.mcpServers.length > 0) {
+          console.log(`    ${c.dim}MCP servers: ${info.mcpServers.join(', ')}${c.reset}`);
+        }
+        if (info.allowedTools === null) {
+          console.log(`    ${c.yellow}⚠ no allowed-tools — unrestricted tool access${c.reset}`);
+        }
+        console.log();
+      }
+
+      // Summary
+      console.log(sectionHeader('Validation Summary'));
+      console.log();
+      if (totalErrors === 0 && totalWarnings === 0) {
+        console.log(`  ${c.green}✔ All ${skills.length} skills valid${c.reset}`);
+      } else {
+        if (totalErrors > 0) console.log(`  ${c.red}✖ ${totalErrors} error${totalErrors !== 1 ? 's' : ''}${c.reset}`);
+        if (totalWarnings > 0) console.log(`  ${c.yellow}⚠ ${totalWarnings} warning${totalWarnings !== 1 ? 's' : ''}${c.reset}`);
+      }
+      console.log();
+
+      if (jsonMode) {
+        console.log(JSON.stringify(skills.map(s => ({
+          name: s.validation.info.name || s.dirName,
+          path: s.path,
+          source: s.source,
+          errors: s.validation.errors,
+          warnings: s.validation.warnings,
+          mcpServers: s.validation.info.mcpServers,
+          allowedTools: s.validation.info.allowedTools,
+        })), null, 2));
+      }
+
+      process.exitCode = totalErrors > 0 ? 1 : 0;
+      return;
+    }
+
+    // Validate specific file(s)
+    for (const p of paths) {
+      const resolved = path.resolve(p);
+      if (!fs.existsSync(resolved)) {
+        console.log(`  ${c.red}✖ File not found: ${p}${c.reset}`);
+        process.exitCode = 1;
+        continue;
+      }
+
+      const content = fs.readFileSync(resolved, 'utf8');
+      const parsed = parseSkillFrontmatter(content);
+      const { errors, warnings, info } = validateSkill(parsed);
+      const name = info.name || path.basename(path.dirname(resolved));
+
+      console.log(`  ${c.bold}${name}${c.reset}  ${c.dim}${resolved}${c.reset}`);
+      console.log();
+
+      if (errors.length === 0 && warnings.length === 0) {
+        console.log(`  ${c.green}✔ Valid skill format${c.reset}`);
+      }
+
+      for (const err of errors) console.log(`  ${c.red}✖ ${err}${c.reset}`);
+      for (const warn of warnings) console.log(`  ${c.yellow}⚠ ${warn}${c.reset}`);
+
+      if (info.name) console.log(`  ${c.dim}name:${c.reset} ${info.name}`);
+      if (info.description) console.log(`  ${c.dim}description:${c.reset} ${info.description.slice(0, 80)}${info.description.length > 80 ? '...' : ''}`);
+      if (info.allowedTools) console.log(`  ${c.dim}allowed-tools:${c.reset} ${info.allowedTools.join(', ')}`);
+      else if (info.allowedTools === null) console.log(`  ${c.yellow}allowed-tools: none (unrestricted)${c.reset}`);
+      if (info.mcpServers?.length > 0) console.log(`  ${c.dim}MCP servers:${c.reset} ${info.mcpServers.join(', ')}`);
+      if (info.bodyLines) console.log(`  ${c.dim}body:${c.reset} ${info.bodyLines} lines`);
+      console.log();
+
+      if (jsonMode) {
+        console.log(JSON.stringify({ name: info.name, path: resolved, errors, warnings, info }, null, 2));
+      }
+
+      process.exitCode = errors.length > 0 ? 1 : 0;
+    }
+    return;
+  }
+
   if (command === 'discover') {
     const scanFlag = targets.includes('--quick') || targets.includes('--scan') || targets.includes('-s');
     const auditFlag = targets.includes('--deep') || targets.includes('--audit') || targets.includes('-a');
@@ -4081,8 +4981,13 @@ async function main() {
     
     let hasFindings = false;
     for (const url of urls) {
-      const report = await auditRepo(url);
-      if (report?.findings?.length > 0) hasFindings = true;
+      const result = await auditRepo(url);
+      // Multi-model returns array, single-model returns object
+      if (Array.isArray(result)) {
+        if (result.some(r => r?.findings?.length > 0)) hasFindings = true;
+      } else if (result?.findings?.length > 0) {
+        hasFindings = true;
+      }
     }
     process.exitCode = hasFindings ? 1 : 0;
     return;