@nerviq/cli 1.20.0 → 1.21.0

package/src/synergy/compensation.js

@@ -1,137 +1,137 @@
-/**
- * S4. Strength/Weakness Compensation
- *
- * Identifies where platforms complement each other and recommends
- * platform additions to fill coverage gaps.
- */
-
-const { PLATFORM_CAPABILITIES, CAPABILITY_LABELS: AREA_LABELS } = require('../shared/capabilities');
-
-const WEAKNESS_THRESHOLD = 3;
-const STRENGTH_THRESHOLD = 4;
-
-/**
- * Analyze where platforms compensate for each other's weaknesses.
- *
- * @param {string[]} activePlatforms - Currently active platforms
- * @param {Object} [platformAudits] - Optional audit results per platform
- * @returns {Object} Compensation analysis
- */
-function analyzeCompensation(activePlatforms, platformAudits) {
-  const platforms = (activePlatforms || []).filter(p => PLATFORM_CAPABILITIES[p]);
-  const compensations = [];
-  const uncoveredGaps = [];
-
-  // Gather all capability areas across active platforms
-  const allAreas = new Set();
-  for (const platform of platforms) {
-    for (const area of Object.keys(PLATFORM_CAPABILITIES[platform])) {
-      allAreas.add(area);
-    }
-  }
-
-  // For each platform, find weaknesses and check if another compensates
-  for (const platform of platforms) {
-    const caps = PLATFORM_CAPABILITIES[platform];
-
-    for (const area of allAreas) {
-      const score = caps[area] || 0;
-      if (score >= WEAKNESS_THRESHOLD) continue;
-
-      // This is a weakness — look for compensation
-      let bestCompensator = null;
-
-      for (const other of platforms) {
-        if (other === platform) continue;
-        const otherScore = (PLATFORM_CAPABILITIES[other] || {})[area] || 0;
-        if (otherScore >= STRENGTH_THRESHOLD) {
-          if (!bestCompensator || otherScore > bestCompensator.score) {
-            bestCompensator = { platform: other, area, score: otherScore };
-          }
-        }
-      }
-
-      if (bestCompensator) {
-        compensations.push({
-          weakness: { platform, area, score, label: AREA_LABELS[area] || area },
-          compensatedBy: {
-            platform: bestCompensator.platform,
-            area: bestCompensator.area,
-            score: bestCompensator.score,
-            label: AREA_LABELS[area] || area,
-          },
-          netBenefit: bestCompensator.score - score,
-        });
-      } else {
-        uncoveredGaps.push({
-          area,
-          label: AREA_LABELS[area] || area,
-          weakPlatforms: [{ platform, score }],
-        });
-      }
-    }
-  }
-
-  // Deduplicate uncovered gaps by area
-  const gapsByArea = {};
-  for (const gap of uncoveredGaps) {
-    if (!gapsByArea[gap.area]) {
-      gapsByArea[gap.area] = { area: gap.area, label: gap.label, weakPlatforms: [] };
-    }
-    gapsByArea[gap.area].weakPlatforms.push(...gap.weakPlatforms);
-  }
-  const dedupedGaps = Object.values(gapsByArea);
-
-  // Recommend platform additions that would fill gaps
-  const inactivePlatforms = Object.keys(PLATFORM_CAPABILITIES).filter(
-    p => !platforms.includes(p)
-  );
-  const recommendedAdditions = [];
-
-  for (const candidate of inactivePlatforms) {
-    const candidateCaps = PLATFORM_CAPABILITIES[candidate];
-    const wouldCover = [];
-    let estimatedBenefit = 0;
-
-    for (const gap of dedupedGaps) {
-      const candidateScore = candidateCaps[gap.area] || 0;
-      if (candidateScore >= STRENGTH_THRESHOLD) {
-        wouldCover.push({
-          area: gap.area,
-          label: gap.label,
-          score: candidateScore,
-        });
-        estimatedBenefit += candidateScore;
-      }
-    }
-
-    if (wouldCover.length > 0) {
-      recommendedAdditions.push({
-        platform: candidate,
-        wouldCover,
-        estimatedBenefit,
-      });
-    }
-  }
-
-  recommendedAdditions.sort((a, b) => b.estimatedBenefit - a.estimatedBenefit);
-
-  return {
-    compensations,
-    uncoveredGaps: dedupedGaps,
-    recommendedAdditions,
-  };
-}
-
-/**
- * Get areas not well covered by any active platform.
- *
- * @param {string[]} activePlatforms - Currently active platforms
- * @returns {Object[]} Uncovered gap areas
- */
-function getUncoveredGaps(activePlatforms) {
-  const result = analyzeCompensation(activePlatforms);
-  return result.uncoveredGaps;
-}
-
-module.exports = { analyzeCompensation, getUncoveredGaps };
+/**
+ * S4. Strength/Weakness Compensation
+ *
+ * Identifies where platforms complement each other and recommends
+ * platform additions to fill coverage gaps.
+ */
+
+const { PLATFORM_CAPABILITIES, CAPABILITY_LABELS: AREA_LABELS } = require('../shared/capabilities');
+
+const WEAKNESS_THRESHOLD = 3;
+const STRENGTH_THRESHOLD = 4;
+
+/**
+ * Analyze where platforms compensate for each other's weaknesses.
+ *
+ * @param {string[]} activePlatforms - Currently active platforms
+ * @param {Object} [platformAudits] - Optional audit results per platform
+ * @returns {Object} Compensation analysis
+ */
+function analyzeCompensation(activePlatforms, platformAudits) {
+  const platforms = (activePlatforms || []).filter(p => PLATFORM_CAPABILITIES[p]);
+  const compensations = [];
+  const uncoveredGaps = [];
+
+  // Gather all capability areas across active platforms
+  const allAreas = new Set();
+  for (const platform of platforms) {
+    for (const area of Object.keys(PLATFORM_CAPABILITIES[platform])) {
+      allAreas.add(area);
+    }
+  }
+
+  // For each platform, find weaknesses and check if another compensates
+  for (const platform of platforms) {
+    const caps = PLATFORM_CAPABILITIES[platform];
+
+    for (const area of allAreas) {
+      const score = caps[area] || 0;
+      if (score >= WEAKNESS_THRESHOLD) continue;
+
+      // This is a weakness — look for compensation
+      let bestCompensator = null;
+
+      for (const other of platforms) {
+        if (other === platform) continue;
+        const otherScore = (PLATFORM_CAPABILITIES[other] || {})[area] || 0;
+        if (otherScore >= STRENGTH_THRESHOLD) {
+          if (!bestCompensator || otherScore > bestCompensator.score) {
+            bestCompensator = { platform: other, area, score: otherScore };
+          }
+        }
+      }
+
+      if (bestCompensator) {
+        compensations.push({
+          weakness: { platform, area, score, label: AREA_LABELS[area] || area },
+          compensatedBy: {
+            platform: bestCompensator.platform,
+            area: bestCompensator.area,
+            score: bestCompensator.score,
+            label: AREA_LABELS[area] || area,
+          },
+          netBenefit: bestCompensator.score - score,
+        });
+      } else {
+        uncoveredGaps.push({
+          area,
+          label: AREA_LABELS[area] || area,
+          weakPlatforms: [{ platform, score }],
+        });
+      }
+    }
+  }
+
+  // Deduplicate uncovered gaps by area
+  const gapsByArea = {};
+  for (const gap of uncoveredGaps) {
+    if (!gapsByArea[gap.area]) {
+      gapsByArea[gap.area] = { area: gap.area, label: gap.label, weakPlatforms: [] };
+    }
+    gapsByArea[gap.area].weakPlatforms.push(...gap.weakPlatforms);
+  }
+  const dedupedGaps = Object.values(gapsByArea);
+
+  // Recommend platform additions that would fill gaps
+  const inactivePlatforms = Object.keys(PLATFORM_CAPABILITIES).filter(
+    p => !platforms.includes(p)
+  );
+  const recommendedAdditions = [];
+
+  for (const candidate of inactivePlatforms) {
+    const candidateCaps = PLATFORM_CAPABILITIES[candidate];
+    const wouldCover = [];
+    let estimatedBenefit = 0;
+
+    for (const gap of dedupedGaps) {
+      const candidateScore = candidateCaps[gap.area] || 0;
+      if (candidateScore >= STRENGTH_THRESHOLD) {
+        wouldCover.push({
+          area: gap.area,
+          label: gap.label,
+          score: candidateScore,
+        });
+        estimatedBenefit += candidateScore;
+      }
+    }
+
+    if (wouldCover.length > 0) {
+      recommendedAdditions.push({
+        platform: candidate,
+        wouldCover,
+        estimatedBenefit,
+      });
+    }
+  }
+
+  recommendedAdditions.sort((a, b) => b.estimatedBenefit - a.estimatedBenefit);
+
+  return {
+    compensations,
+    uncoveredGaps: dedupedGaps,
+    recommendedAdditions,
+  };
+}
+
+/**
+ * Get areas not well covered by any active platform.
+ *
+ * @param {string[]} activePlatforms - Currently active platforms
+ * @returns {Object[]} Uncovered gap areas
+ */
+function getUncoveredGaps(activePlatforms) {
+  const result = analyzeCompensation(activePlatforms);
+  return result.uncoveredGaps;
+}
+
+module.exports = { analyzeCompensation, getUncoveredGaps };

