cryptoserve 0.1.3 → 0.2.1

package/lib/crypto-registry.mjs

@@ -0,0 +1,161 @@
+/**
+ * Centralized crypto package registry — single source of truth for all ecosystems.
+ *
+ * Consolidates package metadata previously duplicated across scanner.mjs (npm only,
+ * uppercase algorithms) and scanner-manifests.mjs (all ecosystems, lowercase).
+ * Algorithms are stored in lowercase, matching algorithm-db.mjs canonical form.
+ * Zero dependencies.
+ */
+
+// ---------------------------------------------------------------------------
+// Known crypto packages per ecosystem
+// ---------------------------------------------------------------------------
+
+export const CRYPTO_PACKAGES = {
+  // npm uses display-name algorithms for backward compat with scanner.mjs output.
+  // The manifest scanner skips npm (parser is null), so only lookupNpmPackage reads this.
+  npm: {
+    'crypto-js':           { category: 'symmetric', algorithms: ['AES', 'DES', '3DES', 'MD5', 'SHA-256', 'SHA-512', 'HMAC'], quantumRisk: 'low' },
+    'jsonwebtoken':        { category: 'token', algorithms: ['RS256', 'HS256', 'ES256'], quantumRisk: 'high' },
+    'jose':                { category: 'token', algorithms: ['RS256', 'ES256', 'EdDSA', 'AES-GCM'], quantumRisk: 'high' },
+    'node-forge':          { category: 'tls', algorithms: ['RSA', 'AES', 'SHA-256', 'HMAC', 'TLS'], quantumRisk: 'high' },
+    'tweetnacl':           { category: 'asymmetric', algorithms: ['X25519', 'Ed25519', 'XSalsa20'], quantumRisk: 'high' },
+    'libsodium-wrappers':  { category: 'asymmetric', algorithms: ['X25519', 'Ed25519', 'ChaCha20', 'AES-256-GCM'], quantumRisk: 'high' },
+    '@noble/curves':       { category: 'asymmetric', algorithms: ['ECDSA', 'Ed25519', 'X25519'], quantumRisk: 'high' },
+    '@noble/hashes':       { category: 'hash', algorithms: ['SHA-256', 'SHA-512', 'SHA3', 'Blake2'], quantumRisk: 'low' },
+    '@noble/post-quantum': { category: 'pqc', algorithms: ['ML-KEM', 'ML-DSA', 'SLH-DSA'], quantumRisk: 'none' },
+    'openpgp':             { category: 'asymmetric', algorithms: ['RSA', 'ECDSA', 'AES', 'SHA-256'], quantumRisk: 'high' },
+    'elliptic':            { category: 'asymmetric', algorithms: ['ECDSA', 'ECDHE', 'Ed25519'], quantumRisk: 'high' },
+    'secp256k1':           { category: 'asymmetric', algorithms: ['ECDSA'], quantumRisk: 'high' },
+    'argon2':              { category: 'kdf', algorithms: ['Argon2'], quantumRisk: 'none' },
+    'scrypt':              { category: 'kdf', algorithms: ['scrypt'], quantumRisk: 'none' },
+    'pbkdf2':              { category: 'kdf', algorithms: ['PBKDF2'], quantumRisk: 'none' },
+    'bcrypt':              { category: 'kdf', algorithms: ['bcrypt'], quantumRisk: 'none' },
+    'bcryptjs':            { category: 'kdf', algorithms: ['bcrypt'], quantumRisk: 'none' },
+    'tls':                 { category: 'tls', algorithms: ['TLS', 'RSA', 'ECDSA'], quantumRisk: 'high' },
+    'ssh2':                { category: 'asymmetric', algorithms: ['RSA', 'Ed25519', 'ECDSA', 'AES'], quantumRisk: 'high' },
+    'node-rsa':            { category: 'asymmetric', algorithms: ['RSA'], quantumRisk: 'high' },
+    'jsrsasign':           { category: 'asymmetric', algorithms: ['RSA', 'ECDSA', 'SHA-256'], quantumRisk: 'high' },
+    'ethers':              { category: 'asymmetric', algorithms: ['ECDSA', 'SHA-256'], quantumRisk: 'high' },
+  },
+  go: {
+    'crypto/aes':            { category: 'encryption', algorithms: ['aes'], quantumRisk: 'none' },
+    'crypto/des':            { category: 'encryption', algorithms: ['des', '3des'], quantumRisk: 'critical', isDeprecated: true },
+    'crypto/rsa':            { category: 'encryption', algorithms: ['rsa'], quantumRisk: 'high' },
+    'crypto/ecdsa':          { category: 'signing', algorithms: ['ecdsa'], quantumRisk: 'high' },
+    'crypto/ed25519':        { category: 'signing', algorithms: ['ed25519'], quantumRisk: 'high' },
+    'crypto/ecdh':           { category: 'key_exchange', algorithms: ['ecdh', 'x25519'], quantumRisk: 'high' },
+    'crypto/sha256':         { category: 'hashing', algorithms: ['sha256'], quantumRisk: 'low' },
+    'crypto/sha512':         { category: 'hashing', algorithms: ['sha512'], quantumRisk: 'low' },
+    'crypto/sha1':           { category: 'hashing', algorithms: ['sha1'], quantumRisk: 'critical', isDeprecated: true },
+    'crypto/md5':            { category: 'hashing', algorithms: ['md5'], quantumRisk: 'critical', isDeprecated: true },
+    'crypto/hmac':           { category: 'mac', algorithms: ['hmac'], quantumRisk: 'low' },
+    'crypto/tls':            { category: 'protocol', algorithms: ['tls'], quantumRisk: 'high' },
+    'golang.org/x/crypto':   { category: 'general', algorithms: ['chacha20-poly1305', 'argon2', 'bcrypt', 'scrypt', 'hkdf'], quantumRisk: 'none' },
+    'golang.org/x/crypto/chacha20poly1305': { category: 'encryption', algorithms: ['chacha20-poly1305'], quantumRisk: 'none' },
+    'golang.org/x/crypto/argon2':           { category: 'kdf', algorithms: ['argon2'], quantumRisk: 'none' },
+    'golang.org/x/crypto/bcrypt':           { category: 'kdf', algorithms: ['bcrypt'], quantumRisk: 'none' },
+    'golang.org/x/crypto/scrypt':           { category: 'kdf', algorithms: ['scrypt'], quantumRisk: 'none' },
+    'github.com/cloudflare/circl':          { category: 'pqc', algorithms: ['kyber', 'dilithium', 'x25519'], quantumRisk: 'none' },
+  },
+  pypi: {
+    'cryptography':    { category: 'general', algorithms: ['aes', 'rsa', 'ecdsa', 'ed25519', 'x25519', 'sha256'], quantumRisk: 'high' },
+    'pycryptodome':    { category: 'general', algorithms: ['aes', 'des', 'rsa', 'sha256', 'md5'], quantumRisk: 'high' },
+    'pycryptodomex':   { category: 'general', algorithms: ['aes', 'des', 'rsa', 'sha256', 'md5'], quantumRisk: 'high' },
+    'bcrypt':          { category: 'kdf', algorithms: ['bcrypt'], quantumRisk: 'none' },
+    'argon2-cffi':     { category: 'kdf', algorithms: ['argon2'], quantumRisk: 'none' },
+    'pynacl':          { category: 'general', algorithms: ['xchacha20', 'ed25519', 'x25519'], quantumRisk: 'high' },
+    'pyopenssl':       { category: 'general', algorithms: ['rsa', 'aes', 'sha256', 'tls'], quantumRisk: 'high' },
+    'paramiko':        { category: 'asymmetric', algorithms: ['rsa', 'ed25519', 'ecdsa', 'aes'], quantumRisk: 'high' },
+    'pyjwt':           { category: 'signing', algorithms: ['rsa', 'ecdsa', 'hmac'], quantumRisk: 'high' },
+    'hashlib':         { category: 'hashing', algorithms: ['sha256', 'sha512', 'md5', 'sha1'], quantumRisk: 'low' },
+    'hmac':            { category: 'mac', algorithms: ['hmac'], quantumRisk: 'low' },
+    'passlib':         { category: 'kdf', algorithms: ['bcrypt', 'argon2', 'pbkdf2', 'scrypt'], quantumRisk: 'none' },
+    'scrypt':          { category: 'kdf', algorithms: ['scrypt'], quantumRisk: 'none' },
+    'ecdsa':           { category: 'signing', algorithms: ['ecdsa'], quantumRisk: 'high' },
+    'rsa':             { category: 'asymmetric', algorithms: ['rsa'], quantumRisk: 'high' },
+    'liboqs-python':   { category: 'pqc', algorithms: ['kyber', 'dilithium', 'sphincs'], quantumRisk: 'none' },
+    'pqcrypto':        { category: 'pqc', algorithms: ['kyber', 'dilithium'], quantumRisk: 'none' },
+    'pyca-cryptography': { category: 'general', algorithms: ['aes', 'rsa', 'ecdsa'], quantumRisk: 'high' },
+  },
+  cargo: {
+    'aes-gcm':           { category: 'encryption', algorithms: ['aes-gcm'], quantumRisk: 'none' },
+    'aes':               { category: 'encryption', algorithms: ['aes'], quantumRisk: 'none' },
+    'chacha20poly1305':  { category: 'encryption', algorithms: ['chacha20-poly1305'], quantumRisk: 'none' },
+    'chacha20':          { category: 'encryption', algorithms: ['chacha20'], quantumRisk: 'none' },
+    'rsa':               { category: 'encryption', algorithms: ['rsa'], quantumRisk: 'high' },
+    'ed25519-dalek':     { category: 'signing', algorithms: ['ed25519'], quantumRisk: 'high' },
+    'ed25519':           { category: 'signing', algorithms: ['ed25519'], quantumRisk: 'high' },
+    'ring':              { category: 'general', algorithms: ['aes-gcm', 'sha256', 'ecdsa', 'ed25519'], quantumRisk: 'high' },
+    'pqcrypto':          { category: 'pqc', algorithms: ['kyber', 'dilithium', 'sphincs'], quantumRisk: 'none' },
+    'sha2':              { category: 'hashing', algorithms: ['sha256', 'sha512'], quantumRisk: 'low' },
+    'sha1':              { category: 'hashing', algorithms: ['sha1'], quantumRisk: 'critical', isDeprecated: true },
+    'md-5':              { category: 'hashing', algorithms: ['md5'], quantumRisk: 'critical', isDeprecated: true },
+    'blake2':            { category: 'hashing', algorithms: ['blake2b'], quantumRisk: 'low' },
+    'argon2':            { category: 'kdf', algorithms: ['argon2'], quantumRisk: 'none' },
+    'bcrypt':            { category: 'kdf', algorithms: ['bcrypt'], quantumRisk: 'none' },
+    'scrypt':            { category: 'kdf', algorithms: ['scrypt'], quantumRisk: 'none' },
+    'pbkdf2':            { category: 'kdf', algorithms: ['pbkdf2'], quantumRisk: 'none' },
+    'x25519-dalek':      { category: 'key_exchange', algorithms: ['x25519'], quantumRisk: 'high' },
+    'p256':              { category: 'signing', algorithms: ['ecdsa'], quantumRisk: 'high' },
+    'hmac':              { category: 'mac', algorithms: ['hmac'], quantumRisk: 'low' },
+    'hkdf':              { category: 'kdf', algorithms: ['hkdf'], quantumRisk: 'none' },
+    'rustls':            { category: 'protocol', algorithms: ['tls', 'aes-gcm', 'chacha20-poly1305'], quantumRisk: 'high' },
+  },
+  maven: {
+    'org.bouncycastle':  { category: 'general', algorithms: ['aes', 'rsa', 'ecdsa', 'ed25519', 'sha256'], quantumRisk: 'high' },
+    'com.google.crypto.tink': { category: 'general', algorithms: ['aes-gcm', 'ecdsa', 'ed25519'], quantumRisk: 'high' },
+    'io.jsonwebtoken':   { category: 'signing', algorithms: ['rsa', 'ecdsa', 'hmac'], quantumRisk: 'high' },
+    'com.nimbusds':      { category: 'signing', algorithms: ['rsa', 'ecdsa', 'ed25519'], quantumRisk: 'high' },
+    'org.signal':        { category: 'asymmetric', algorithms: ['x25519', 'ed25519', 'aes-gcm'], quantumRisk: 'high' },
+  },
+};
+
+// ---------------------------------------------------------------------------
+// Lookup helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Look up a dependency in the crypto packages database.
+ * For Go imports, also checks subpackage paths.
+ * For Maven, checks groupId prefix.
+ */
+export function lookupPackage(name, ecosystem) {
+  const db = CRYPTO_PACKAGES[ecosystem];
+  if (!db) return null;
+
+  // Direct match
+  if (db[name]) return { ...db[name], name };
+
+  // For Go, check if it's a subpackage of a known package
+  if (ecosystem === 'go') {
+    for (const [pkgName, info] of Object.entries(db)) {
+      if (name.startsWith(pkgName + '/') || name === pkgName) {
+        return { ...info, name: pkgName };
+      }
+    }
+  }
+
+  // For Maven, check groupId
+  if (ecosystem === 'maven') {
+    const groupId = name.split(':')[0];
+    for (const [pkgName, info] of Object.entries(db)) {
+      if (groupId.startsWith(pkgName)) {
+        return { ...info, name: pkgName };
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Shorthand for npm package lookup.
+ * Returns the package info directly — npm section already uses display-name
+ * algorithms and scanner.mjs-compatible categories.
+ */
+export function lookupNpmPackage(name) {
+  const pkg = CRYPTO_PACKAGES.npm[name];
+  if (!pkg) return null;
+  return { algorithms: pkg.algorithms, quantumRisk: pkg.quantumRisk, category: pkg.category };
+}

package/lib/init.mjs

@@ -142,13 +142,13 @@ function protectAider(projectDir, result) {
 }
 
 function addInstructions(filePath, result) {
-  let content = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
+  const existed = existsSync(filePath);
+  let content = existed ? readFileSync(filePath, 'utf-8') : '';
   if (content.includes(MARKER)) return;
 
   content += buildSecretlessInstructions();
   writeFileSync(filePath, content);
 
-  const existed = existsSync(filePath);
   if (existed) {
     result.filesModified.push(filePath);
   } else {

package/lib/pqc-engine.mjs

@@ -5,6 +5,8 @@
  * Provides air-gapped quantum readiness analysis with zero dependencies.
  */
 
+import { lookupAlgorithm, classifyFromDb } from './algorithm-db.mjs';
+
 // ---------------------------------------------------------------------------
 // Embedded intelligence data
 // ---------------------------------------------------------------------------
@@ -170,63 +172,101 @@ export const COMPLIANCE_FRAMEWORKS = {
 };
 
 // ---------------------------------------------------------------------------
-// Algorithm classification rules
+// Algorithm classification
 // ---------------------------------------------------------------------------
 
-// [pattern, timelineKey, category] — first match wins
-const ALGO_CLASSIFICATION_RULES = [
-  // PQC (safe)
-  ['Kyber',     'pqc',        'pqc'],
-  ['ML-KEM',    'pqc',        'pqc'],
-  ['Dilithium', 'pqc',        'pqc'],
-  ['ML-DSA',    'pqc',        'pqc'],
-  ['Falcon',    'pqc',        'pqc'],
-  ['SPHINCS',   'pqc',        'pqc'],
-  ['SLH-DSA',   'pqc',        'pqc'],
-  // Asymmetric (quantum-vulnerable via Shor's)
-  ['RSA',       'rsa_2048',   'asymmetric'],
-  ['ECDSA',     'ecdsa_p256', 'asymmetric'],
-  ['ECDHE',     'ecdsa_p256', 'asymmetric'],
-  ['ECC',       'ecdsa_p256', 'asymmetric'],
-  ['Ed25519',   'ed25519',    'asymmetric'],
-  ['EdDSA',     'ed25519',    'asymmetric'],
-  ['Curve25519','x25519',     'asymmetric'],
-  ['X25519',    'x25519',     'asymmetric'],
-  ['DH',        'dh_2048',    'asymmetric'],
-  // Symmetric (Grover's — key-doubling sufficient)
-  ['AES',       'aes_256',    'symmetric'],
-  ['ChaCha20',  'chacha20',   'symmetric'],
-  ['3DES',      'aes_128',    'symmetric'],
-  ['DES',       'aes_128',    'symmetric'],
-  ['XSalsa20',  'chacha20',   'symmetric'],
+// Timeline mapping: [pattern, timelineKey] — first match wins.
+// Category is now derived from algorithm-db.mjs's classifyFromDb().
+const TIMELINE_RULES = [
+  // PQC
+  ['Kyber',     'pqc'],
+  ['ML-KEM',    'pqc'],
+  ['Dilithium', 'pqc'],
+  ['ML-DSA',    'pqc'],
+  ['Falcon',    'pqc'],
+  ['SPHINCS',   'pqc'],
+  ['SLH-DSA',   'pqc'],
+  // Asymmetric
+  ['RSA',       'rsa_2048'],
+  ['ECDSA',     'ecdsa_p256'],
+  ['ECDHE',     'ecdsa_p256'],
+  ['ECC',       'ecdsa_p256'],
+  ['Ed25519',   'ed25519'],
+  ['EdDSA',     'ed25519'],
+  ['Curve25519','x25519'],
+  ['X25519',    'x25519'],
+  ['DH',        'dh_2048'],
+  // Symmetric
+  ['AES',       'aes_256'],
+  ['ChaCha20',  'chacha20'],
+  ['3DES',      'aes_128'],
+  ['DES',       'aes_128'],
+  ['XSalsa20',  'chacha20'],
   // Hashing
-  ['SHA-256',   'sha_256',    'hash'],
-  ['SHA-512',   'sha_256',    'hash'],
-  ['SHA-1',     'sha_256',    'hash'],
-  ['SHA3',      'sha_256',    'hash'],
-  ['Blake2',    'sha_256',    'hash'],
-  ['MD5',       'sha_256',    'hash'],
-  // KDF / MAC / CSPRNG
-  ['HMAC',      'sha_256',    'hash'],
-  ['bcrypt',    null,         'kdf'],
-  ['Argon2',    null,         'kdf'],
-  ['PBKDF2',    null,         'kdf'],
-  ['scrypt',    null,         'kdf'],
-  ['CSPRNG',    null,         'random'],
-  ['Poly1305',  null,         'mac'],
+  ['SHA-256',   'sha_256'],
+  ['SHA-512',   'sha_256'],
+  ['SHA-1',     'sha_256'],
+  ['SHA3',      'sha_256'],
+  ['Blake2',    'sha_256'],
+  ['MD5',       'sha_256'],
+  // MAC / KDF
+  ['HMAC',      'sha_256'],
+  ['bcrypt',    null],
+  ['Argon2',    null],
+  ['PBKDF2',    null],
+  ['scrypt',    null],
+  ['CSPRNG',    null],
+  ['Poly1305',  null],
   // Token / TLS wrappers
-  ['TLS',       'rsa_2048',   'asymmetric'],
-  ['JWS',       'rsa_2048',   'asymmetric'],
-  ['JWE',       'rsa_2048',   'asymmetric'],
-  ['JWK',       'rsa_2048',   'asymmetric'],
-  ['RS256',     'rsa_2048',   'asymmetric'],
-  ['ES256',     'ecdsa_p256', 'asymmetric'],
-  ['HS256',     'sha_256',    'hash'],
+  ['TLS',       'rsa_2048'],
+  ['JWS',       'rsa_2048'],
+  ['JWE',       'rsa_2048'],
+  ['JWK',       'rsa_2048'],
+  ['RS256',     'rsa_2048'],
+  ['ES256',     'ecdsa_p256'],
+  ['HS256',     'sha_256'],
 ];
 
-// ---------------------------------------------------------------------------
-// Classification
-// ---------------------------------------------------------------------------
+/**
+ * Map algorithm-db category + quantumRisk to PQC engine classification category.
+ * This derives the quantum vulnerability class from algorithm-db metadata.
+ */
+function dbCategoryToPqcCategory(dbEntry) {
+  if (!dbEntry) return null;
+  const { category, quantumRisk } = dbEntry;
+
+  // PQC algorithms: signing/key_exchange with no quantum risk
+  // (classical asymmetric has 'high' risk, PQC has 'none')
+  if (quantumRisk === 'none' && (category === 'signing' || category === 'key_exchange')) {
+    return 'pqc';
+  }
+
+  // Signing and key exchange → asymmetric (quantum-vulnerable via Shor's)
+  if (category === 'signing' || category === 'key_exchange') return 'asymmetric';
+
+  // Encryption with high quantum risk → asymmetric (RSA encryption)
+  if (category === 'encryption' && quantumRisk === 'high') return 'asymmetric';
+
+  // Encryption with none/low risk → symmetric
+  if (category === 'encryption') return 'symmetric';
+
+  // Hashing
+  if (category === 'hashing') return 'hash';
+
+  // MAC
+  if (category === 'mac') return 'hash';
+
+  // KDF
+  if (category === 'kdf') return 'kdf';
+
+  // Protocol (TLS) → asymmetric (involves key exchange)
+  if (category === 'protocol') return 'asymmetric';
+
+  // Random
+  if (category === 'random') return 'random';
+
+  return null;
+}
 
 function classifyAlgorithms(libraries) {
   const seen = new Set();
@@ -237,20 +277,33 @@ function classifyAlgorithms(libraries) {
       if (seen.has(algoName)) continue;
       seen.add(algoName);
 
-      let matched = false;
+      // Look up timeline key via pattern matching
+      let timelineKey = null;
       const upper = algoName.toUpperCase();
-
-      for (const [pattern, timelineKey, category] of ALGO_CLASSIFICATION_RULES) {
+      for (const [pattern, tKey] of TIMELINE_RULES) {
         if (upper.includes(pattern.toUpperCase())) {
-          results.push({ algo: algoName, timelineKey, category });
-          matched = true;
+          timelineKey = tKey;
           break;
         }
       }
 
-      if (!matched) {
-        results.push({ algo: algoName, timelineKey: null, category: 'unknown' });
+      // Derive category from algorithm-db
+      const dbEntry = classifyFromDb(algoName);
+      let category = dbEntry ? dbCategoryToPqcCategory(dbEntry) : null;
+
+      // Fallback: if algorithm-db doesn't know this algo, infer from timeline
+      if (!category) {
+        if (timelineKey === 'pqc') category = 'pqc';
+        else if (timelineKey && timelineKey in QUANTUM_THREAT_TIMELINE) {
+          // Timeline keys like rsa_2048, ecdsa_p256 → asymmetric
+          const t = QUANTUM_THREAT_TIMELINE[timelineKey];
+          category = t.median <= 30 ? 'asymmetric' : 'symmetric';
+        } else {
+          category = 'unknown';
+        }
       }
+
+      results.push({ algo: algoName, timelineKey, category });
     }
   }
 
@@ -478,7 +531,7 @@ function calculateQuantumScore(libraries, classifications) {
   // Score by individual algorithm classifications, not library count.
   // A project with 5 symmetric + 1 asymmetric algorithm is mostly ready, not 0%.
   const safe = classifications.filter(
-    c => c.category !== 'asymmetric' || c.category === 'pqc'
+    c => c.category !== 'asymmetric'
   ).length;
   const vulnerable = classifications.filter(
     c => c.category === 'asymmetric'
@@ -605,7 +658,107 @@ function buildThreatTimelines(classifications) {
 // Main entry point
 // ---------------------------------------------------------------------------
 
-export function analyzeOffline(libraries, dataProfile = null) {
+// ---------------------------------------------------------------------------
+// Confidence calculation
+// ---------------------------------------------------------------------------
+
+function calculateConfidence(libraries, classifications, scanMeta = {}) {
+  const algorithmsFound = classifications.length;
+  const languagesScanned = scanMeta.languagesDetected?.length || 0;
+  const filesScanned = scanMeta.filesScanned || 0;
+  const manifestsFound = scanMeta.manifestsFound?.length || 0;
+
+  let score = 0;
+
+  // Algorithms contribute up to 40 points
+  if (algorithmsFound >= 10) score += 40;
+  else if (algorithmsFound >= 5) score += 30;
+  else if (algorithmsFound >= 3) score += 20;
+  else if (algorithmsFound >= 1) score += 10;
+
+  // Manifests contribute up to 25 points
+  if (manifestsFound >= 3) score += 25;
+  else if (manifestsFound >= 2) score += 20;
+  else if (manifestsFound >= 1) score += 15;
+
+  // Files scanned contribute up to 20 points
+  if (filesScanned >= 100) score += 20;
+  else if (filesScanned >= 50) score += 15;
+  else if (filesScanned >= 20) score += 10;
+  else if (filesScanned >= 5) score += 5;
+
+  // Languages contribute up to 15 points
+  if (languagesScanned >= 3) score += 15;
+  else if (languagesScanned >= 2) score += 10;
+  else if (languagesScanned >= 1) score += 5;
+
+  let level;
+  if (score >= 70) level = 'high';
+  else if (score >= 40) level = 'medium';
+  else level = 'low';
+
+  const parts = [];
+  if (algorithmsFound > 0) parts.push(`${algorithmsFound} algorithms found`);
+  if (languagesScanned > 0) parts.push(`${languagesScanned} languages`);
+  if (filesScanned > 0) parts.push(`${filesScanned} files`);
+  if (manifestsFound > 0) parts.push(`${manifestsFound} manifests`);
+
+  return {
+    level,
+    score,
+    reason: parts.join(', ') || 'no data scanned',
+    algorithmsFound,
+    languagesScanned,
+    filesScanned,
+    manifestsFound,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Migration urgency mapping
+// ---------------------------------------------------------------------------
+
+function getMigrationUrgency(riskLevel) {
+  switch (riskLevel) {
+    case 'critical': return 'immediate';
+    case 'high':     return 'high';
+    case 'medium':   return 'medium';
+    case 'low':      return 'low';
+    default:         return 'none';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Risk breakdown
+// ---------------------------------------------------------------------------
+
+function getRiskBreakdown(classifications) {
+  const breakdown = { critical: 0, high: 0, medium: 0, low: 0, none: 0 };
+
+  for (const c of classifications) {
+    // Use algorithm-db for per-algorithm risk if available
+    const dbEntry = lookupAlgorithm(c.algo);
+    if (dbEntry) {
+      const risk = dbEntry.quantumRisk || 'none';
+      if (risk in breakdown) breakdown[risk]++;
+      else breakdown.none++;
+    } else if (c.category === 'pqc') {
+      breakdown.none++;
+    } else if (c.category === 'asymmetric') {
+      breakdown.high++;
+    } else {
+      breakdown.low++;
+    }
+  }
+
+  return breakdown;
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+export function analyzeOffline(libraries, dataProfile = null, scanMeta = {}) {
   const profileKey = dataProfile || 'general';
   const profile = DATA_PROFILES[profileKey] || DATA_PROFILES.general;
 
@@ -622,6 +775,11 @@ export function analyzeOffline(libraries, dataProfile = null) {
   const nextSteps = generateNextSteps(urgency, migrationPlan, sndl);
   const threatTimelines = buildThreatTimelines(classifications);
 
+  // New in v0.2.0
+  const confidence = calculateConfidence(libraries, classifications, scanMeta);
+  const migrationUrgency = getMigrationUrgency(urgency);
+  const riskBreakdown = getRiskBreakdown(classifications);
+
   return {
     generatedAt: new Date().toISOString(),
     analysisMode: 'offline',
@@ -630,7 +788,10 @@ export function analyzeOffline(libraries, dataProfile = null) {
     signatureRecommendations: sigRecs,
     migrationPlan,
     overallUrgency: urgency,
+    migrationUrgency,
     quantumReadinessScore: quantumScore,
+    confidence,
+    riskBreakdown,
     keyFindings: findings,
     nextSteps,
     complianceReferences: complianceRefs,