@getcodesentinel/codesentinel 1.15.0 → 1.17.0

package/dist/index.js

@@ -1656,7 +1656,7 @@ var createReport = (snapshot, diff) => {
       confidence: repositoryConfidence(snapshot),
       dimensionScores: repositoryDimensionScores(snapshot)
     },
-    quality: snapshot.analysis.quality,
+    health: snapshot.analysis.health,
     hotspots: hotspotItems(snapshot),
     structural: {
       cycleCount: snapshot.analysis.structural.metrics.cycleCount,
@@ -1728,19 +1728,21 @@ var renderTextReport = (report) => {
   lines.push(`  external: ${report.repository.dimensionScores.external ?? "n/a"}`);
   lines.push(`  interactions: ${report.repository.dimensionScores.interactions ?? "n/a"}`);
   lines.push("");
-  lines.push("Quality Summary");
-  lines.push(`  qualityScore: ${report.quality.qualityScore}`);
-  lines.push(`  normalizedScore: ${report.quality.normalizedScore}`);
-  lines.push(`  modularity: ${report.quality.dimensions.modularity}`);
-  lines.push(`  changeHygiene: ${report.quality.dimensions.changeHygiene}`);
-  lines.push(`  testHealth: ${report.quality.dimensions.testHealth}`);
+  lines.push("Health Summary");
+  lines.push(`  healthScore: ${report.health.healthScore}`);
+  lines.push(`  normalizedScore: ${report.health.normalizedScore}`);
+  lines.push(`  modularity: ${report.health.dimensions.modularity}`);
+  lines.push(`  changeHygiene: ${report.health.dimensions.changeHygiene}`);
+  lines.push(`  testHealth: ${report.health.dimensions.testHealth}`);
+  lines.push(`  ownershipDistribution: ${report.health.dimensions.ownershipDistribution}`);
   lines.push("  topIssues:");
-  for (const issue of report.quality.topIssues.slice(0, 5)) {
+  for (const issue of report.health.topIssues.slice(0, 5)) {
+    const ruleSuffix = issue.ruleId === void 0 ? "" : ` [rule=${issue.ruleId}]`;
     lines.push(
-      `    - [${issue.severity}] (${issue.dimension}) ${issue.id} @ ${issue.target}: ${issue.message}`
+      `    - [${issue.severity}] (${issue.dimension}) ${issue.id}${ruleSuffix} @ ${issue.target}: ${issue.message}`
     );
   }
-  if (report.quality.topIssues.length === 0) {
+  if (report.health.topIssues.length === 0) {
     lines.push("    - none");
   }
   lines.push("");
@@ -1819,19 +1821,21 @@ var renderMarkdownReport = (report) => {
   lines.push(`- external: \`${report.repository.dimensionScores.external ?? "n/a"}\``);
   lines.push(`- interactions: \`${report.repository.dimensionScores.interactions ?? "n/a"}\``);
   lines.push("");
-  lines.push("## Quality Summary");
-  lines.push(`- qualityScore: \`${report.quality.qualityScore}\``);
-  lines.push(`- normalizedScore: \`${report.quality.normalizedScore}\``);
-  lines.push(`- modularity: \`${report.quality.dimensions.modularity}\``);
-  lines.push(`- changeHygiene: \`${report.quality.dimensions.changeHygiene}\``);
-  lines.push(`- testHealth: \`${report.quality.dimensions.testHealth}\``);
-  if (report.quality.topIssues.length === 0) {
+  lines.push("## Health Summary");
+  lines.push(`- healthScore: \`${report.health.healthScore}\``);
+  lines.push(`- normalizedScore: \`${report.health.normalizedScore}\``);
+  lines.push(`- modularity: \`${report.health.dimensions.modularity}\``);
+  lines.push(`- changeHygiene: \`${report.health.dimensions.changeHygiene}\``);
+  lines.push(`- testHealth: \`${report.health.dimensions.testHealth}\``);
+  lines.push(`- ownershipDistribution: \`${report.health.dimensions.ownershipDistribution}\``);
+  if (report.health.topIssues.length === 0) {
     lines.push("- top issues: none");
   } else {
     lines.push("- top issues:");
-    for (const issue of report.quality.topIssues.slice(0, 5)) {
+    for (const issue of report.health.topIssues.slice(0, 5)) {
+      const ruleSuffix = issue.ruleId === void 0 ? "" : ` [rule=${issue.ruleId}]`;
       lines.push(
-        `  - [${issue.severity}] \`${issue.id}\` (\`${issue.dimension}\`) @ \`${issue.target}\`: ${issue.message}`
+        `  - [${issue.severity}] \`${issue.id}\`${ruleSuffix} (\`${issue.dimension}\`) @ \`${issue.target}\`: ${issue.message}`
       );
     }
   }
@@ -1981,14 +1985,20 @@ var requireDiff = (input, gateId) => {
 };
 var validateGateConfig = (input) => {
   const config = input.gateConfig;
-  if (config.maxRepoDelta !== void 0 && (!Number.isFinite(config.maxRepoDelta) || config.maxRepoDelta < 0)) {
-    throw new GovernanceConfigurationError("max-repo-delta must be a finite number >= 0");
+  if (config.maxRiskDelta !== void 0 && (!Number.isFinite(config.maxRiskDelta) || config.maxRiskDelta < 0)) {
+    throw new GovernanceConfigurationError("max-risk-delta must be a finite number >= 0");
+  }
+  if (config.maxHealthDelta !== void 0 && (!Number.isFinite(config.maxHealthDelta) || config.maxHealthDelta < 0)) {
+    throw new GovernanceConfigurationError("max-health-delta must be a finite number >= 0");
   }
   if (config.maxNewHotspots !== void 0 && (!Number.isInteger(config.maxNewHotspots) || config.maxNewHotspots < 0)) {
     throw new GovernanceConfigurationError("max-new-hotspots must be an integer >= 0");
   }
-  if (config.maxRepoScore !== void 0 && (!Number.isFinite(config.maxRepoScore) || config.maxRepoScore < 0 || config.maxRepoScore > 100)) {
-    throw new GovernanceConfigurationError("max-repo-score must be a number in [0, 100]");
+  if (config.maxRiskScore !== void 0 && (!Number.isFinite(config.maxRiskScore) || config.maxRiskScore < 0 || config.maxRiskScore > 100)) {
+    throw new GovernanceConfigurationError("max-risk-score must be a number in [0, 100]");
+  }
+  if (config.minHealthScore !== void 0 && (!Number.isFinite(config.minHealthScore) || config.minHealthScore < 0 || config.minHealthScore > 100)) {
+    throw new GovernanceConfigurationError("min-health-score must be a number in [0, 100]");
   }
   if (config.newHotspotScoreThreshold !== void 0 && (!Number.isFinite(config.newHotspotScoreThreshold) || config.newHotspotScoreThreshold < 0 || config.newHotspotScoreThreshold > 100)) {
     throw new GovernanceConfigurationError(
@@ -2001,41 +2011,76 @@ var evaluateGates = (input) => {
   const config = input.gateConfig;
   const violations = [];
   const evaluatedGates = [];
-  if (config.maxRepoScore !== void 0) {
-    evaluatedGates.push("max-repo-score");
+  if (config.maxRiskScore !== void 0) {
+    evaluatedGates.push("max-risk-score");
     const current = input.current.analysis.risk.riskScore;
-    if (current > config.maxRepoScore) {
+    if (current > config.maxRiskScore) {
       violations.push(
         makeViolation(
-          "max-repo-score",
+          "max-risk-score",
           "error",
-          `Repository score ${current} exceeds configured max ${config.maxRepoScore}.`,
+          `Risk score ${current} exceeds configured max ${config.maxRiskScore}.`,
           [input.current.analysis.structural.targetPath],
           [{ kind: "repository_metric", metric: "riskScore" }]
         )
       );
     }
   }
-  if (config.maxRepoDelta !== void 0) {
-    evaluatedGates.push("max-repo-delta");
-    requireDiff(input, "max-repo-delta");
+  if (config.minHealthScore !== void 0) {
+    evaluatedGates.push("min-health-score");
+    const current = input.current.analysis.health.healthScore;
+    if (current < config.minHealthScore) {
+      violations.push(
+        makeViolation(
+          "min-health-score",
+          "error",
+          `Health score ${current} is below configured minimum ${config.minHealthScore}.`,
+          [input.current.analysis.structural.targetPath],
+          [{ kind: "repository_metric", metric: "healthScore" }]
+        )
+      );
+    }
+  }
+  if (config.maxRiskDelta !== void 0) {
+    evaluatedGates.push("max-risk-delta");
+    requireDiff(input, "max-risk-delta");
     const baseline = input.baseline;
     if (baseline === void 0) {
-      throw new GovernanceConfigurationError("max-repo-delta requires baseline snapshot");
+      throw new GovernanceConfigurationError("max-risk-delta requires baseline snapshot");
     }
     const delta = input.current.analysis.risk.normalizedScore - baseline.analysis.risk.normalizedScore;
-    if (delta > config.maxRepoDelta) {
+    if (delta > config.maxRiskDelta) {
       violations.push(
         makeViolation(
-          "max-repo-delta",
+          "max-risk-delta",
           "error",
-          `Repository normalized score delta ${delta.toFixed(4)} exceeds allowed ${config.maxRepoDelta}.`,
+          `Risk normalized score delta ${delta.toFixed(4)} exceeds allowed ${config.maxRiskDelta}.`,
           [input.current.analysis.structural.targetPath],
           [{ kind: "repository_metric", metric: "normalizedScore" }]
         )
       );
     }
   }
+  if (config.maxHealthDelta !== void 0) {
+    evaluatedGates.push("max-health-delta");
+    requireDiff(input, "max-health-delta");
+    const baseline = input.baseline;
+    if (baseline === void 0) {
+      throw new GovernanceConfigurationError("max-health-delta requires baseline snapshot");
+    }
+    const delta = input.current.analysis.health.normalizedScore - baseline.analysis.health.normalizedScore;
+    if (delta < -config.maxHealthDelta) {
+      violations.push(
+        makeViolation(
+          "max-health-delta",
+          "error",
+          `Health normalized score delta ${delta.toFixed(4)} is below allowed minimum ${(-config.maxHealthDelta).toFixed(4)}.`,
+          [input.current.analysis.structural.targetPath],
+          [{ kind: "repository_metric", metric: "healthNormalizedScore" }]
+        )
+      );
+    }
+  }
   if (config.noNewCycles === true) {
     evaluatedGates.push("no-new-cycles");
     requireDiff(input, "no-new-cycles");
@@ -2493,7 +2538,7 @@ var resolveAutoBaselineRef = async (input) => {
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 import { dirname as dirname2, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 
@@ -2535,11 +2580,11 @@ var createSummaryShape = (summary) => ({
     fragileClusterCount: summary.risk.fragileClusters.length,
     dependencyAmplificationZoneCount: summary.risk.dependencyAmplificationZones.length
   },
-  quality: {
-    qualityScore: summary.quality.qualityScore,
-    normalizedScore: summary.quality.normalizedScore,
-    dimensions: summary.quality.dimensions,
-    topIssues: summary.quality.topIssues.slice(0, 5)
+  health: {
+    healthScore: summary.health.healthScore,
+    normalizedScore: summary.health.normalizedScore,
+    dimensions: summary.health.dimensions,
+    topIssues: summary.health.topIssues.slice(0, 5)
   }
 });
 var formatAnalyzeOutput = (summary, mode) => mode === "json" ? JSON.stringify(summary, null, 2) : JSON.stringify(createSummaryShape(summary), null, 2);
@@ -2890,7 +2935,7 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { dirname, join as join3 } from "path";
 import { stderr, stdin } from "process";
-import { clearScreenDown, cursorTo, emitKeypressEvents, moveCursor } from "readline";
+import { clearScreenDown, cursorTo, emitKeypressEvents } from "readline";
 var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var UPDATE_CACHE_PATH = join3(homedir(), ".cache", "codesentinel", "update-check.json");
 var SEMVER_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -3082,11 +3127,15 @@ var fetchLatestVersion = async (packageName) => {
   }
   return parseNpmViewVersionOutput(result.stdout);
 };
-var renderUpdatePrompt = (latestVersion, currentVersion, selectedIndex) => {
-  const options = ["Install update now", "Not now (continue current command)"];
+var renderUpdatePrompt = (packageName, latestVersion, currentVersion, selectedIndex) => {
+  const options = [
+    `1. Update now (runs \`npm install -g ${packageName}\`)`,
+    "2. Skip"
+  ];
   const lines = [
-    `${ANSI.cyan}${ANSI.bold}CodeSentinel Update Available${ANSI.reset}`,
-    `${ANSI.dim}Current: ${currentVersion}  Latest: ${latestVersion}${ANSI.reset}`,
+    `  ${ANSI.bold}${ANSI.cyan}\u2728 Update available! ${currentVersion} -> ${latestVersion}${ANSI.reset}`,
+    "",
+    `  ${ANSI.dim}Release notes: https://github.com/getcodesentinel/codesentinel/releases/latest${ANSI.reset}`,
     "",
     ...options.map((option, index) => {
       const selected = index === selectedIndex;
@@ -3095,12 +3144,12 @@ var renderUpdatePrompt = (latestVersion, currentVersion, selectedIndex) => {
       return `${prefix} ${text}`;
     }),
     "",
-    `${ANSI.dim}Use \u2191/\u2193 to choose, Enter to confirm.${ANSI.reset}`
+    `  ${ANSI.dim}Use \u2191/\u2193 to choose. Press enter to continue${ANSI.reset}`
   ];
   stderr.write(lines.join("\n"));
   return lines.length;
 };
-var promptInstall = async (latestVersion, currentVersion) => {
+var promptInstall = async (packageName, latestVersion, currentVersion) => {
   if (!stdin.isTTY || !stderr.isTTY || typeof stdin.setRawMode !== "function") {
     stderr.write(
       `New version ${latestVersion} is available (current ${currentVersion}). Run: npm install -g @getcodesentinel/codesentinel@latest
@@ -3111,18 +3160,14 @@ var promptInstall = async (latestVersion, currentVersion) => {
   return await new Promise((resolve6) => {
     emitKeypressEvents(stdin);
     let selectedIndex = 0;
-    let renderedLines = 0;
     const previousRawMode = stdin.isRaw;
     const clearPromptArea = () => {
-      if (renderedLines > 0) {
-        moveCursor(stderr, 0, -(renderedLines - 1));
-      }
-      cursorTo(stderr, 0);
+      cursorTo(stderr, 0, 0);
       clearScreenDown(stderr);
     };
     const redraw = () => {
       clearPromptArea();
-      renderedLines = renderUpdatePrompt(latestVersion, currentVersion, selectedIndex);
+      renderUpdatePrompt(packageName, latestVersion, currentVersion, selectedIndex);
     };
     const cleanup = (choice) => {
       stdin.off("keypress", onKeypress);
@@ -3134,7 +3179,7 @@ var promptInstall = async (latestVersion, currentVersion) => {
       if (choice === "install") {
         stderr.write(`${ANSI.yellow}Installing latest CodeSentinel...${ANSI.reset}
 `);
-      } else if (renderedLines > 0) {
+      } else {
         stderr.write("\n");
       }
       resolve6(choice);
@@ -3193,7 +3238,7 @@ var checkForCliUpdates = async (input) => {
     if (comparison === null || comparison <= 0) {
       return;
     }
-    const choice = await promptInstall(latestVersion, input.currentVersion);
+    const choice = await promptInstall(input.packageName, latestVersion, input.currentVersion);
     if (choice === "interrupt") {
       process.exit(130);
     }
@@ -3216,8 +3261,7 @@ var checkForCliUpdates = async (input) => {
 };
 
 // src/application/run-analyze-command.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join4, resolve as resolve3 } from "path";
+import { resolve as resolve3 } from "path";
 
 // ../code-graph/dist/index.js
 import { extname, isAbsolute, relative, resolve as resolve2 } from "path";
@@ -4265,7 +4309,7 @@ var analyzeRepositoryEvolutionFromGit = (input, onProgress) => {
   return analyzeRepositoryEvolution(input, historyProvider, onProgress);
 };
 
-// ../quality-engine/dist/index.js
+// ../health-engine/dist/index.js
 var clamp01 = (value) => {
   if (!Number.isFinite(value)) {
     return 0;
@@ -4305,16 +4349,66 @@ var concentration = (rawValues) => {
   return clamp01(normalized);
 };
 var DIMENSION_WEIGHTS = {
-  modularity: 0.45,
-  changeHygiene: 0.35,
-  testHealth: 0.2
+  modularity: 0.35,
+  changeHygiene: 0.3,
+  testHealth: 0.2,
+  ownershipDistribution: 0.15
+};
+var HEALTH_TRACE_VERSION = "1";
+var toPercentage = (normalizedHealth) => round45(clamp01(normalizedHealth) * 100);
+var dampenForSmallSamples = (penalty, sampleSize, warmupSize, minimumWeight = 0.35) => {
+  const reliability = clamp01(sampleSize / Math.max(1, warmupSize));
+  const dampeningWeight = minimumWeight + (1 - minimumWeight) * reliability;
+  return clamp01(penalty) * dampeningWeight;
+};
+var topPercentShare = (values, fraction) => {
+  const positive = values.filter((value) => value > 0).sort((a, b) => b - a);
+  if (positive.length === 0) {
+    return 0;
+  }
+  const topCount = Math.max(1, Math.ceil(positive.length * clamp01(fraction)));
+  const total = positive.reduce((sum, value) => sum + value, 0);
+  const topTotal = positive.slice(0, topCount).reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return 0;
+  }
+  return clamp01(topTotal / total);
 };
-var TODO_FIXME_MAX_IMPACT = 0.08;
-var toPercentage = (normalizedQuality) => round45(clamp01(normalizedQuality) * 100);
+var normalizedEntropy = (weights) => {
+  const positive = weights.filter((value) => value > 0);
+  if (positive.length <= 1) {
+    return 0;
+  }
+  const total = positive.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return 0;
+  }
+  const entropy = positive.reduce((sum, value) => {
+    const p = value / total;
+    return sum - p * Math.log(p);
+  }, 0);
+  return clamp01(entropy / Math.log(positive.length));
+};
+var toFactorTrace = (spec) => ({
+  factorId: spec.factorId,
+  contribution: round45(spec.penalty * spec.weight * 100),
+  penalty: round45(spec.penalty),
+  rawMetrics: spec.rawMetrics,
+  normalizedMetrics: spec.normalizedMetrics,
+  weight: round45(spec.weight),
+  evidence: spec.evidence
+});
+var createDimensionTrace = (dimension, health, factors) => ({
+  dimension,
+  normalizedScore: round45(clamp01(health)),
+  score: toPercentage(health),
+  factors: factors.map((factor) => toFactorTrace(factor))
+});
 var filePaths = (structural) => structural.files.map((file) => file.relativePath);
+var normalizePath2 = (value) => value.replaceAll("\\", "/").toLowerCase();
 var isTestPath = (path) => {
-  const normalized = path.toLowerCase();
-  return normalized.includes("/__tests__/") || normalized.includes("\\__tests__\\") || normalized.includes(".test.") || normalized.includes(".spec.");
+  const normalized = normalizePath2(path);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || normalized.includes(".test.") || normalized.includes(".spec.");
 };
 var isSourcePath = (path) => {
   if (path.endsWith(".d.ts")) {
@@ -4322,148 +4416,721 @@ var isSourcePath = (path) => {
   }
   return !isTestPath(path);
 };
+var hasTestDirectory = (paths) => paths.some((path) => {
+  const normalized = normalizePath2(path);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/");
+});
+var moduleNameFromPath = (path) => {
+  const normalized = path.replaceAll("\\", "/");
+  const firstSegment = normalized.split("/")[0] ?? normalized;
+  return firstSegment.length === 0 ? normalized : firstSegment;
+};
 var pushIssue = (issues, issue) => {
   issues.push({
     ...issue,
     severity: issue.severity ?? "warn"
   });
 };
-var computeRepositoryQualitySummary = (input) => {
+var weightedPenalty = (factors) => clamp01(factors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0));
+var computeRepositoryHealthSummary = (input) => {
+  const ownershipPenaltyMultiplier = clamp01(input.config?.ownershipPenaltyMultiplier ?? 1);
   const issues = [];
   const sourceFileSet = new Set(input.structural.files.map((file) => file.relativePath));
-  const cycleCount = input.structural.metrics.cycleCount;
-  const cycleSizeAverage = input.structural.cycles.length === 0 ? 0 : average(input.structural.cycles.map((cycle) => cycle.nodes.length));
-  const cyclePenalty = clamp01(cycleCount / 6) * 0.7 + clamp01((cycleSizeAverage - 2) / 8) * 0.3;
-  if (cycleCount > 0) {
+  const sourceFileCount = Math.max(1, input.structural.files.length);
+  const structuralEdges = input.structural.edges;
+  const cycleSets = input.structural.cycles.map((cycle) => new Set(cycle.nodes)).filter((set) => set.size >= 2);
+  const cycleNodeSet = /* @__PURE__ */ new Set();
+  for (const cycleSet of cycleSets) {
+    for (const node of cycleSet) {
+      cycleNodeSet.add(node);
+    }
+  }
+  const edgesInsideCycles = structuralEdges.filter(
+    (edge) => cycleSets.some((cycleSet) => cycleSet.has(edge.from) && cycleSet.has(edge.to))
+  ).length;
+  const cycleEdgeRatio = structuralEdges.length === 0 ? 0 : clamp01(edgesInsideCycles / structuralEdges.length);
+  const cycleNodeRatio = clamp01(cycleNodeSet.size / sourceFileCount);
+  const cycleDensityPenalty = clamp01(
+    clamp01(cycleEdgeRatio / 0.2) * 0.75 + clamp01(cycleNodeRatio / 0.35) * 0.25
+  );
+  const fanInConcentration = concentration(input.structural.files.map((file) => file.fanIn));
+  const fanOutConcentration = concentration(input.structural.files.map((file) => file.fanOut));
+  const fanConcentration = average([fanInConcentration, fanOutConcentration]);
+  const centralityPressure = input.structural.files.map((file) => file.fanIn + file.fanOut);
+  const centralityConcentration = concentration(centralityPressure);
+  let structuralHotspotOverlap = 0;
+  if (input.evolution.available) {
+    const evolutionSourceFiles = input.evolution.files.filter(
+      (file) => sourceFileSet.has(file.filePath)
+    );
+    const topStructuralCount = Math.max(1, Math.ceil(sourceFileCount * 0.1));
+    const topChangeCount = Math.max(1, Math.ceil(Math.max(1, evolutionSourceFiles.length) * 0.1));
+    const topStructural = new Set(
+      [...input.structural.files].map((file) => ({
+        filePath: file.relativePath,
+        pressure: file.fanIn + file.fanOut
+      })).sort((a, b) => b.pressure - a.pressure || a.filePath.localeCompare(b.filePath)).slice(0, topStructuralCount).map((item) => item.filePath)
+    );
+    const topChange = new Set(
+      [...evolutionSourceFiles].sort((a, b) => b.churnTotal - a.churnTotal || a.filePath.localeCompare(b.filePath)).slice(0, topChangeCount).map((item) => item.filePath)
+    );
+    const overlapCount = [...topStructural].filter((filePath) => topChange.has(filePath)).length;
+    structuralHotspotOverlap = topStructural.size === 0 || topChange.size === 0 ? 0 : clamp01(overlapCount / Math.min(topStructural.size, topChange.size));
+  }
+  const modularityFactors = [
+    {
+      factorId: "health.modularity.cycle_density",
+      penalty: cycleDensityPenalty,
+      rawMetrics: {
+        cycleCount: input.structural.metrics.cycleCount,
+        cycleEdgeRatio: round45(cycleEdgeRatio),
+        cycleNodeRatio: round45(cycleNodeRatio)
+      },
+      normalizedMetrics: {
+        cycleDensityPenalty: round45(cycleDensityPenalty)
+      },
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "structural.cycleEdgeRatio" }]
+    },
+    {
+      factorId: "health.modularity.fan_concentration",
+      penalty: fanConcentration,
+      rawMetrics: {
+        fanInConcentration: round45(fanInConcentration),
+        fanOutConcentration: round45(fanOutConcentration)
+      },
+      normalizedMetrics: {
+        fanConcentration: round45(fanConcentration)
+      },
+      weight: 0.25,
+      evidence: [{ kind: "repository_metric", metric: "structural.files.fanIn/fanOut" }]
+    },
+    {
+      factorId: "health.modularity.centrality_concentration",
+      penalty: centralityConcentration,
+      rawMetrics: {
+        centralityConcentration: round45(centralityConcentration)
+      },
+      normalizedMetrics: {
+        centralityConcentration: round45(centralityConcentration)
+      },
+      weight: 0.2,
+      evidence: [{ kind: "repository_metric", metric: "structural.centralityPressure" }]
+    },
+    {
+      factorId: "health.modularity.hotspot_overlap",
+      penalty: structuralHotspotOverlap,
+      rawMetrics: {
+        structuralHotspotOverlap: round45(structuralHotspotOverlap)
+      },
+      normalizedMetrics: {
+        structuralHotspotOverlap: round45(structuralHotspotOverlap)
+      },
+      weight: 0.15,
+      evidence: [{ kind: "repository_metric", metric: "structural.evolution.hotspotOverlap" }]
+    }
+  ];
+  const modularityPenalty = dampenForSmallSamples(
+    weightedPenalty(modularityFactors),
+    sourceFileCount,
+    8,
+    0.45
+  );
+  if (cycleDensityPenalty >= 0.35) {
+    const firstCycle = input.structural.cycles[0];
     pushIssue(issues, {
-      id: "quality.modularity.structural_cycles",
+      id: "health.modularity.cycle_density",
+      ruleId: "graph.cycle_density",
+      signal: "structural.cycleEdgeRatio",
       dimension: "modularity",
-      target: input.structural.cycles[0]?.nodes.slice().sort((a, b) => a.localeCompare(b)).join(" -> ") ?? input.structural.targetPath,
-      message: `${cycleCount} structural cycle(s) increase coupling and refactor cost.`,
-      severity: cycleCount >= 3 ? "error" : "warn",
-      impact: round45(cyclePenalty * 0.6)
+      target: firstCycle?.nodes.slice().sort((a, b) => a.localeCompare(b)).join(" -> ") ?? input.structural.targetPath,
+      message: "Dependencies inside cycles consume a high share of graph edges, reducing refactor flexibility.",
+      severity: cycleDensityPenalty >= 0.7 ? "error" : "warn",
+      evidenceMetrics: {
+        cycleCount: input.structural.metrics.cycleCount,
+        cycleEdgeRatio: round45(cycleEdgeRatio),
+        cycleNodeRatio: round45(cycleNodeRatio)
+      },
+      impact: round45(modularityPenalty * 0.35)
     });
   }
-  const fanInConcentration = concentration(input.structural.files.map((file) => file.fanIn));
-  const fanOutConcentration = concentration(input.structural.files.map((file) => file.fanOut));
-  const centralityConcentration = average([fanInConcentration, fanOutConcentration]);
   if (centralityConcentration >= 0.5) {
     const hottest = [...input.structural.files].map((file) => ({
       path: file.relativePath,
       pressure: file.fanIn + file.fanOut
     })).sort((a, b) => b.pressure - a.pressure || a.path.localeCompare(b.path))[0];
     pushIssue(issues, {
-      id: "quality.modularity.centrality_concentration",
+      id: "health.modularity.centrality_concentration",
+      ruleId: "graph.centrality_concentration",
+      signal: "structural.centralityPressure",
       dimension: "modularity",
       target: hottest?.path ?? input.structural.targetPath,
-      message: "Fan-in/fan-out pressure is concentrated in a small set of files.",
-      impact: round45(centralityConcentration * 0.5)
+      message: "Dependency flow is concentrated in a narrow set of files, creating architectural bottlenecks.",
+      evidenceMetrics: {
+        fanConcentration: round45(fanConcentration),
+        centralityConcentration: round45(centralityConcentration)
+      },
+      impact: round45(modularityPenalty * 0.25)
     });
   }
-  let churnConcentration = 0;
-  let volatilityConcentration = 0;
-  let couplingDensity = 0;
-  let couplingIntensity = 0;
+  if (structuralHotspotOverlap >= 0.5) {
+    pushIssue(issues, {
+      id: "health.modularity.hotspot_overlap",
+      ruleId: "graph.hotspot_overlap",
+      signal: "structural.evolution.hotspotOverlap",
+      dimension: "modularity",
+      target: input.structural.targetPath,
+      message: "Structural hubs overlap with top churn hotspots, making change pressure harder to isolate.",
+      evidenceMetrics: {
+        structuralHotspotOverlap: round45(structuralHotspotOverlap)
+      },
+      impact: round45(modularityPenalty * 0.2)
+    });
+  }
+  let churnConcentrationPenalty = 0;
+  let volatilityConcentrationPenalty = 0;
+  let coChangeClusterPenalty = 0;
+  let top10PercentFilesChurnShare = 0;
+  let top10PercentFilesVolatilityShare = 0;
+  let denseCoChangePairRatio = 0;
   if (input.evolution.available) {
     const evolutionSourceFiles = input.evolution.files.filter(
       (file) => sourceFileSet.has(file.filePath)
     );
-    churnConcentration = concentration(evolutionSourceFiles.map((file) => file.churnTotal));
-    volatilityConcentration = concentration(
-      evolutionSourceFiles.map((file) => file.recentVolatility)
+    const evolutionFileCount = evolutionSourceFiles.length;
+    top10PercentFilesChurnShare = topPercentShare(
+      evolutionSourceFiles.map((file) => file.churnTotal),
+      0.1
+    );
+    top10PercentFilesVolatilityShare = topPercentShare(
+      evolutionSourceFiles.map((file) => file.recentVolatility),
+      0.1
     );
-    const fileCount = Math.max(1, evolutionSourceFiles.length);
-    const maxPairs = fileCount * (fileCount - 1) / 2;
     const sourcePairs = input.evolution.coupling.pairs.filter(
       (pair) => sourceFileSet.has(pair.fileA) && sourceFileSet.has(pair.fileB)
     );
-    couplingDensity = maxPairs <= 0 ? 0 : clamp01(sourcePairs.length / maxPairs);
-    couplingIntensity = average(sourcePairs.map((pair) => pair.couplingScore));
-    if (churnConcentration >= 0.45) {
+    const maxPairs = evolutionFileCount * (evolutionFileCount - 1) / 2;
+    const densePairs = sourcePairs.filter((pair) => pair.couplingScore >= 0.55);
+    denseCoChangePairRatio = maxPairs <= 0 ? 0 : clamp01(densePairs.length / maxPairs);
+    const couplingScoreConcentration = concentration(sourcePairs.map((pair) => pair.couplingScore));
+    churnConcentrationPenalty = dampenForSmallSamples(
+      clamp01((top10PercentFilesChurnShare - 0.35) / 0.55),
+      evolutionFileCount,
+      12,
+      0.3
+    );
+    volatilityConcentrationPenalty = dampenForSmallSamples(
+      clamp01((top10PercentFilesVolatilityShare - 0.35) / 0.55),
+      evolutionFileCount,
+      12,
+      0.3
+    );
+    const coChangeRaw = average([
+      clamp01(denseCoChangePairRatio / 0.2),
+      couplingScoreConcentration
+    ]);
+    coChangeClusterPenalty = dampenForSmallSamples(coChangeRaw, sourcePairs.length, 20, 0.35);
+    if (churnConcentrationPenalty >= 0.35) {
       const mostChurn = [...evolutionSourceFiles].sort(
         (a, b) => b.churnTotal - a.churnTotal || a.filePath.localeCompare(b.filePath)
       )[0];
       pushIssue(issues, {
-        id: "quality.change_hygiene.churn_concentration",
+        id: "health.change_hygiene.churn_concentration",
+        ruleId: "git.churn_distribution",
+        signal: "evolution.top10PercentFilesChurnShare",
         dimension: "changeHygiene",
         target: mostChurn?.filePath ?? input.structural.targetPath,
-        message: "Churn is concentrated in a narrow part of the codebase.",
-        impact: round45(churnConcentration * 0.45)
+        message: "A small slice of files carries most churn, reducing change predictability.",
+        evidenceMetrics: {
+          top10PercentFilesChurnShare: round45(top10PercentFilesChurnShare)
+        },
+        impact: round45(churnConcentrationPenalty * 0.4)
       });
     }
-    if (volatilityConcentration >= 0.45) {
+    if (volatilityConcentrationPenalty >= 0.35) {
       const volatileFile = [...evolutionSourceFiles].sort(
         (a, b) => b.recentVolatility - a.recentVolatility || a.filePath.localeCompare(b.filePath)
       )[0];
       pushIssue(issues, {
-        id: "quality.change_hygiene.volatility_concentration",
+        id: "health.change_hygiene.volatility_concentration",
+        ruleId: "git.volatility_distribution",
+        signal: "evolution.top10PercentFilesVolatilityShare",
         dimension: "changeHygiene",
         target: volatileFile?.filePath ?? input.structural.targetPath,
-        message: "Recent volatility is concentrated in files that change frequently.",
-        impact: round45(volatilityConcentration * 0.4)
+        message: "Recent volatility is concentrated, increasing review and release uncertainty.",
+        evidenceMetrics: {
+          top10PercentFilesVolatilityShare: round45(top10PercentFilesVolatilityShare)
+        },
+        impact: round45(volatilityConcentrationPenalty * 0.3)
       });
     }
-    if (couplingDensity >= 0.35 || couplingIntensity >= 0.45) {
+    if (coChangeClusterPenalty >= 0.35) {
       const strongestPair = [...sourcePairs].sort(
         (a, b) => b.couplingScore - a.couplingScore || `${a.fileA}|${a.fileB}`.localeCompare(`${b.fileA}|${b.fileB}`)
       )[0];
       pushIssue(issues, {
-        id: "quality.change_hygiene.coupling_density",
+        id: "health.change_hygiene.dense_co_change_clusters",
+        ruleId: "git.co_change_clusters",
+        signal: "evolution.denseCoChangePairRatio",
         dimension: "changeHygiene",
         target: strongestPair === void 0 ? input.structural.targetPath : `${strongestPair.fileA}<->${strongestPair.fileB}`,
-        message: "Co-change relationships are dense, increasing coordination overhead.",
-        impact: round45(average([couplingDensity, couplingIntensity]) * 0.35)
+        message: "Dense co-change clusters suggest wider coordination scope per change.",
+        evidenceMetrics: {
+          denseCoChangePairRatio: round45(denseCoChangePairRatio)
+        },
+        impact: round45(coChangeClusterPenalty * 0.3)
       });
     }
   }
-  const modularityPenalty = clamp01(cyclePenalty * 0.55 + centralityConcentration * 0.45);
-  const changeHygienePenalty = input.evolution.available ? clamp01(
-    churnConcentration * 0.4 + volatilityConcentration * 0.35 + couplingDensity * 0.15 + couplingIntensity * 0.1
-  ) : 0.25;
+  const changeHygieneFactors = [
+    {
+      factorId: "health.change_hygiene.churn_concentration",
+      penalty: churnConcentrationPenalty,
+      rawMetrics: {
+        top10PercentFilesChurnShare: round45(top10PercentFilesChurnShare)
+      },
+      normalizedMetrics: {
+        churnConcentrationPenalty: round45(churnConcentrationPenalty)
+      },
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "evolution.top10PercentFilesChurnShare" }]
+    },
+    {
+      factorId: "health.change_hygiene.volatility_concentration",
+      penalty: volatilityConcentrationPenalty,
+      rawMetrics: {
+        top10PercentFilesVolatilityShare: round45(top10PercentFilesVolatilityShare)
+      },
+      normalizedMetrics: {
+        volatilityConcentrationPenalty: round45(volatilityConcentrationPenalty)
+      },
+      weight: 0.3,
+      evidence: [
+        {
+          kind: "repository_metric",
+          metric: "evolution.top10PercentFilesVolatilityShare"
+        }
+      ]
+    },
+    {
+      factorId: "health.change_hygiene.dense_co_change_clusters",
+      penalty: coChangeClusterPenalty,
+      rawMetrics: {
+        denseCoChangePairRatio: round45(denseCoChangePairRatio)
+      },
+      normalizedMetrics: {
+        coChangeClusterPenalty: round45(coChangeClusterPenalty)
+      },
+      weight: 0.3,
+      evidence: [{ kind: "repository_metric", metric: "evolution.denseCoChangePairRatio" }]
+    }
+  ];
+  const changeHygienePenalty = input.evolution.available ? weightedPenalty(changeHygieneFactors) : 0.12;
   const paths = filePaths(input.structural);
   const testFiles = paths.filter((path) => isTestPath(path)).length;
   const sourceFiles = paths.filter((path) => isSourcePath(path)).length;
   const testRatio = sourceFiles <= 0 ? 1 : testFiles / sourceFiles;
-  const testPresencePenalty = sourceFiles <= 0 ? 0 : 1 - clamp01(testRatio / 0.3);
-  if (sourceFiles > 0 && testRatio < 0.2) {
+  const testingDirectoryPresent = hasTestDirectory(paths);
+  const testPresencePenalty = sourceFiles <= 0 ? 0 : testFiles === 0 ? 1 : 0;
+  const testRatioPenalty = sourceFiles <= 0 ? 0 : 1 - clamp01(testRatio / 0.25);
+  const testingDirectoryPenalty = sourceFiles <= 0 ? 0 : testingDirectoryPresent ? 0 : 0.35;
+  const testHealthFactors = [
+    {
+      factorId: "health.test_health.test_file_presence",
+      penalty: testPresencePenalty,
+      rawMetrics: {
+        sourceFiles,
+        testFiles
+      },
+      normalizedMetrics: {
+        testPresencePenalty: round45(testPresencePenalty)
+      },
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "tests.filePresence" }]
+    },
+    {
+      factorId: "health.test_health.test_to_source_ratio",
+      penalty: testRatioPenalty,
+      rawMetrics: {
+        testToSourceRatio: round45(testRatio)
+      },
+      normalizedMetrics: {
+        testRatioPenalty: round45(testRatioPenalty)
+      },
+      weight: 0.45,
+      evidence: [{ kind: "repository_metric", metric: "tests.testToSourceRatio" }]
+    },
+    {
+      factorId: "health.test_health.testing_directory_presence",
+      penalty: testingDirectoryPenalty,
+      rawMetrics: {
+        testingDirectoryPresent: testingDirectoryPresent ? 1 : 0
+      },
+      normalizedMetrics: {
+        testingDirectoryPenalty: round45(testingDirectoryPenalty)
+      },
+      weight: 0.15,
+      evidence: [{ kind: "repository_metric", metric: "tests.directoryPresence" }]
+    }
+  ];
+  const testHealthPenalty = dampenForSmallSamples(
+    weightedPenalty(testHealthFactors),
+    sourceFiles,
+    10,
+    0.3
+  );
+  if (sourceFiles > 0 && testFiles === 0) {
     pushIssue(issues, {
-      id: "quality.test_health.low_test_presence",
+      id: "health.test_health.low_test_presence",
+      ruleId: "tests.file_presence",
+      signal: "tests.filePresence",
       dimension: "testHealth",
       target: input.structural.targetPath,
-      message: `Detected ${testFiles} test file(s) for ${sourceFiles} source file(s).`,
-      severity: testRatio === 0 ? "error" : "warn",
-      impact: round45(testPresencePenalty * 0.5)
+      message: `No test files detected for ${sourceFiles} source file(s).`,
+      severity: sourceFiles >= 12 ? "error" : "warn",
+      evidenceMetrics: {
+        sourceFiles,
+        testFiles,
+        testToSourceRatio: round45(testRatio)
+      },
+      impact: round45(testHealthPenalty * 0.45)
     });
   }
-  const todoFixmeCount = Math.max(0, input.todoFixmeCount ?? 0);
-  const todoFixmePenalty = clamp01(todoFixmeCount / 120) * TODO_FIXME_MAX_IMPACT;
-  if (todoFixmeCount > 0) {
+  if (sourceFiles > 0 && testRatio < 0.12) {
     pushIssue(issues, {
-      id: "quality.change_hygiene.todo_fixme_load",
-      dimension: "changeHygiene",
+      id: "health.test_health.low_test_ratio",
+      ruleId: "tests.ratio",
+      signal: "tests.testToSourceRatio",
+      dimension: "testHealth",
       target: input.structural.targetPath,
-      message: `Found ${todoFixmeCount} TODO/FIXME marker(s); cleanup debt is accumulating.`,
-      impact: round45(todoFixmePenalty * 0.2)
+      message: "Test-to-source ratio is low; long-term change confidence may degrade.",
+      evidenceMetrics: {
+        sourceFiles,
+        testFiles,
+        testToSourceRatio: round45(testRatio)
+      },
+      impact: round45(testHealthPenalty * 0.35)
     });
   }
-  const modularityQuality = clamp01(1 - modularityPenalty);
-  const changeHygieneQuality = clamp01(1 - clamp01(changeHygienePenalty + todoFixmePenalty));
-  const testHealthQuality = clamp01(1 - testPresencePenalty);
+  if (input.evolution.available) {
+    const evolutionSourceFiles = input.evolution.files.filter(
+      (file) => sourceFileSet.has(file.filePath)
+    );
+    const authorTotals = /* @__PURE__ */ new Map();
+    const moduleTotals = /* @__PURE__ */ new Map();
+    const moduleAuthors = /* @__PURE__ */ new Map();
+    let singleContributorFiles = 0;
+    let trackedFiles = 0;
+    for (const file of evolutionSourceFiles) {
+      if (file.commitCount <= 0 || file.authorDistribution.length === 0) {
+        continue;
+      }
+      trackedFiles += 1;
+      const dominantShare = clamp01(file.authorDistribution[0]?.share ?? 0);
+      if (file.authorDistribution.length === 1 || dominantShare >= 0.9) {
+        singleContributorFiles += 1;
+      }
+      for (const author of file.authorDistribution) {
+        const commits = Math.max(0, author.commits);
+        if (commits <= 0) {
+          continue;
+        }
+        const moduleName = moduleNameFromPath(file.filePath);
+        const moduleAuthorTotals = moduleAuthors.get(moduleName) ?? /* @__PURE__ */ new Map();
+        if (moduleAuthors.has(moduleName) === false) {
+          moduleAuthors.set(moduleName, moduleAuthorTotals);
+        }
+        authorTotals.set(author.authorId, (authorTotals.get(author.authorId) ?? 0) + commits);
+        moduleTotals.set(moduleName, (moduleTotals.get(moduleName) ?? 0) + commits);
+        moduleAuthorTotals.set(
+          author.authorId,
+          (moduleAuthorTotals.get(author.authorId) ?? 0) + commits
+        );
+      }
+    }
+    const totalAuthorCommits = [...authorTotals.values()].reduce((sum, value) => sum + value, 0);
+    const highestAuthorCommits = [...authorTotals.values()].sort((a, b) => b - a)[0] ?? 0;
+    const topAuthorCommitShare = totalAuthorCommits <= 0 ? 0 : clamp01(highestAuthorCommits / totalAuthorCommits);
+    const filesWithSingleContributorRatio = trackedFiles === 0 ? 0 : clamp01(singleContributorFiles / trackedFiles);
+    const authorEntropy = normalizedEntropy([...authorTotals.values()]);
+    let dominatedModules = 0;
+    let trackedModules = 0;
+    for (const [moduleName, moduleCommitTotal] of moduleTotals.entries()) {
+      if (moduleCommitTotal < 5) {
+        continue;
+      }
+      const perModuleAuthors = moduleAuthors.get(moduleName);
+      if (perModuleAuthors === void 0) {
+        continue;
+      }
+      trackedModules += 1;
+      const topAuthorModuleCommits = [...perModuleAuthors.values()].sort((a, b) => b - a)[0] ?? 0;
+      const moduleTopShare = moduleCommitTotal <= 0 ? 0 : topAuthorModuleCommits / moduleCommitTotal;
+      if (moduleTopShare >= 0.8) {
+        dominatedModules += 1;
+      }
+    }
+    const modulesDominatedBySingleContributorRatio = trackedModules === 0 ? 0 : clamp01(dominatedModules / trackedModules);
+    const ownershipSampleSize = trackedFiles;
+    const ownershipCommitVolume = totalAuthorCommits;
+    const ownershipReliability = average([
+      clamp01(ownershipSampleSize / 12),
+      clamp01(ownershipCommitVolume / 180)
+    ]);
+    const topAuthorPenalty = clamp01((topAuthorCommitShare - 0.55) / 0.4);
+    const singleContributorPenalty = clamp01((filesWithSingleContributorRatio - 0.35) / 0.6);
+    const entropyPenalty = clamp01((0.75 - authorEntropy) / 0.75);
+    const moduleDominancePenalty = clamp01((modulesDominatedBySingleContributorRatio - 0.4) / 0.6);
+    const ownershipBasePenalty = weightedPenalty([
+      {
+        factorId: "health.ownership.top_author_commit_share",
+        penalty: topAuthorPenalty,
+        rawMetrics: {
+          topAuthorCommitShare: round45(topAuthorCommitShare)
+        },
+        normalizedMetrics: {
+          topAuthorPenalty: round45(topAuthorPenalty)
+        },
+        weight: 0.35,
+        evidence: [{ kind: "repository_metric", metric: "ownership.topAuthorCommitShare" }]
+      },
+      {
+        factorId: "health.ownership.files_with_single_contributor_ratio",
+        penalty: singleContributorPenalty,
+        rawMetrics: {
+          filesWithSingleContributorRatio: round45(filesWithSingleContributorRatio)
+        },
+        normalizedMetrics: {
+          singleContributorPenalty: round45(singleContributorPenalty)
+        },
+        weight: 0.25,
+        evidence: [
+          {
+            kind: "repository_metric",
+            metric: "ownership.filesWithSingleContributorRatio"
+          }
+        ]
+      },
+      {
+        factorId: "health.ownership.author_entropy",
+        penalty: entropyPenalty,
+        rawMetrics: {
+          authorEntropy: round45(authorEntropy)
+        },
+        normalizedMetrics: {
+          authorEntropyPenalty: round45(entropyPenalty)
+        },
+        weight: 0.25,
+        evidence: [{ kind: "repository_metric", metric: "ownership.authorEntropy" }]
+      },
+      {
+        factorId: "health.ownership.module_single_author_dominance",
+        penalty: moduleDominancePenalty,
+        rawMetrics: {
+          modulesDominatedBySingleContributorRatio: round45(
+            modulesDominatedBySingleContributorRatio
+          )
+        },
+        normalizedMetrics: {
+          moduleDominancePenalty: round45(moduleDominancePenalty)
+        },
+        weight: 0.15,
+        evidence: [{ kind: "repository_metric", metric: "ownership.moduleDominance" }]
+      }
+    ]);
+    const ownershipDistributionPenalty2 = clamp01(
+      ownershipBasePenalty * (0.3 + 0.7 * ownershipReliability) * ownershipPenaltyMultiplier
+    );
+    const ownershipDistributionFactors2 = [
+      {
+        factorId: "health.ownership.top_author_commit_share",
+        penalty: topAuthorPenalty,
+        rawMetrics: {
+          topAuthorCommitShare: round45(topAuthorCommitShare)
+        },
+        normalizedMetrics: {
+          topAuthorPenalty: round45(topAuthorPenalty),
+          ownershipPenaltyMultiplier: round45(ownershipPenaltyMultiplier),
+          ownershipReliability: round45(ownershipReliability)
+        },
+        weight: 0.35,
+        evidence: [{ kind: "repository_metric", metric: "ownership.topAuthorCommitShare" }]
+      },
+      {
+        factorId: "health.ownership.files_with_single_contributor_ratio",
+        penalty: singleContributorPenalty,
+        rawMetrics: {
+          filesWithSingleContributorRatio: round45(filesWithSingleContributorRatio)
+        },
+        normalizedMetrics: {
+          singleContributorPenalty: round45(singleContributorPenalty)
+        },
+        weight: 0.25,
+        evidence: [
+          {
+            kind: "repository_metric",
+            metric: "ownership.filesWithSingleContributorRatio"
+          }
+        ]
+      },
+      {
+        factorId: "health.ownership.author_entropy",
+        penalty: entropyPenalty,
+        rawMetrics: {
+          authorEntropy: round45(authorEntropy)
+        },
+        normalizedMetrics: {
+          authorEntropyPenalty: round45(entropyPenalty)
+        },
+        weight: 0.25,
+        evidence: [{ kind: "repository_metric", metric: "ownership.authorEntropy" }]
+      },
+      {
+        factorId: "health.ownership.module_single_author_dominance",
+        penalty: moduleDominancePenalty,
+        rawMetrics: {
+          modulesDominatedBySingleContributorRatio: round45(
+            modulesDominatedBySingleContributorRatio
+          )
+        },
+        normalizedMetrics: {
+          moduleDominancePenalty: round45(moduleDominancePenalty)
+        },
+        weight: 0.15,
+        evidence: [{ kind: "repository_metric", metric: "ownership.moduleDominance" }]
+      }
+    ];
+    if (topAuthorPenalty >= 0.35) {
+      pushIssue(issues, {
+        id: "health.ownership.top_author_commit_share",
+        ruleId: "ownership.top_author_share",
+        signal: "ownership.topAuthorCommitShare",
+        dimension: "ownershipDistribution",
+        target: input.structural.targetPath,
+        message: "A single contributor owns most commits, concentrating repository knowledge.",
+        severity: topAuthorPenalty >= 0.75 ? "error" : "warn",
+        evidenceMetrics: {
+          topAuthorCommitShare: round45(topAuthorCommitShare),
+          authorEntropy: round45(authorEntropy)
+        },
+        impact: round45(ownershipDistributionPenalty2 * 0.4)
+      });
+    }
+    if (singleContributorPenalty >= 0.35) {
+      pushIssue(issues, {
+        id: "health.ownership.single_author_dominance",
+        ruleId: "ownership.file_dominance",
+        signal: "ownership.filesWithSingleContributorRatio",
+        dimension: "ownershipDistribution",
+        target: input.structural.targetPath,
+        message: "Many files are dominated by a single contributor, reducing change resilience.",
+        evidenceMetrics: {
+          filesWithSingleContributorRatio: round45(filesWithSingleContributorRatio),
+          modulesDominatedBySingleContributorRatio: round45(
+            modulesDominatedBySingleContributorRatio
+          )
+        },
+        impact: round45(ownershipDistributionPenalty2 * 0.35)
+      });
+    }
+    if (entropyPenalty >= 0.35) {
+      pushIssue(issues, {
+        id: "health.ownership.low_author_entropy",
+        ruleId: "ownership.author_entropy",
+        signal: "ownership.authorEntropy",
+        dimension: "ownershipDistribution",
+        target: input.structural.targetPath,
+        message: "Contributor distribution is narrow across the repository.",
+        evidenceMetrics: {
+          authorEntropy: round45(authorEntropy),
+          topAuthorCommitShare: round45(topAuthorCommitShare)
+        },
+        impact: round45(ownershipDistributionPenalty2 * 0.25)
+      });
+    }
+    const modularityHealth2 = clamp01(1 - modularityPenalty);
+    const changeHygieneHealth2 = clamp01(1 - changeHygienePenalty);
+    const testHealthScore2 = clamp01(1 - testHealthPenalty);
+    const ownershipDistributionHealth2 = clamp01(1 - ownershipDistributionPenalty2);
+    const normalizedScore2 = clamp01(
+      modularityHealth2 * DIMENSION_WEIGHTS.modularity + changeHygieneHealth2 * DIMENSION_WEIGHTS.changeHygiene + testHealthScore2 * DIMENSION_WEIGHTS.testHealth + ownershipDistributionHealth2 * DIMENSION_WEIGHTS.ownershipDistribution
+    );
+    const topIssues2 = [...issues].sort(
+      (a, b) => b.impact - a.impact || a.id.localeCompare(b.id) || a.target.localeCompare(b.target)
+    ).slice(0, 12).map(({ impact: _impact, ...issue }) => issue);
+    return {
+      healthScore: toPercentage(normalizedScore2),
+      normalizedScore: round45(normalizedScore2),
+      dimensions: {
+        modularity: toPercentage(modularityHealth2),
+        changeHygiene: toPercentage(changeHygieneHealth2),
+        testHealth: toPercentage(testHealthScore2),
+        ownershipDistribution: toPercentage(ownershipDistributionHealth2)
+      },
+      topIssues: topIssues2,
+      trace: {
+        schemaVersion: HEALTH_TRACE_VERSION,
+        dimensions: [
+          createDimensionTrace("modularity", modularityHealth2, modularityFactors),
+          createDimensionTrace("changeHygiene", changeHygieneHealth2, changeHygieneFactors),
+          createDimensionTrace("testHealth", testHealthScore2, testHealthFactors),
+          createDimensionTrace(
+            "ownershipDistribution",
+            ownershipDistributionHealth2,
+            ownershipDistributionFactors2
+          )
+        ]
+      }
+    };
+  }
+  const ownershipDistributionPenalty = clamp01(0.12 * ownershipPenaltyMultiplier);
+  const ownershipDistributionFactors = [
+    {
+      factorId: "health.ownership.missing_git_history",
+      penalty: ownershipDistributionPenalty,
+      rawMetrics: {
+        gitHistoryAvailable: 0
+      },
+      normalizedMetrics: {
+        ownershipDistributionPenalty: round45(ownershipDistributionPenalty)
+      },
+      weight: 1,
+      evidence: [{ kind: "repository_metric", metric: "evolution.available" }]
+    }
+  ];
+  const modularityHealth = clamp01(1 - modularityPenalty);
+  const changeHygieneHealth = clamp01(1 - changeHygienePenalty);
+  const testHealthScore = clamp01(1 - testHealthPenalty);
+  const ownershipDistributionHealth = clamp01(1 - ownershipDistributionPenalty);
   const normalizedScore = clamp01(
-    modularityQuality * DIMENSION_WEIGHTS.modularity + changeHygieneQuality * DIMENSION_WEIGHTS.changeHygiene + testHealthQuality * DIMENSION_WEIGHTS.testHealth
+    modularityHealth * DIMENSION_WEIGHTS.modularity + changeHygieneHealth * DIMENSION_WEIGHTS.changeHygiene + testHealthScore * DIMENSION_WEIGHTS.testHealth + ownershipDistributionHealth * DIMENSION_WEIGHTS.ownershipDistribution
   );
   const topIssues = [...issues].sort(
     (a, b) => b.impact - a.impact || a.id.localeCompare(b.id) || a.target.localeCompare(b.target)
-  ).slice(0, 8).map(({ impact: _impact, ...issue }) => issue);
+  ).slice(0, 12).map(({ impact: _impact, ...issue }) => issue);
   return {
-    qualityScore: toPercentage(normalizedScore),
+    healthScore: toPercentage(normalizedScore),
     normalizedScore: round45(normalizedScore),
     dimensions: {
-      modularity: toPercentage(modularityQuality),
-      changeHygiene: toPercentage(changeHygieneQuality),
-      testHealth: toPercentage(testHealthQuality)
+      modularity: toPercentage(modularityHealth),
+      changeHygiene: toPercentage(changeHygieneHealth),
+      testHealth: toPercentage(testHealthScore),
+      ownershipDistribution: toPercentage(ownershipDistributionHealth)
     },
-    topIssues
+    topIssues,
+    trace: {
+      schemaVersion: HEALTH_TRACE_VERSION,
+      dimensions: [
+        createDimensionTrace("modularity", modularityHealth, modularityFactors),
+        createDimensionTrace("changeHygiene", changeHygieneHealth, changeHygieneFactors),
+        createDimensionTrace("testHealth", testHealthScore, testHealthFactors),
+        createDimensionTrace(
+          "ownershipDistribution",
+          ownershipDistributionHealth,
+          ownershipDistributionFactors
+        )
+      ]
+    }
   };
 };
 
@@ -4640,7 +5307,7 @@ var normalizeWithScale = (value, scale) => {
   }
   return toUnitInterval((value - scale.lower) / (scale.upper - scale.lower));
 };
-var normalizePath2 = (path) => path.replaceAll("\\", "/");
+var normalizePath3 = (path) => path.replaceAll("\\", "/");
 var computeAggregatorAttenuation = (input) => {
   const { fanIn, fanOut, inCycle, evolutionMetrics, config } = input;
   if (!config.enabled || inCycle > 0) {
@@ -4715,7 +5382,7 @@ var computeEvolutionHistoryConfidence = (structural, evolution, evolutionByFile)
   }
   let coveredFiles = 0;
   for (const file of structural.files) {
-    if (evolutionByFile.has(normalizePath2(file.id))) {
+    if (evolutionByFile.has(normalizePath3(file.id))) {
       coveredFiles += 1;
     }
   }
@@ -4909,7 +5576,7 @@ var mapEvolutionByFile = (evolution) => {
     return /* @__PURE__ */ new Map();
   }
   return new Map(
-    evolution.files.map((fileMetrics) => [normalizePath2(fileMetrics.filePath), fileMetrics])
+    evolution.files.map((fileMetrics) => [normalizePath3(fileMetrics.filePath), fileMetrics])
   );
 };
 var computeEvolutionScales = (evolutionByFile, config) => {
@@ -4933,7 +5600,7 @@ var computeEvolutionScales = (evolutionByFile, config) => {
   };
 };
 var inferModuleName = (filePath, config) => {
-  const normalized = normalizePath2(filePath);
+  const normalized = normalizePath3(filePath);
   const parts = normalized.split("/").filter((part) => part.length > 0);
   if (parts.length <= 1) {
     return config.module.rootLabel;
@@ -4954,7 +5621,7 @@ var buildFragileClusters = (structural, evolution, fileScoresByFile, config) =>
   const clusters = [];
   let cycleClusterCount = 0;
   for (const cycle of structural.cycles) {
-    const files = [...new Set(cycle.nodes.map((node) => normalizePath2(node)))].filter(
+    const files = [...new Set(cycle.nodes.map((node) => normalizePath3(node)))].filter(
       (filePath) => fileScoresByFile.has(filePath)
     );
     if (files.length < 2) {
@@ -4986,8 +5653,8 @@ var buildFragileClusters = (structural, evolution, fileScoresByFile, config) =>
       )
     );
     const selectedPairs = candidates.filter((pair) => pair.couplingScore >= threshold).map((pair) => ({
-      fileA: normalizePath2(pair.fileA),
-      fileB: normalizePath2(pair.fileB),
+      fileA: normalizePath3(pair.fileA),
+      fileB: normalizePath3(pair.fileB),
       couplingScore: pair.couplingScore
     })).filter(
       (pair) => pair.fileA !== pair.fileB && fileScoresByFile.has(pair.fileA) && fileScoresByFile.has(pair.fileB)
@@ -5065,7 +5732,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
   );
   const evolutionScales = computeEvolutionScales(evolutionByFile, config);
   const cycleFileSet = new Set(
-    structural.cycles.flatMap((cycle) => cycle.nodes.map((node) => normalizePath2(node)))
+    structural.cycles.flatMap((cycle) => cycle.nodes.map((node) => normalizePath3(node)))
   );
   const fanInScale = buildQuantileScale(
     structural.files.map((file) => logScale(file.fanIn)),
@@ -5088,7 +5755,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
     external: external.available
   });
   const fileRiskContexts = structural.files.map((file) => {
-    const filePath = normalizePath2(file.id);
+    const filePath = normalizePath3(file.id);
     const inCycle = cycleFileSet.has(filePath) ? 1 : 0;
     const fanInRisk = normalizeWithScale(logScale(file.fanIn), fanInScale);
     const fanOutRisk = normalizeWithScale(logScale(file.fanOut), fanOutScale);
@@ -5704,31 +6371,9 @@ var evaluateRepositoryRisk = (input, options = {}) => {
   };
 };
 
-// src/application/todo-fixme-counter.ts
-import * as ts2 from "typescript";
-var markerRegex = /\b(?:TODO|FIXME)\b/gi;
-var countMarkers = (text) => text.match(markerRegex)?.length ?? 0;
-var countTodoFixmeInComments = (content) => {
-  const scanner = ts2.createScanner(
-    ts2.ScriptTarget.Latest,
-    false,
-    ts2.LanguageVariant.Standard,
-    content
-  );
-  let total = 0;
-  let token = scanner.scan();
-  while (token !== ts2.SyntaxKind.EndOfFileToken) {
-    if (token === ts2.SyntaxKind.SingleLineCommentTrivia || token === ts2.SyntaxKind.MultiLineCommentTrivia) {
-      total += countMarkers(scanner.getTokenText());
-    }
-    token = scanner.scan();
-  }
-  return total;
-};
-
 // src/application/run-analyze-command.ts
 var resolveTargetPath = (inputPath, cwd) => resolve3(cwd, inputPath ?? ".");
-var riskProfileConfig = {
+var scoringProfileConfig = {
   default: void 0,
   personal: {
     evolutionFactorWeights: {
@@ -5740,8 +6385,17 @@ var riskProfileConfig = {
     }
   }
 };
-var resolveRiskConfigForProfile = (riskProfile) => {
-  return riskProfileConfig[riskProfile ?? "default"];
+var healthProfileConfig = {
+  default: void 0,
+  personal: {
+    ownershipPenaltyMultiplier: 0.25
+  }
+};
+var resolveRiskConfigForProfile = (scoringProfile) => {
+  return scoringProfileConfig[scoringProfile ?? "default"];
+};
+var resolveHealthConfigForProfile = (scoringProfile) => {
+  return healthProfileConfig[scoringProfile ?? "default"];
 };
 var createExternalProgressReporter = (logger) => {
   let lastLoggedProgress = 0;
@@ -5854,18 +6508,6 @@ var createEvolutionProgressReporter = (logger) => {
     }
   };
 };
-var collectTodoFixmeCount = async (targetPath, structural) => {
-  const filePaths2 = [...structural.files].map((file) => file.relativePath).sort((a, b) => a.localeCompare(b));
-  let total = 0;
-  for (const relativePath of filePaths2) {
-    try {
-      const content = await readFile2(join4(targetPath, relativePath), "utf8");
-      total += countTodoFixmeInComments(content);
-    } catch {
-    }
-  }
-  return total;
-};
 var collectAnalysisInputs = async (inputPath, authorIdentityMode, options = {}, logger = createSilentLogger()) => {
   const invocationCwd = process.env["INIT_CWD"] ?? process.cwd();
   const targetPath = resolveTargetPath(inputPath, invocationCwd);
@@ -5908,14 +6550,10 @@ var collectAnalysisInputs = async (inputPath, authorIdentityMode, options = {},
   } else {
     logger.warn(`external analysis unavailable: ${external.reason}`);
   }
-  logger.info("collecting quality text signals");
-  const todoFixmeCount = await collectTodoFixmeCount(targetPath, structural);
-  logger.debug(`quality text signals: todoFixmeCount=${todoFixmeCount}`);
   return {
     structural,
     evolution,
-    external,
-    todoFixmeCount
+    external
   };
 };
 var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logger = createSilentLogger()) => {
@@ -5926,32 +6564,33 @@ var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logg
     logger
   );
   logger.info("computing risk summary");
-  const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
+  const riskConfig = resolveRiskConfigForProfile(options.scoringProfile);
+  const healthConfig = resolveHealthConfigForProfile(options.scoringProfile);
   const risk = computeRepositoryRiskSummary({
     structural: analysisInputs.structural,
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     ...riskConfig === void 0 ? {} : { config: riskConfig }
   });
-  const quality = computeRepositoryQualitySummary({
+  const health = computeRepositoryHealthSummary({
     structural: analysisInputs.structural,
     evolution: analysisInputs.evolution,
-    todoFixmeCount: analysisInputs.todoFixmeCount
+    ...healthConfig === void 0 ? {} : { config: healthConfig }
   });
   logger.info(
-    `analysis completed (riskScore=${risk.riskScore}, qualityScore=${quality.qualityScore})`
+    `analysis completed (riskScore=${risk.riskScore}, healthScore=${health.healthScore})`
   );
   return {
     structural: analysisInputs.structural,
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     risk,
-    quality
+    health
   };
 };
 
 // src/application/run-check-command.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
 
 // src/application/build-analysis-snapshot.ts
 var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logger) => {
@@ -5963,7 +6602,8 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
     },
     logger
   );
-  const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
+  const riskConfig = resolveRiskConfigForProfile(options.scoringProfile);
+  const healthConfig = resolveHealthConfigForProfile(options.scoringProfile);
   const evaluation = evaluateRepositoryRisk(
     {
       structural: analysisInputs.structural,
@@ -5978,10 +6618,10 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     risk: evaluation.summary,
-    quality: computeRepositoryQualitySummary({
+    health: computeRepositoryHealthSummary({
       structural: analysisInputs.structural,
       evolution: analysisInputs.evolution,
-      todoFixmeCount: analysisInputs.todoFixmeCount
+      ...healthConfig === void 0 ? {} : { config: healthConfig }
     })
   };
   return createSnapshot({
@@ -5990,7 +6630,7 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
     analysisConfig: {
       authorIdentityMode,
       includeTrace: options.includeTrace,
-      riskProfile: options.riskProfile ?? "default",
+      scoringProfile: options.scoringProfile ?? "default",
       recentWindowDays: analysisInputs.evolution.available ? analysisInputs.evolution.metrics.recentWindowDays : options.recentWindowDays ?? null
     }
   });
@@ -6025,7 +6665,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
     authorIdentityMode,
     {
       includeTrace: options.includeTrace,
-      ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+      ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
       ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
     },
     logger
@@ -6034,7 +6674,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
   let diff;
   if (options.baselinePath !== void 0) {
     logger.info(`loading baseline snapshot: ${options.baselinePath}`);
-    const baselineRaw = await readFile3(options.baselinePath, "utf8");
+    const baselineRaw = await readFile2(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -6073,7 +6713,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
 };
 
 // src/application/run-ci-command.ts
-import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { relative as relative2, resolve as resolve4 } from "path";
 var isPathOutsideBase = (value) => {
   return value === ".." || value.startsWith("../") || value.startsWith("..\\");
@@ -6094,7 +6734,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
     authorIdentityMode,
     {
       includeTrace: options.includeTrace,
-      ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+      ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
       ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
     },
     logger
@@ -6153,7 +6793,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
             authorIdentityMode,
             {
               includeTrace: options.includeTrace,
-              ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+              ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
               ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
             },
             logger
@@ -6173,7 +6813,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
     diff = compareSnapshots(current, baseline);
   } else if (options.baselinePath !== void 0) {
     logger.info(`loading baseline snapshot: ${options.baselinePath}`);
-    const baselineRaw = await readFile4(options.baselinePath, "utf8");
+    const baselineRaw = await readFile3(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -6221,7 +6861,7 @@ ${ciMarkdown}`;
 };
 
 // src/application/run-report-command.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
 var runReportCommand = async (inputPath, authorIdentityMode, options, logger = createSilentLogger()) => {
   logger.info("building analysis snapshot");
   const current = await buildAnalysisSnapshot(
@@ -6229,7 +6869,7 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     authorIdentityMode,
     {
       includeTrace: options.includeTrace,
-      ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+      ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
       ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
     },
     logger
@@ -6243,7 +6883,7 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     report = createReport(current);
   } else {
     logger.info(`loading baseline snapshot: ${options.comparePath}`);
-    const baselineRaw = await readFile5(options.comparePath, "utf8");
+    const baselineRaw = await readFile4(options.comparePath, "utf8");
     const baseline = parseSnapshot(baselineRaw);
     const diff = compareSnapshots(current, baseline);
     report = createReport(current, diff);
@@ -6286,7 +6926,8 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
     logger
   );
   logger.info("computing explainable risk summary");
-  const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
+  const riskConfig = resolveRiskConfigForProfile(options.scoringProfile);
+  const healthConfig = resolveHealthConfigForProfile(options.scoringProfile);
   const evaluation = evaluateRepositoryRisk(
     {
       structural: analysisInputs.structural,
@@ -6304,14 +6945,14 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     risk: evaluation.summary,
-    quality: computeRepositoryQualitySummary({
+    health: computeRepositoryHealthSummary({
       structural: analysisInputs.structural,
       evolution: analysisInputs.evolution,
-      todoFixmeCount: analysisInputs.todoFixmeCount
+      ...healthConfig === void 0 ? {} : { config: healthConfig }
     })
   };
   logger.info(
-    `explanation completed (riskScore=${summary.risk.riskScore}, qualityScore=${summary.quality.qualityScore})`
+    `explanation completed (riskScore=${summary.risk.riskScore}, healthScore=${summary.health.healthScore})`
   );
   return {
     summary,
@@ -6368,7 +7009,7 @@ var renderReportHighlightsText = (report) => {
   lines.push("Repository Summary");
   lines.push(`  target: ${report.repository.targetPath}`);
   lines.push(`  riskScore: ${report.repository.riskScore}`);
-  lines.push(`  qualityScore: ${report.quality.qualityScore}`);
+  lines.push(`  healthScore: ${report.health.healthScore}`);
   lines.push(`  normalizedScore: ${report.repository.normalizedScore}`);
   lines.push(`  riskTier: ${report.repository.riskTier}`);
   lines.push("");
@@ -6384,7 +7025,7 @@ var renderReportHighlightsMarkdown = (report) => {
   lines.push("## Repository Summary");
   lines.push(`- target: \`${report.repository.targetPath}\``);
   lines.push(`- riskScore: \`${report.repository.riskScore}\``);
-  lines.push(`- qualityScore: \`${report.quality.qualityScore}\``);
+  lines.push(`- healthScore: \`${report.health.healthScore}\``);
   lines.push(`- normalizedScore: \`${report.repository.normalizedScore}\``);
   lines.push(`- riskTier: \`${report.repository.riskTier}\``);
   lines.push("");
@@ -6402,7 +7043,7 @@ var renderCompactText = (report, explainSummary) => {
   lines.push("Repository");
   lines.push(`  target: ${report.repository.targetPath}`);
   lines.push(`  riskScore: ${report.repository.riskScore}`);
-  lines.push(`  qualityScore: ${report.quality.qualityScore}`);
+  lines.push(`  healthScore: ${report.health.healthScore}`);
   lines.push(`  riskTier: ${report.repository.riskTier}`);
   lines.push(
     `  dimensions: structural=${report.repository.dimensionScores.structural ?? "n/a"}, evolution=${report.repository.dimensionScores.evolution ?? "n/a"}, external=${report.repository.dimensionScores.external ?? "n/a"}, interactions=${report.repository.dimensionScores.interactions ?? "n/a"}`
@@ -6428,7 +7069,7 @@ var renderCompactMarkdown = (report, explainSummary) => {
   lines.push("## Repository");
   lines.push(`- target: \`${report.repository.targetPath}\``);
   lines.push(`- riskScore: \`${report.repository.riskScore}\``);
-  lines.push(`- qualityScore: \`${report.quality.qualityScore}\``);
+  lines.push(`- healthScore: \`${report.health.healthScore}\``);
   lines.push(`- riskTier: \`${report.repository.riskTier}\``);
   lines.push(
     `- dimensions: structural=\`${report.repository.dimensionScores.structural ?? "n/a"}\`, evolution=\`${report.repository.dimensionScores.evolution ?? "n/a"}\`, external=\`${report.repository.dimensionScores.external ?? "n/a"}\`, interactions=\`${report.repository.dimensionScores.interactions ?? "n/a"}\``
@@ -6447,12 +7088,12 @@ var renderCompactMarkdown = (report, explainSummary) => {
   }
   return lines.join("\n");
 };
-var riskProfileOption = () => new Option(
-  "--risk-profile <profile>",
-  "risk profile: default (balanced) or personal (down-weights single-maintainer ownership penalties)"
+var scoringProfileOption = () => new Option(
+  "--scoring-profile <profile>",
+  "scoring profile: default (balanced) or personal (down-weights single-maintainer ownership penalties for risk and health ownership)"
 ).choices(["default", "personal"]).default("default");
 program.name("codesentinel").description("Structural and evolutionary risk analysis for TypeScript/JavaScript codebases").version(version);
-program.command("analyze").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("analyze").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -6475,7 +7116,7 @@ program.command("analyze").argument("[path]", "path to the project to analyze").
     const summary = await runAnalyzeCommand(
       path,
       options.authorIdentity,
-      { recentWindowDays: options.recentWindowDays, riskProfile: options.riskProfile },
+      { recentWindowDays: options.recentWindowDays, scoringProfile: options.scoringProfile },
       logger
     );
     const outputMode = options.json === true ? "json" : options.output;
@@ -6483,7 +7124,7 @@ program.command("analyze").argument("[path]", "path to the project to analyze").
 `);
   }
 );
-program.command("explain").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("explain").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -6509,7 +7150,7 @@ program.command("explain").argument("[path]", "path to the project to analyze").
       ...options.module === void 0 ? {} : { module: options.module },
       top: Number.isFinite(top) ? top : 5,
       recentWindowDays: options.recentWindowDays,
-      riskProfile: options.riskProfile,
+      scoringProfile: options.scoringProfile,
       format: options.format
     };
     const result = await runExplainCommand(path, options.authorIdentity, explainOptions, logger);
@@ -6547,7 +7188,7 @@ program.command("dependency-risk").argument("<dependency>", "dependency spec to
 `);
   }
 );
-program.command("report").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("report").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -6576,7 +7217,7 @@ program.command("report").argument("[path]", "path to the project to analyze").a
         ...options.compare === void 0 ? {} : { comparePath: options.compare },
         ...options.snapshot === void 0 ? {} : { snapshotPath: options.snapshot },
         includeTrace: options.trace,
-        riskProfile: options.riskProfile,
+        scoringProfile: options.scoringProfile,
         recentWindowDays: options.recentWindowDays
       },
       logger
@@ -6587,7 +7228,7 @@ program.command("report").argument("[path]", "path to the project to analyze").a
     }
   }
 );
-program.command("run").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("run").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -6598,7 +7239,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
     "log verbosity: silent, error, warn, info, debug (logs are written to stderr)"
   ).choices(["silent", "error", "warn", "info", "debug"]).default(parseLogLevel(process.env["CODESENTINEL_LOG_LEVEL"]))
 ).addOption(
-  new Option("--format <mode>", "combined output format: text, md, json").choices(["text", "md", "json"]).default("text")
+  new Option("--format <mode>", "combined output format: text, md, json").choices(["text", "md", "json"]).default("md")
 ).addOption(
   new Option("--detail <level>", "run detail level: compact (default), standard, full").choices(["compact", "standard", "full"]).default("compact")
 ).option("--file <path>", "explain a specific file target").option("--module <name>", "explain a specific module target").option("--top <count>", "number of top hotspots to explain when no target is selected", "5").option("--compare <baseline>", "compare against a baseline snapshot JSON file").option("--snapshot <path>", "write current snapshot JSON artifact").option("--no-trace", "disable trace embedding in generated snapshot").addOption(
@@ -6619,7 +7260,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
         top: Number.isFinite(top) ? top : 5,
         format: options.format,
         recentWindowDays: options.recentWindowDays,
-        riskProfile: options.riskProfile
+        scoringProfile: options.scoringProfile
       },
       logger
     );
@@ -6633,7 +7274,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
     }
     const report = options.compare === void 0 ? createReport(snapshot) : createReport(
       snapshot,
-      compareSnapshots(snapshot, parseSnapshot(await readFile6(options.compare, "utf8")))
+      compareSnapshots(snapshot, parseSnapshot(await readFile5(options.compare, "utf8")))
     );
     if (options.format === "json") {
       const analyzeSummaryOutput = formatAnalyzeOutput(explain.summary, "summary");
@@ -6677,7 +7318,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
               },
               report: {
                 repository: report.repository,
-                quality: report.quality,
+                health: report.health,
                 hotspots: report.hotspots.slice(0, 5),
                 structural: report.structural,
                 external: report.external
@@ -6825,24 +7466,28 @@ var parseMainBranches = (options) => {
   return unique.length > 0 ? unique : void 0;
 };
 var buildGateConfigFromOptions = (options) => {
-  const maxRepoDelta = parseGateNumber(options.maxRepoDelta, "--max-repo-delta");
+  const maxRiskDelta = parseGateNumber(options.maxRiskDelta, "--max-risk-delta");
+  const maxHealthDelta = parseGateNumber(options.maxHealthDelta, "--max-health-delta");
   const maxNewHotspots = parseGateNumber(options.maxNewHotspots, "--max-new-hotspots");
-  const maxRepoScore = parseGateNumber(options.maxRepoScore, "--max-repo-score");
+  const maxRiskScore = parseGateNumber(options.maxRiskScore, "--max-risk-score");
+  const minHealthScore = parseGateNumber(options.minHealthScore, "--min-health-score");
   const newHotspotScoreThreshold = parseGateNumber(
     options.newHotspotScoreThreshold,
     "--new-hotspot-score-threshold"
   );
   return {
-    ...maxRepoDelta === void 0 ? {} : { maxRepoDelta },
+    ...maxRiskDelta === void 0 ? {} : { maxRiskDelta },
+    ...maxHealthDelta === void 0 ? {} : { maxHealthDelta },
     ...options.noNewCycles === true ? { noNewCycles: true } : {},
     ...options.noNewHighRiskDeps === true ? { noNewHighRiskDeps: true } : {},
     ...maxNewHotspots === void 0 ? {} : { maxNewHotspots },
-    ...maxRepoScore === void 0 ? {} : { maxRepoScore },
+    ...maxRiskScore === void 0 ? {} : { maxRiskScore },
+    ...minHealthScore === void 0 ? {} : { minHealthScore },
     ...newHotspotScoreThreshold === void 0 ? {} : { newHotspotScoreThreshold },
     failOn: options.failOn
   };
 };
-program.command("check").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("check").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -6852,7 +7497,10 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
     "--log-level <level>",
     "log verbosity: silent, error, warn, info, debug (logs are written to stderr)"
   ).choices(["silent", "error", "warn", "info", "debug"]).default(parseLogLevel(process.env["CODESENTINEL_LOG_LEVEL"]))
-).option("--compare <baseline>", "baseline snapshot path").option("--max-repo-delta <value>", "maximum allowed normalized repository score increase").option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-repo-score <score>", "absolute repository score limit (0..100)").addOption(
+).option("--compare <baseline>", "baseline snapshot path").option("--max-risk-delta <value>", "maximum allowed normalized risk score increase").option(
+  "--max-health-delta <value>",
+  "maximum allowed normalized health score regression versus baseline (requires --compare)"
+).option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-risk-score <score>", "absolute risk score limit (0..100)").option("--min-health-score <score>", "minimum health score threshold (0..100)").addOption(
   new Option("--fail-on <level>", "failing severity threshold").choices(["error", "warn"]).default("error")
 ).addOption(
   new Option("--format <mode>", "output format: text, json, md").choices(["text", "json", "md"]).default("text")
@@ -6872,7 +7520,7 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
         {
           ...options.compare === void 0 ? {} : { baselinePath: options.compare },
           includeTrace: options.trace,
-          riskProfile: options.riskProfile,
+          scoringProfile: options.scoringProfile,
           recentWindowDays: options.recentWindowDays,
           gateConfig,
           outputFormat: options.format,
@@ -6896,7 +7544,7 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
     }
   }
 );
-program.command("ci").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("ci").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -6920,7 +7568,10 @@ program.command("ci").argument("[path]", "path to the project to analyze").addOp
 ).option(
   "--main-branches <names>",
   "comma-separated default branch candidates for auto baseline resolution (for example: main,master)"
-).option("--snapshot <path>", "write current snapshot JSON to path").option("--report <path>", "write markdown CI summary report").option("--json-output <path>", "write machine-readable CI JSON output").option("--max-repo-delta <value>", "maximum allowed normalized repository score increase").option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-repo-score <score>", "absolute repository score limit (0..100)").addOption(
+).option("--snapshot <path>", "write current snapshot JSON to path").option("--report <path>", "write markdown CI summary report").option("--json-output <path>", "write machine-readable CI JSON output").option("--max-risk-delta <value>", "maximum allowed normalized risk score increase").option(
+  "--max-health-delta <value>",
+  "maximum allowed normalized health score regression versus baseline"
+).option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-risk-score <score>", "absolute risk score limit (0..100)").option("--min-health-score <score>", "minimum health score threshold (0..100)").addOption(
   new Option("--fail-on <level>", "failing severity threshold").choices(["error", "warn"]).default("error")
 ).option("--no-trace", "disable trace embedding in generated snapshot").addOption(
   new Option(
@@ -6945,7 +7596,7 @@ program.command("ci").argument("[path]", "path to the project to analyze").addOp
           ...options.report === void 0 ? {} : { reportPath: options.report },
           ...options.jsonOutput === void 0 ? {} : { jsonOutputPath: options.jsonOutput },
           includeTrace: options.trace,
-          riskProfile: options.riskProfile,
+          scoringProfile: options.scoringProfile,
           recentWindowDays: options.recentWindowDays,
           gateConfig
         },