package/src/synergy/evidence.js

@@ -1,193 +1,193 @@
-/**
- * S3. Compound Evidence System
- *
- * Combines audit findings from multiple platforms for stronger insights.
- * Cross-validates findings and calculates compound amplification scores.
- */
-
-/**
- * Normalize a finding key across platforms.
- * Different platforms may name the same concept differently.
- */
-function normalizeFindingKey(finding) {
-  // Use the technique key or a composite of category+name
-  return finding.key || `${finding.category || 'unknown'}:${finding.name || 'unnamed'}`;
-}
-
-/**
- * Group findings by their normalized concept.
- */
-function groupByConcept(platformAudits) {
-  const concepts = {};
-
-  for (const [platform, auditResult] of Object.entries(platformAudits)) {
-    if (!auditResult || !auditResult.results) continue;
-
-    for (const finding of auditResult.results) {
-      const key = normalizeFindingKey(finding);
-      if (!concepts[key]) {
-        concepts[key] = {
-          key,
-          name: finding.name,
-          category: finding.category,
-          impact: finding.impact,
-          platforms: {},
-        };
-      }
-      concepts[key].platforms[platform] = {
-        passed: finding.passed,
-        fix: finding.fix,
-      };
-    }
-  }
-
-  return concepts;
-}
-
-/**
- * Combine audit findings from multiple platforms for stronger insights.
- *
- * @param {Object} platformAudits - { claude: auditResult, codex: auditResult, ... }
- * @returns {Object} Compound audit result with cross-validation and amplification
- */
-function compoundAudit(platformAudits) {
-  const platforms = Object.keys(platformAudits).filter(
-    p => platformAudits[p] && platformAudits[p].results
-  );
-
-  if (platforms.length === 0) {
-    return {
-      compoundScore: 0,
-      bestSingleScore: 0,
-      amplification: 0,
-      totalFindings: 0,
-      crossValidated: [],
-      platformUnique: {},
-      coverageMap: {},
-    };
-  }
-
-  const concepts = groupByConcept(platformAudits);
-  const crossValidated = [];
-  const platformUnique = {};
-  const coverageMap = {};
-
-  for (const platform of platforms) {
-    platformUnique[platform] = [];
-    coverageMap[platform] = { found: 0, unique: 0, shared: 0 };
-  }
-
-  // Analyze each concept across platforms
-  for (const [key, concept] of Object.entries(concepts)) {
-    const involvedPlatforms = Object.keys(concept.platforms);
-    const failedOn = involvedPlatforms.filter(p => concept.platforms[p].passed === false);
-    const passedOn = involvedPlatforms.filter(p => concept.platforms[p].passed === true);
-
-    // Track coverage
-    for (const p of involvedPlatforms) {
-      coverageMap[p].found++;
-    }
-
-    if (involvedPlatforms.length >= 2) {
-      // Cross-validated finding
-      for (const p of involvedPlatforms) {
-        coverageMap[p].shared++;
-      }
-
-      if (failedOn.length >= 2) {
-        crossValidated.push({
-          key,
-          name: concept.name,
-          category: concept.category,
-          impact: concept.impact,
-          failedOn,
-          passedOn,
-          confidence: Math.min(1, 0.5 + (failedOn.length * 0.15)),
-          verdict: failedOn.length === involvedPlatforms.length
-            ? 'universal-gap'
-            : 'partial-gap',
-        });
-      } else if (passedOn.length >= 2) {
-        crossValidated.push({
-          key,
-          name: concept.name,
-          category: concept.category,
-          impact: concept.impact,
-          failedOn,
-          passedOn,
-          confidence: Math.min(1, 0.5 + (passedOn.length * 0.15)),
-          verdict: 'cross-validated-pass',
-        });
-      }
-    } else {
-      // Platform-unique finding
-      const platform = involvedPlatforms[0];
-      coverageMap[platform].unique++;
-      platformUnique[platform].push({
-        key,
-        name: concept.name,
-        category: concept.category,
-        impact: concept.impact,
-        passed: concept.platforms[platform].passed,
-        fix: concept.platforms[platform].fix,
-      });
-    }
-  }
-
-  // Calculate scores
-  const singleScores = platforms.map(p => platformAudits[p].score || 0);
-  const bestSingleScore = Math.max(...singleScores);
-
-  // Compound score = best single + bonus from cross-validation + bonus from unique coverage
-  const crossValidationBonus = crossValidated
-    .filter(cv => cv.verdict === 'cross-validated-pass')
-    .length * 0.5;
-  const uniqueCoverageBonus = Object.values(platformUnique)
-    .reduce((sum, findings) => sum + findings.filter(f => f.passed).length, 0) * 0.3;
-  const totalUniqueFindings = Object.keys(concepts).length;
-
-  const compoundScore = Math.round(
-    Math.min(150, bestSingleScore + crossValidationBonus + uniqueCoverageBonus)
-  );
-
-  return {
-    compoundScore,
-    bestSingleScore,
-    amplification: compoundScore - bestSingleScore,
-    totalFindings: totalUniqueFindings,
-    crossValidated,
-    platformUnique,
-    coverageMap,
-  };
-}
-
-/**
- * Calculate the amplification factor from combining multiple platforms.
- *
- * @param {Object} platformAudits - Per-platform audit results
- * @returns {Object} Amplification metrics
- */
-function calculateAmplification(platformAudits) {
-  const result = compoundAudit(platformAudits);
-  const platformCount = Object.keys(platformAudits).filter(
-    p => platformAudits[p] && platformAudits[p].results
-  ).length;
-
-  return {
-    amplification: result.amplification,
-    amplificationPercent: result.bestSingleScore > 0
-      ? Math.round((result.amplification / result.bestSingleScore) * 100)
-      : 0,
-    platformCount,
-    crossValidatedCount: result.crossValidated.length,
-    uniqueFindingsPerPlatform: Object.fromEntries(
-      Object.entries(result.platformUnique).map(([p, findings]) => [p, findings.length])
-    ),
-    verdict: result.amplification > 10 ? 'strong-synergy'
-      : result.amplification > 5 ? 'moderate-synergy'
-      : result.amplification > 0 ? 'mild-synergy'
-      : 'no-synergy',
-  };
-}
-
-module.exports = { compoundAudit, calculateAmplification };
+/**
+ * S3. Compound Evidence System
+ *
+ * Combines audit findings from multiple platforms for stronger insights.
+ * Cross-validates findings and calculates compound amplification scores.
+ */
+
+/**
+ * Normalize a finding key across platforms.
+ * Different platforms may name the same concept differently.
+ */
+function normalizeFindingKey(finding) {
+  // Use the technique key or a composite of category+name
+  return finding.key || `${finding.category || 'unknown'}:${finding.name || 'unnamed'}`;
+}
+
+/**
+ * Group findings by their normalized concept.
+ */
+function groupByConcept(platformAudits) {
+  const concepts = {};
+
+  for (const [platform, auditResult] of Object.entries(platformAudits)) {
+    if (!auditResult || !auditResult.results) continue;
+
+    for (const finding of auditResult.results) {
+      const key = normalizeFindingKey(finding);
+      if (!concepts[key]) {
+        concepts[key] = {
+          key,
+          name: finding.name,
+          category: finding.category,
+          impact: finding.impact,
+          platforms: {},
+        };
+      }
+      concepts[key].platforms[platform] = {
+        passed: finding.passed,
+        fix: finding.fix,
+      };
+    }
+  }
+
+  return concepts;
+}
+
+/**
+ * Combine audit findings from multiple platforms for stronger insights.
+ *
+ * @param {Object} platformAudits - { claude: auditResult, codex: auditResult, ... }
+ * @returns {Object} Compound audit result with cross-validation and amplification
+ */
+function compoundAudit(platformAudits) {
+  const platforms = Object.keys(platformAudits).filter(
+    p => platformAudits[p] && platformAudits[p].results
+  );
+
+  if (platforms.length === 0) {
+    return {
+      compoundScore: 0,
+      bestSingleScore: 0,
+      amplification: 0,
+      totalFindings: 0,
+      crossValidated: [],
+      platformUnique: {},
+      coverageMap: {},
+    };
+  }
+
+  const concepts = groupByConcept(platformAudits);
+  const crossValidated = [];
+  const platformUnique = {};
+  const coverageMap = {};
+
+  for (const platform of platforms) {
+    platformUnique[platform] = [];
+    coverageMap[platform] = { found: 0, unique: 0, shared: 0 };
+  }
+
+  // Analyze each concept across platforms
+  for (const [key, concept] of Object.entries(concepts)) {
+    const involvedPlatforms = Object.keys(concept.platforms);
+    const failedOn = involvedPlatforms.filter(p => concept.platforms[p].passed === false);
+    const passedOn = involvedPlatforms.filter(p => concept.platforms[p].passed === true);
+
+    // Track coverage
+    for (const p of involvedPlatforms) {
+      coverageMap[p].found++;
+    }
+
+    if (involvedPlatforms.length >= 2) {
+      // Cross-validated finding
+      for (const p of involvedPlatforms) {
+        coverageMap[p].shared++;
+      }
+
+      if (failedOn.length >= 2) {
+        crossValidated.push({
+          key,
+          name: concept.name,
+          category: concept.category,
+          impact: concept.impact,
+          failedOn,
+          passedOn,
+          confidence: Math.min(1, 0.5 + (failedOn.length * 0.15)),
+          verdict: failedOn.length === involvedPlatforms.length
+            ? 'universal-gap'
+            : 'partial-gap',
+        });
+      } else if (passedOn.length >= 2) {
+        crossValidated.push({
+          key,
+          name: concept.name,
+          category: concept.category,
+          impact: concept.impact,
+          failedOn,
+          passedOn,
+          confidence: Math.min(1, 0.5 + (passedOn.length * 0.15)),
+          verdict: 'cross-validated-pass',
+        });
+      }
+    } else {
+      // Platform-unique finding
+      const platform = involvedPlatforms[0];
+      coverageMap[platform].unique++;
+      platformUnique[platform].push({
+        key,
+        name: concept.name,
+        category: concept.category,
+        impact: concept.impact,
+        passed: concept.platforms[platform].passed,
+        fix: concept.platforms[platform].fix,
+      });
+    }
+  }
+
+  // Calculate scores
+  const singleScores = platforms.map(p => platformAudits[p].score || 0);
+  const bestSingleScore = Math.max(...singleScores);
+
+  // Compound score = best single + bonus from cross-validation + bonus from unique coverage
+  const crossValidationBonus = crossValidated
+    .filter(cv => cv.verdict === 'cross-validated-pass')
+    .length * 0.5;
+  const uniqueCoverageBonus = Object.values(platformUnique)
+    .reduce((sum, findings) => sum + findings.filter(f => f.passed).length, 0) * 0.3;
+  const totalUniqueFindings = Object.keys(concepts).length;
+
+  const compoundScore = Math.round(
+    Math.min(150, bestSingleScore + crossValidationBonus + uniqueCoverageBonus)
+  );
+
+  return {
+    compoundScore,
+    bestSingleScore,
+    amplification: compoundScore - bestSingleScore,
+    totalFindings: totalUniqueFindings,
+    crossValidated,
+    platformUnique,
+    coverageMap,
+  };
+}
+
+/**
+ * Calculate the amplification factor from combining multiple platforms.
+ *
+ * @param {Object} platformAudits - Per-platform audit results
+ * @returns {Object} Amplification metrics
+ */
+function calculateAmplification(platformAudits) {
+  const result = compoundAudit(platformAudits);
+  const platformCount = Object.keys(platformAudits).filter(
+    p => platformAudits[p] && platformAudits[p].results
+  ).length;
+
+  return {
+    amplification: result.amplification,
+    amplificationPercent: result.bestSingleScore > 0
+      ? Math.round((result.amplification / result.bestSingleScore) * 100)
+      : 0,
+    platformCount,
+    crossValidatedCount: result.crossValidated.length,
+    uniqueFindingsPerPlatform: Object.fromEntries(
+      Object.entries(result.platformUnique).map(([p, findings]) => [p, findings.length])
+    ),
+    verdict: result.amplification > 10 ? 'strong-synergy'
+      : result.amplification > 5 ? 'moderate-synergy'
+      : result.amplification > 0 ? 'mild-synergy'
+      : 'no-synergy',
+  };
+}
+
+module.exports = { compoundAudit, calculateAmplification };