50c 4.0.0 → 4.1.1

package/lib/pre-publish.js

@@ -1,831 +0,0 @@
-/**
- * 50c Pre-Publish Verification Tool
- * 
- * Thorough 100-point checklist before publishing to:
- * - npm (packages)
- * - GitHub (releases)
- * - arXiv (papers)
- * - Medical journals
- * - Scientific publications
- * 
- * "Ask once, verify everything"
- */
-
-// Verification profiles for different publish targets
-const PROFILES = {
-  npm: {
-    name: 'NPM Package',
-    checks: [
-      // Package basics
-      { id: 'pkg_name', cat: 'metadata', desc: 'Package name valid and available', empirical: true },
-      { id: 'pkg_version', cat: 'metadata', desc: 'Version bumped from npm registry', empirical: true },
-      { id: 'pkg_desc', cat: 'metadata', desc: 'Description clear, no marketing fluff', empirical: false },
-      { id: 'pkg_keywords', cat: 'metadata', desc: 'Keywords relevant and searchable', empirical: false },
-      { id: 'pkg_license', cat: 'metadata', desc: 'LICENSE file exists and valid', empirical: true },
-      { id: 'pkg_repo', cat: 'metadata', desc: 'Repository URL valid and accessible', empirical: true },
-      { id: 'pkg_homepage', cat: 'metadata', desc: 'Homepage URL live and correct', empirical: true },
-      
-      // Code quality
-      { id: 'syntax_valid', cat: 'code', desc: 'All JS/TS files pass syntax check', empirical: true },
-      { id: 'no_console_log', cat: 'code', desc: 'No debug console.log statements', empirical: true },
-      { id: 'no_todo_fixme', cat: 'code', desc: 'No unresolved TODO/FIXME comments', empirical: true },
-      { id: 'no_hardcoded_secrets', cat: 'security', desc: 'No hardcoded API keys/passwords/tokens', empirical: true },
-      { id: 'no_localhost', cat: 'security', desc: 'No localhost/127.0.0.1 in production code', empirical: true },
-      { id: 'deps_secure', cat: 'security', desc: 'No known vulnerabilities in dependencies', empirical: true },
-      
-      // Documentation
-      { id: 'readme_exists', cat: 'docs', desc: 'README.md exists', empirical: true },
-      { id: 'readme_install', cat: 'docs', desc: 'Installation instructions present', empirical: true },
-      { id: 'readme_usage', cat: 'docs', desc: 'Usage examples present', empirical: true },
-      { id: 'readme_links_live', cat: 'docs', desc: 'All README links are live', empirical: true },
-      { id: 'changelog_updated', cat: 'docs', desc: 'CHANGELOG updated for this version', empirical: true },
-      
-      // Build/Test
-      { id: 'tests_pass', cat: 'test', desc: 'All tests pass', empirical: true },
-      { id: 'build_clean', cat: 'test', desc: 'Build completes without warnings', empirical: true },
-      { id: 'entry_point_valid', cat: 'test', desc: 'Main/bin entry points resolve', empirical: true },
-      
-      // Files
-      { id: 'files_included', cat: 'files', desc: 'Only intended files in package', empirical: true },
-      { id: 'no_env_files', cat: 'files', desc: 'No .env files included', empirical: true },
-      { id: 'no_test_files', cat: 'files', desc: 'Test files excluded from package', empirical: true },
-      { id: 'size_reasonable', cat: 'files', desc: 'Package size under 10MB', empirical: true },
-    ]
-  },
-  
-  github: {
-    name: 'GitHub Release',
-    checks: [
-      { id: 'tag_format', cat: 'release', desc: 'Tag follows semver (vX.Y.Z)', empirical: true },
-      { id: 'tag_unique', cat: 'release', desc: 'Tag does not exist yet', empirical: true },
-      { id: 'branch_clean', cat: 'release', desc: 'No uncommitted changes', empirical: true },
-      { id: 'branch_pushed', cat: 'release', desc: 'All commits pushed to remote', empirical: true },
-      { id: 'ci_passing', cat: 'release', desc: 'CI/CD pipeline green', empirical: true },
-      { id: 'release_notes', cat: 'docs', desc: 'Release notes written', empirical: false },
-      { id: 'breaking_changes', cat: 'docs', desc: 'Breaking changes documented', empirical: false },
-      { id: 'migration_guide', cat: 'docs', desc: 'Migration guide if needed', empirical: false },
-      { id: 'no_secrets_in_history', cat: 'security', desc: 'No secrets in git history', empirical: true },
-      { id: 'license_file', cat: 'legal', desc: 'LICENSE file present', empirical: true },
-    ]
-  },
-  
-  arxiv: {
-    name: 'arXiv Paper',
-    checks: [
-      // Compilation
-      { id: 'latex_compiles', cat: 'build', desc: 'LaTeX compiles without errors', empirical: true },
-      { id: 'no_overfull_hbox', cat: 'build', desc: 'No overfull hbox warnings', empirical: true },
-      { id: 'figures_render', cat: 'build', desc: 'All figures render correctly', empirical: true },
-      { id: 'refs_resolve', cat: 'build', desc: 'All references resolve', empirical: true },
-      { id: 'citations_complete', cat: 'build', desc: 'No [?] citation markers', empirical: true },
-      
-      // Content integrity
-      { id: 'abstract_standalone', cat: 'content', desc: 'Abstract is self-contained', empirical: false },
-      { id: 'claims_supported', cat: 'content', desc: 'All claims have citations or proofs', empirical: false },
-      { id: 'math_verified', cat: 'content', desc: 'Mathematical derivations verified', empirical: false },
-      { id: 'no_placeholder', cat: 'content', desc: 'No TODO/TBD/XXX placeholders', empirical: true },
-      { id: 'consistent_notation', cat: 'content', desc: 'Notation consistent throughout', empirical: false },
-      
-      // AI-POWERED VERIFICATION (50c tools)
-      { id: 'math_verified_bcalc', cat: 'ai-verify', desc: '[bCalc] Math expressions validated', empirical: true },
-      { id: 'proofs_verified_genius', cat: 'ai-verify', desc: '[genius+] Proofs checked for gaps', empirical: true },
-      { id: 'claims_validated_search', cat: 'ai-verify', desc: '[web_search] Novelty claims validated', empirical: true },
-      
-      // Reproducibility
-      { id: 'code_available', cat: 'repro', desc: 'Code repository linked', empirical: true },
-      { id: 'data_available', cat: 'repro', desc: 'Dataset accessible or described', empirical: false },
-      { id: 'hyperparams_listed', cat: 'repro', desc: 'All hyperparameters specified', empirical: false },
-      { id: 'compute_resources', cat: 'repro', desc: 'Compute requirements stated', empirical: false },
-      
-      // Ethics
-      { id: 'ethics_statement', cat: 'ethics', desc: 'Ethics statement if applicable', empirical: false },
-      { id: 'limitations_discussed', cat: 'ethics', desc: 'Limitations acknowledged', empirical: false },
-      { id: 'societal_impact', cat: 'ethics', desc: 'Broader impact discussed', empirical: false },
-      
-      // Formatting
-      { id: 'arxiv_format', cat: 'format', desc: 'Follows arXiv formatting guidelines', empirical: true },
-      { id: 'page_limit', cat: 'format', desc: 'Within page limit for category', empirical: true },
-      { id: 'anon_submission', cat: 'format', desc: 'Anonymized if required', empirical: true },
-    ]
-  },
-  
-  medical: {
-    name: 'Medical/Clinical Publication',
-    checks: [
-      // Regulatory
-      { id: 'irb_approval', cat: 'regulatory', desc: 'IRB/Ethics approval documented', empirical: true },
-      { id: 'trial_registration', cat: 'regulatory', desc: 'Trial registered (if applicable)', empirical: true },
-      { id: 'consort_checklist', cat: 'regulatory', desc: 'CONSORT/STROBE checklist completed', empirical: true },
-      { id: 'data_privacy', cat: 'regulatory', desc: 'Patient data de-identified', empirical: true },
-      
-      // Statistical rigor
-      { id: 'sample_size_justified', cat: 'stats', desc: 'Sample size calculation provided', empirical: false },
-      { id: 'stats_methods_appropriate', cat: 'stats', desc: 'Statistical methods appropriate', empirical: false },
-      { id: 'confidence_intervals', cat: 'stats', desc: 'Confidence intervals reported', empirical: true },
-      { id: 'effect_sizes', cat: 'stats', desc: 'Effect sizes reported', empirical: true },
-      { id: 'multiple_comparisons', cat: 'stats', desc: 'Multiple comparisons addressed', empirical: false },
-      
-      // Clinical validity
-      { id: 'endpoints_defined', cat: 'clinical', desc: 'Primary/secondary endpoints defined', empirical: true },
-      { id: 'adverse_events', cat: 'clinical', desc: 'Adverse events reported', empirical: true },
-      { id: 'limitations_stated', cat: 'clinical', desc: 'Study limitations stated', empirical: true },
-      { id: 'generalizability', cat: 'clinical', desc: 'Generalizability discussed', empirical: false },
-      
-      // Conflicts
-      { id: 'coi_disclosed', cat: 'disclosure', desc: 'Conflicts of interest disclosed', empirical: true },
-      { id: 'funding_disclosed', cat: 'disclosure', desc: 'Funding sources disclosed', empirical: true },
-      { id: 'author_contributions', cat: 'disclosure', desc: 'Author contributions listed', empirical: true },
-    ]
-  },
-  
-  science: {
-    name: 'Scientific Publication',
-    checks: [
-      // Methodology
-      { id: 'methods_reproducible', cat: 'methods', desc: 'Methods described in reproducible detail', empirical: false },
-      { id: 'controls_appropriate', cat: 'methods', desc: 'Control experiments appropriate', empirical: false },
-      { id: 'sample_size_adequate', cat: 'methods', desc: 'Sample size adequate for claims', empirical: false },
-      { id: 'blinding_described', cat: 'methods', desc: 'Blinding procedures described', empirical: false },
-      
-      // AI-POWERED VERIFICATION (50c tools)
-      { id: 'methodology_hints', cat: 'ai-verify', desc: '[hints+] Methodology weaknesses', empirical: true },
-      { id: 'claims_validated_search', cat: 'ai-verify', desc: '[web_search] Prior work check', empirical: true },
-      
-      // Data integrity
-      { id: 'raw_data_available', cat: 'data', desc: 'Raw data available/accessible', empirical: true },
-      { id: 'data_processing_documented', cat: 'data', desc: 'Data processing steps documented', empirical: false },
-      { id: 'outliers_handled', cat: 'data', desc: 'Outlier handling described', empirical: false },
-      { id: 'error_bars_explained', cat: 'data', desc: 'Error bars/uncertainty quantified', empirical: true },
-      
-      // Claims
-      { id: 'claims_match_evidence', cat: 'claims', desc: 'Claims proportional to evidence', empirical: false },
-      { id: 'alternative_explanations', cat: 'claims', desc: 'Alternative explanations addressed', empirical: false },
-      { id: 'no_overclaiming', cat: 'claims', desc: 'No overclaiming in abstract/title', empirical: false },
-      { id: 'novelty_justified', cat: 'claims', desc: 'Novelty claims justified vs prior work', empirical: false },
-      
-      // Figures
-      { id: 'figures_clear', cat: 'figures', desc: 'Figures clear at print resolution', empirical: true },
-      { id: 'axes_labeled', cat: 'figures', desc: 'All axes labeled with units', empirical: true },
-      { id: 'legends_complete', cat: 'figures', desc: 'Figure legends self-contained', empirical: false },
-      { id: 'color_accessible', cat: 'figures', desc: 'Color-blind accessible', empirical: true },
-    ]
-  },
-  
-  math: {
-    name: 'Mathematics Paper',
-    checks: [
-      // Proofs
-      { id: 'proofs_complete', cat: 'proofs', desc: 'All proofs complete (no gaps)', empirical: false },
-      { id: 'proofs_verified', cat: 'proofs', desc: 'Proofs independently verified', empirical: false },
-      { id: 'edge_cases_handled', cat: 'proofs', desc: 'Edge cases and degeneracies handled', empirical: false },
-      { id: 'assumptions_explicit', cat: 'proofs', desc: 'All assumptions explicitly stated', empirical: false },
-      
-      // AI-POWERED VERIFICATION (50c tools)
-      { id: 'math_verified_bcalc', cat: 'ai-verify', desc: '[bCalc] Mathematical verification', empirical: true },
-      { id: 'proofs_verified_genius', cat: 'ai-verify', desc: '[genius+] Proof gap detection', empirical: true },
-      { id: 'claims_validated_search', cat: 'ai-verify', desc: '[web_search] Novelty validation', empirical: true },
-      
-      // Definitions
-      { id: 'terms_defined', cat: 'defs', desc: 'All terms defined before use', empirical: true },
-      { id: 'notation_consistent', cat: 'defs', desc: 'Notation consistent with literature', empirical: false },
-      { id: 'numbering_correct', cat: 'defs', desc: 'Theorem/lemma numbering correct', empirical: true },
-      
-      // Examples
-      { id: 'examples_verify_claims', cat: 'examples', desc: 'Examples verify main theorems', empirical: false },
-      { id: 'counterexamples_checked', cat: 'examples', desc: 'Potential counterexamples addressed', empirical: false },
-      { id: 'computational_verified', cat: 'examples', desc: 'Computational results verified', empirical: true },
-      
-      // Literature
-      { id: 'prior_work_cited', cat: 'refs', desc: 'Prior work appropriately cited', empirical: false },
-      { id: 'no_overclaiming_novelty', cat: 'refs', desc: 'Novelty claims accurate', empirical: false },
-      { id: 'comparison_to_existing', cat: 'refs', desc: 'Results compared to existing bounds', empirical: false },
-    ]
-  }
-};
-
-// 50c API integration for AI-powered verification
-async function call50cTool(tool, params, timeout = 60000) {
-  const fs = require('fs');
-  const path = require('path');
-  
-  // Try to get API key from mcp.json
-  let apiKey = process.env.FIFTYC_API_KEY;
-  if (!apiKey) {
-    try {
-      const homeDir = process.env.USERPROFILE || process.env.HOME;
-      const mcpPath = path.join(homeDir, '.verdent', 'mcp.json');
-      if (fs.existsSync(mcpPath)) {
-        const mcp = JSON.parse(fs.readFileSync(mcpPath, 'utf8'));
-        const server = mcp.mcpServers?.['50c'] || mcp.mcpServers?.['50c-ai'];
-        apiKey = server?.env?.FIFTYC_API_KEY;
-      }
-    } catch (e) {}
-  }
-  
-  if (!apiKey) {
-    return { error: 'No 50c API key configured' };
-  }
-  
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    
-    const res = await fetch('https://api.50c.ai/mcp', {
-      method: 'POST',
-      headers: { 
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        method: 'tools/call',
-        params: { name: tool, arguments: params },
-        id: Date.now()
-      }),
-      signal: controller.signal
-    });
-    
-    clearTimeout(timeoutId);
-    const data = await res.json();
-    return data.result?.content?.[0]?.text || data.result || data;
-  } catch (e) {
-    return { error: e.message };
-  }
-}
-
-// Empirical check implementations
-const EMPIRICAL_CHECKS = {
-  // NPM checks
-  async pkg_version(ctx) {
-    const pkg = ctx.packageJson;
-    if (!pkg) return { pass: false, msg: 'No package.json found' };
-    
-    try {
-      const res = await fetch(`https://registry.npmjs.org/${pkg.name}/latest`);
-      if (res.status === 404) return { pass: true, msg: 'New package (not on npm yet)' };
-      const data = await res.json();
-      const npmVersion = data.version;
-      const localVersion = pkg.version;
-      
-      if (localVersion === npmVersion) {
-        return { pass: false, msg: `Version ${localVersion} already published. Bump required.` };
-      }
-      
-      // Check if local is higher
-      const [lMaj, lMin, lPatch] = localVersion.split('.').map(Number);
-      const [nMaj, nMin, nPatch] = npmVersion.split('.').map(Number);
-      
-      if (lMaj > nMaj || (lMaj === nMaj && lMin > nMin) || (lMaj === nMaj && lMin === nMin && lPatch > nPatch)) {
-        return { pass: true, msg: `${localVersion} > ${npmVersion} (npm)` };
-      }
-      
-      return { pass: false, msg: `Local ${localVersion} <= npm ${npmVersion}` };
-    } catch (e) {
-      return { pass: false, msg: `npm check failed: ${e.message}` };
-    }
-  },
-  
-  async pkg_homepage(ctx) {
-    const url = ctx.packageJson?.homepage;
-    if (!url) return { pass: false, msg: 'No homepage in package.json' };
-    
-    try {
-      const res = await fetch(url, { method: 'HEAD' });
-      return res.ok 
-        ? { pass: true, msg: `${url} is live` }
-        : { pass: false, msg: `${url} returned ${res.status}` };
-    } catch (e) {
-      return { pass: false, msg: `${url} unreachable: ${e.message}` };
-    }
-  },
-  
-  async pkg_repo(ctx) {
-    const repo = ctx.packageJson?.repository?.url || ctx.packageJson?.repository;
-    if (!repo) return { pass: null, msg: 'No repository URL (optional)' };
-    
-    // Convert git URL to HTTPS for checking
-    let checkUrl = String(repo).replace(/^git\+/, '').replace(/\.git$/, '');
-    if (checkUrl.startsWith('git://')) {
-      checkUrl = checkUrl.replace('git://', 'https://');
-    }
-    
-    try {
-      const res = await fetch(checkUrl, { method: 'HEAD' });
-      return res.ok
-        ? { pass: true, msg: `${checkUrl} accessible` }
-        : { pass: false, msg: `${checkUrl} returned ${res.status}` };
-    } catch (e) {
-      return { pass: false, msg: `${checkUrl} unreachable` };
-    }
-  },
-  
-  async syntax_valid(ctx) {
-    const { execSync } = require('child_process');
-    const jsFiles = ctx.files.filter(f => f.endsWith('.js') || f.endsWith('.mjs'));
-    const errors = [];
-    
-    for (const file of jsFiles.slice(0, 20)) { // Limit to 20 files
-      try {
-        execSync(`node -c "${file}"`, { stdio: 'pipe', cwd: ctx.cwd });
-      } catch (e) {
-        errors.push(file);
-      }
-    }
-    
-    return errors.length === 0
-      ? { pass: true, msg: `${jsFiles.length} JS files valid` }
-      : { pass: false, msg: `Syntax errors in: ${errors.join(', ')}` };
-  },
-  
-  async no_hardcoded_secrets(ctx) {
-    const { execSync } = require('child_process');
-    const patterns = [
-      'api[_-]?key\\s*[=:]\\s*["\'][a-zA-Z0-9]{20,}',
-      'password\\s*[=:]\\s*["\'][^"\']{8,}',
-      'secret\\s*[=:]\\s*["\'][a-zA-Z0-9]{20,}',
-      'token\\s*[=:]\\s*["\'][a-zA-Z0-9]{20,}',
-      'AWS[_-]?ACCESS[_-]?KEY',
-      'PRIVATE[_-]?KEY',
-    ];
-    
-    const findings = [];
-    for (const pattern of patterns) {
-      try {
-        const result = execSync(
-          `findstr /R /I /S "${pattern}" *.js *.ts *.json 2>nul`,
-          { cwd: ctx.cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
-        );
-        if (result.trim()) {
-          findings.push(pattern.substring(0, 20) + '...');
-        }
-      } catch (e) {
-        // No matches is good
-      }
-    }
-    
-    return findings.length === 0
-      ? { pass: true, msg: 'No hardcoded secrets detected' }
-      : { pass: false, msg: `Potential secrets: ${findings.join(', ')}` };
-  },
-  
-  async readme_links_live(ctx) {
-    const fs = require('fs');
-    const readmePath = ctx.files.find(f => f.toLowerCase().endsWith('readme.md'));
-    if (!readmePath) return { pass: false, msg: 'No README.md' };
-    
-    const content = fs.readFileSync(readmePath, 'utf8');
-    const urlPattern = /https?:\/\/[^\s\)\"\']+/g;
-    const urls = [...new Set(content.match(urlPattern) || [])];
-    
-    const deadLinks = [];
-    for (const url of urls.slice(0, 10)) { // Check first 10
-      try {
-        const res = await fetch(url, { method: 'HEAD', timeout: 5000 });
-        if (!res.ok) deadLinks.push(url);
-      } catch (e) {
-        deadLinks.push(url);
-      }
-    }
-    
-    return deadLinks.length === 0
-      ? { pass: true, msg: `${urls.length} links verified` }
-      : { pass: false, msg: `Dead links: ${deadLinks.join(', ')}` };
-  },
-  
-  async no_localhost(ctx) {
-    const fs = require('fs');
-    const path = require('path');
-    const findings = [];
-    
-    // File-level exclusions: files whose entire purpose IS a local dev server
-    const LEGIT_LOCAL_FILES = new Set(['pre-publish.js', 'mcp-tv.js', 'invent-ui.js']);
-
-    for (const file of ctx.files.filter(f => /\.(js|ts|json)$/.test(f)).slice(0, 30)) {
-      if (LEGIT_LOCAL_FILES.has(path.basename(file))) continue;
-
-      try {
-        const content = fs.readFileSync(file, 'utf8');
-        if (/localhost|127\.0\.0\.1|0\.0\.0\.0/.test(content)) {
-          const lines = content.split('\n');
-          for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            const trimmed = line.trim();
-            // Exclude legitimate patterns:
-            //   - Comments (// or  *)
-            //   - env-fallback (|| 'localhost')
-            //   - regex/pattern keywords
-            //   - Template-literal dynamic ports (`http://localhost:${port}`)
-            //   - API protocol documentation in help text (POST/GET http://localhost)
-            //   - JSDoc protocol descriptions
-            if (
-              /localhost|127\.0\.0\.1/.test(line)
-              && !trimmed.startsWith('//')
-              && !trimmed.startsWith('*')
-              && !line.includes('||')
-              && !line.includes('regex')
-              && !line.includes('pattern')
-              && !line.includes('${')
-              && !line.includes('POST http')
-              && !line.includes('GET http')
-            ) {
-              findings.push(`${path.basename(file)}:${i+1}`);
-              break;
-            }
-          }
-        }
-      } catch (e) {}
-    }
-    
-    return findings.length === 0
-      ? { pass: true, msg: 'No localhost references' }
-      : { pass: false, msg: `localhost found: ${findings.slice(0,3).join(', ')}` };
-  },
-  
-  async size_reasonable(ctx) {
-    const { execSync } = require('child_process');
-    try {
-      const result = execSync('npm pack --dry-run 2>&1', { cwd: ctx.cwd, encoding: 'utf8' });
-      const sizeMatch = result.match(/total files.*?(\d+(?:\.\d+)?)\s*(kB|MB|B)/i);
-      if (sizeMatch) {
-        let sizeKB = parseFloat(sizeMatch[1]);
-        if (sizeMatch[2].toLowerCase() === 'mb') sizeKB *= 1024;
-        if (sizeMatch[2].toLowerCase() === 'b') sizeKB /= 1024;
-        
-        return sizeKB < 10240 // 10MB limit
-          ? { pass: true, msg: `Package size: ${sizeKB.toFixed(1)} KB` }
-          : { pass: false, msg: `Package too large: ${sizeKB.toFixed(1)} KB (limit 10MB)` };
-      }
-    } catch (e) {}
-    return { pass: null, msg: 'Could not determine package size' };
-  },
-  
-  // arXiv checks
-  async latex_compiles(ctx) {
-    const { execSync } = require('child_process');
-    const texFile = ctx.files.find(f => f.endsWith('.tex') && !f.includes('preamble'));
-    if (!texFile) return { pass: false, msg: 'No .tex file found' };
-    
-    try {
-      execSync(`pdflatex -interaction=nonstopmode "${texFile}"`, { cwd: ctx.cwd, stdio: 'pipe' });
-      return { pass: true, msg: 'LaTeX compiles' };
-    } catch (e) {
-      return { pass: false, msg: 'LaTeX compilation failed' };
-    }
-  },
-  
-  async no_placeholder(ctx) {
-    const fs = require('fs');
-    const findings = [];
-    const patterns = /\b(TODO|FIXME|XXX|TBD|PLACEHOLDER)\b/gi;
-    
-    for (const file of ctx.files.slice(0, 50)) {
-      try {
-        const content = fs.readFileSync(file, 'utf8');
-        const matches = content.match(patterns);
-        if (matches) {
-          findings.push(`${file}: ${matches.length} placeholders`);
-        }
-      } catch (e) {}
-    }
-    
-    return findings.length === 0
-      ? { pass: true, msg: 'No placeholders found' }
-      : { pass: false, msg: findings.slice(0, 3).join('; ') };
-  },
-  
-  // AI-powered math verification using bCalc
-  async math_verified_bcalc(ctx) {
-    const fs = require('fs');
-    const texFiles = ctx.files.filter(f => f.endsWith('.tex'));
-    if (texFiles.length === 0) return { pass: null, msg: 'No .tex files' };
-    
-    // Extract key mathematical claims/equations
-    const content = fs.readFileSync(texFiles[0], 'utf8');
-    const equations = content.match(/\$\$[^$]+\$\$/g) || [];
-    const claims = content.match(/\\begin\{theorem\}[\s\S]*?\\end\{theorem\}/g) || [];
-    
-    if (equations.length === 0 && claims.length === 0) {
-      return { pass: null, msg: 'No equations/theorems found to verify' };
-    }
-    
-    // Sample first theorem or key equation for bCalc verification
-    const sample = claims[0] || equations[0];
-    const cleanSample = sample.replace(/\\[a-z]+\{[^}]*\}/g, '').substring(0, 500);
-    
-    try {
-      const result = await call50cTool('bcalc', {
-        expression: cleanSample,
-        mode: 'verify'
-      }, 30000);
-      
-      if (result.error) {
-        return { pass: null, msg: `bCalc unavailable: ${result.error}` };
-      }
-      
-      // Check if bCalc found issues
-      const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
-      const hasIssues = /error|invalid|incorrect|false/i.test(resultStr);
-      
-      return hasIssues
-        ? { pass: false, msg: `bCalc found issues: ${resultStr.substring(0, 100)}` }
-        : { pass: true, msg: 'bCalc verified mathematical expressions' };
-    } catch (e) {
-      return { pass: null, msg: `bCalc check failed: ${e.message}` };
-    }
-  },
-  
-  // AI-powered proof verification using genius_plus
-  async proofs_verified_genius(ctx) {
-    const fs = require('fs');
-    const texFiles = ctx.files.filter(f => f.endsWith('.tex'));
-    if (texFiles.length === 0) return { pass: null, msg: 'No .tex files' };
-    
-    const content = fs.readFileSync(texFiles[0], 'utf8');
-    
-    // Extract proofs
-    const proofs = content.match(/\\begin\{proof\}[\s\S]*?\\end\{proof\}/g) || [];
-    if (proofs.length === 0) {
-      return { pass: null, msg: 'No formal proofs found' };
-    }
-    
-    // Take abstract + first proof for genius+ analysis
-    const abstractMatch = content.match(/\\begin\{abstract\}([\s\S]*?)\\end\{abstract\}/);
-    const abstract = abstractMatch ? abstractMatch[1] : '';
-    const firstProof = proofs[0].substring(0, 1000);
-    
-    try {
-      const result = await call50cTool('genius_plus', {
-        problem: `Verify this mathematical proof for logical gaps, unstated assumptions, or errors:\n\nContext: ${abstract.substring(0, 300)}\n\nProof:\n${firstProof}`
-      }, 90000);
-      
-      if (result.error) {
-        return { pass: null, msg: `genius+ unavailable: ${result.error}` };
-      }
-      
-      const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
-      
-      // Check for red flags
-      const redFlags = /gap|flaw|error|incorrect|missing|invalid|contradiction/i.test(resultStr);
-      
-      return redFlags
-        ? { pass: false, msg: `genius+ found issues: ${resultStr.substring(0, 150)}...` }
-        : { pass: true, msg: 'genius+ verified proof structure' };
-    } catch (e) {
-      return { pass: null, msg: `genius+ check failed: ${e.message}` };
-    }
-  },
-  
-  // AI-powered claim validation using web_search
-  async claims_validated_search(ctx) {
-    const fs = require('fs');
-    const texFiles = ctx.files.filter(f => f.endsWith('.tex'));
-    if (texFiles.length === 0) return { pass: null, msg: 'No .tex files' };
-    
-    const content = fs.readFileSync(texFiles[0], 'utf8');
-    
-    // Extract title and key claims
-    const titleMatch = content.match(/\\title\{([^}]+)\}/);
-    const title = titleMatch ? titleMatch[1] : '';
-    
-    // Find novelty claims
-    const noveltyPatterns = /first|novel|new|unprecedented|breakthrough|improve|better than/gi;
-    const hasNoveltyClaims = noveltyPatterns.test(content);
-    
-    if (!hasNoveltyClaims || !title) {
-      return { pass: null, msg: 'No novelty claims to validate' };
-    }
-    
-    try {
-      const result = await call50cTool('web_search', {
-        query: title.replace(/[\\{}]/g, ' ').trim(),
-        max_results: 5
-      }, 30000);
-      
-      if (result.error) {
-        return { pass: null, msg: `web_search unavailable: ${result.error}` };
-      }
-      
-      const resultStr = typeof result === 'string' ? result : JSON.stringify(result);
-      
-      // Check if similar work already exists
-      const duplicateSignals = /already|published|existing|prior art|known result/i.test(resultStr);
-      
-      return duplicateSignals
-        ? { pass: false, msg: `Potential prior work found - verify novelty: ${resultStr.substring(0, 100)}` }
-        : { pass: true, msg: 'No obvious conflicting prior work found' };
-    } catch (e) {
-      return { pass: null, msg: `Search check failed: ${e.message}` };
-    }
-  },
-  
-  // Science-specific: validate methodology with hints+
-  async methodology_hints(ctx) {
-    const fs = require('fs');
-    const files = ctx.files.filter(f => /\.(tex|md|txt)$/.test(f));
-    if (files.length === 0) return { pass: null, msg: 'No text files' };
-    
-    // Read first file
-    const content = fs.readFileSync(files[0], 'utf8').substring(0, 2000);
-    
-    // Look for methods section
-    const methodsMatch = content.match(/method|experiment|procedure|approach/i);
-    if (!methodsMatch) {
-      return { pass: null, msg: 'No methods section detected' };
-    }
-    
-    try {
-      const result = await call50cTool('hints_plus', {
-        query: `Evaluate scientific methodology for weaknesses: ${content.substring(0, 1000)}`
-      }, 30000);
-      
-      if (result.error) {
-        return { pass: null, msg: `hints+ unavailable: ${result.error}` };
-      }
-      
-      // hints_plus returns brutal hints - just report them
-      return { 
-        pass: null, 
-        msg: `hints+: ${typeof result === 'string' ? result.substring(0, 200) : JSON.stringify(result).substring(0, 200)}` 
-      };
-    } catch (e) {
-      return { pass: null, msg: `hints+ check failed: ${e.message}` };
-    }
-  },
-};
-
-/**
- * Main verification function
- */
-async function verify(profile, options = {}) {
-  const config = PROFILES[profile];
-  if (!config) {
-    return { error: `Unknown profile: ${profile}. Available: ${Object.keys(PROFILES).join(', ')}` };
-  }
-  
-  const fs = require('fs');
-  const path = require('path');
-  const cwd = options.cwd || process.cwd();
-  
-  // Build context
-  const ctx = {
-    cwd,
-    profile,
-    files: [],
-    packageJson: null,
-  };
-  
-  // Gather files
-  try {
-    const walk = (dir, depth = 0) => {
-      if (depth > 3) return; // Max depth
-      const items = fs.readdirSync(dir);
-      for (const item of items) {
-        if (item.startsWith('.') || item === 'node_modules') continue;
-        const full = path.join(dir, item);
-        const stat = fs.statSync(full);
-        if (stat.isDirectory()) {
-          walk(full, depth + 1);
-        } else {
-          ctx.files.push(full);
-        }
-      }
-    };
-    walk(cwd);
-  } catch (e) {}
-  
-  // Load package.json if exists
-  try {
-    const pkgPath = path.join(cwd, 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      ctx.packageJson = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    }
-  } catch (e) {}
-  
-  // Run checks
-  const results = {
-    profile: config.name,
-    timestamp: new Date().toISOString(),
-    summary: { pass: 0, fail: 0, skip: 0, manual: 0 },
-    checks: [],
-    ready: false,
-  };
-  
-  for (const check of config.checks) {
-    const result = { ...check, status: null, msg: '' };
-    
-    if (check.empirical && EMPIRICAL_CHECKS[check.id]) {
-      try {
-        const r = await EMPIRICAL_CHECKS[check.id](ctx);
-        result.status = r.pass ? 'PASS' : (r.pass === false ? 'FAIL' : 'SKIP');
-        result.msg = r.msg;
-      } catch (e) {
-        result.status = 'SKIP';
-        result.msg = `Error: ${e.message}`;
-      }
-    } else if (check.empirical) {
-      result.status = 'SKIP';
-      result.msg = 'Check not implemented';
-    } else {
-      result.status = 'MANUAL';
-      result.msg = 'Requires manual review';
-    }
-    
-    results.checks.push(result);
-    
-    if (result.status === 'PASS') results.summary.pass++;
-    else if (result.status === 'FAIL') results.summary.fail++;
-    else if (result.status === 'SKIP') results.summary.skip++;
-    else results.summary.manual++;
-  }
-  
-  results.ready = results.summary.fail === 0;
-  results.score = Math.round((results.summary.pass / (results.summary.pass + results.summary.fail + results.summary.manual)) * 100);
-  
-  return results;
-}
-
-/**
- * Generate verification receipt as Markdown
- */
-function generateReceipt(results, options = {}) {
-  const lines = [
-    '# 50c Pre-Publish Verification Receipt',
-    '',
-    `**Generated:** ${results.timestamp}`,
-    `**Profile:** ${results.profile}`,
-    `**Directory:** ${options.cwd || 'N/A'}`,
-    `**Verdict:** ${results.ready ? '✅ READY TO PUBLISH' : '❌ NOT READY - FIX ISSUES'}`,
-    '',
-    '---',
-    '',
-    '## Summary',
-    '',
-    '| Metric | Count |',
-    '|--------|-------|',
-    `| Pass | ${results.summary.pass} |`,
-    `| Fail | ${results.summary.fail} |`,
-    `| Skip | ${results.summary.skip} |`,
-    `| Manual | ${results.summary.manual} |`,
-    `| **Score** | **${results.score}/100** |`,
-    '',
-    '---',
-    '',
-    '## Detailed Results',
-    '',
-  ];
-  
-  // Group by category
-  const byCategory = {};
-  for (const check of results.checks) {
-    if (!byCategory[check.cat]) byCategory[check.cat] = [];
-    byCategory[check.cat].push(check);
-  }
-  
-  for (const [cat, checks] of Object.entries(byCategory)) {
-    lines.push(`### ${cat.toUpperCase()}`);
-    lines.push('');
-    lines.push('| Status | Check | Message |');
-    lines.push('|--------|-------|---------|');
-    for (const c of checks) {
-      const icon = c.status === 'PASS' ? '✅' : c.status === 'FAIL' ? '❌' : c.status === 'SKIP' ? '⏭️' : '👁️';
-      lines.push(`| ${icon} ${c.status} | ${c.desc} | ${(c.msg || '').substring(0, 50)} |`);
-    }
-    lines.push('');
-  }
-  
-  // Cost estimate
-  const aiChecks = results.checks.filter(c => c.cat === 'ai-verify' && c.status !== 'SKIP');
-  if (aiChecks.length > 0) {
-    lines.push('---');
-    lines.push('');
-    lines.push('## AI Verification Cost');
-    lines.push('');
-    lines.push('| Tool | Est. Cost |');
-    lines.push('|------|-----------|');
-    for (const c of aiChecks) {
-      const cost = c.id.includes('bcalc') ? '$0.15' : 
-                   c.id.includes('genius') ? '$0.65' : 
-                   c.id.includes('hints') ? '$0.10' : 'FREE';
-      lines.push(`| ${c.id} | ${cost} |`);
-    }
-    lines.push('');
-  }
-  
-  lines.push('---');
-  lines.push('');
-  lines.push('*Generated by 50c Pre-Publish Verification Tool*');
-  lines.push('*AI verification does not replace peer review*');
-  
-  return lines.join('\n');
-}
-
-/**
- * Full verification with receipt generation
- */
-async function verifyWithReceipt(profile, options = {}) {
-  const results = await verify(profile, options);
-  const receipt = generateReceipt(results, options);
-  return { ...results, receipt };
-}
-
-module.exports = { verify, verifyWithReceipt, generateReceipt, PROFILES, EMPIRICAL_CHECKS, call50cTool };