@getcodesentinel/codesentinel 1.16.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,23 +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(`  staticAnalysis: ${report.quality.dimensions.staticAnalysis}`);
-  lines.push(`  complexity: ${report.quality.dimensions.complexity}`);
-  lines.push(`  duplication: ${report.quality.dimensions.duplication}`);
-  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}${ruleSuffix} @ ${issue.target}: ${issue.message}`
     );
   }
-  if (report.quality.topIssues.length === 0) {
+  if (report.health.topIssues.length === 0) {
     lines.push("    - none");
   }
   lines.push("");
@@ -1823,20 +1821,18 @@ 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(`- staticAnalysis: \`${report.quality.dimensions.staticAnalysis}\``);
-  lines.push(`- complexity: \`${report.quality.dimensions.complexity}\``);
-  lines.push(`- duplication: \`${report.quality.dimensions.duplication}\``);
-  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}\`${ruleSuffix} (\`${issue.dimension}\`) @ \`${issue.target}\`: ${issue.message}`
@@ -1992,8 +1988,8 @@ var validateGateConfig = (input) => {
   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.maxQualityDelta !== void 0 && (!Number.isFinite(config.maxQualityDelta) || config.maxQualityDelta < 0)) {
-    throw new GovernanceConfigurationError("max-quality-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");
@@ -2001,8 +1997,8 @@ var validateGateConfig = (input) => {
   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.minQualityScore !== void 0 && (!Number.isFinite(config.minQualityScore) || config.minQualityScore < 0 || config.minQualityScore > 100)) {
-    throw new GovernanceConfigurationError("min-quality-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(
@@ -2030,17 +2026,17 @@ var evaluateGates = (input) => {
       );
     }
   }
-  if (config.minQualityScore !== void 0) {
-    evaluatedGates.push("min-quality-score");
-    const current = input.current.analysis.quality.qualityScore;
-    if (current < config.minQualityScore) {
+  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-quality-score",
+          "min-health-score",
           "error",
-          `Quality score ${current} is below configured minimum ${config.minQualityScore}.`,
+          `Health score ${current} is below configured minimum ${config.minHealthScore}.`,
           [input.current.analysis.structural.targetPath],
-          [{ kind: "repository_metric", metric: "qualityScore" }]
+          [{ kind: "repository_metric", metric: "healthScore" }]
         )
       );
     }
@@ -2065,22 +2061,22 @@ var evaluateGates = (input) => {
       );
     }
   }
-  if (config.maxQualityDelta !== void 0) {
-    evaluatedGates.push("max-quality-delta");
-    requireDiff(input, "max-quality-delta");
+  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-quality-delta requires baseline snapshot");
+      throw new GovernanceConfigurationError("max-health-delta requires baseline snapshot");
     }
-    const delta = input.current.analysis.quality.normalizedScore - baseline.analysis.quality.normalizedScore;
-    if (delta < -config.maxQualityDelta) {
+    const delta = input.current.analysis.health.normalizedScore - baseline.analysis.health.normalizedScore;
+    if (delta < -config.maxHealthDelta) {
       violations.push(
         makeViolation(
-          "max-quality-delta",
+          "max-health-delta",
           "error",
-          `Quality normalized score delta ${delta.toFixed(4)} is below allowed minimum ${(-config.maxQualityDelta).toFixed(4)}.`,
+          `Health normalized score delta ${delta.toFixed(4)} is below allowed minimum ${(-config.maxHealthDelta).toFixed(4)}.`,
           [input.current.analysis.structural.targetPath],
-          [{ kind: "repository_metric", metric: "qualityNormalizedScore" }]
+          [{ kind: "repository_metric", metric: "healthNormalizedScore" }]
         )
       );
     }
@@ -2542,8 +2538,8 @@ var resolveAutoBaselineRef = async (input) => {
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve6 } from "path";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 
 // src/application/format-analyze-output.ts
@@ -2584,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);
@@ -3161,7 +3157,7 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
     );
     return "skip";
   }
-  return await new Promise((resolve7) => {
+  return await new Promise((resolve6) => {
     emitKeypressEvents(stdin);
     let selectedIndex = 0;
     const previousRawMode = stdin.isRaw;
@@ -3186,7 +3182,7 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
       } else {
         stderr.write("\n");
       }
-      resolve7(choice);
+      resolve6(choice);
     };
     const onKeypress = (_str, key) => {
       if (key.ctrl === true && key.name === "c") {
@@ -3265,7 +3261,7 @@ var checkForCliUpdates = async (input) => {
 };
 
 // src/application/run-analyze-command.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve3 } from "path";
 
 // ../code-graph/dist/index.js
 import { extname, isAbsolute, relative, resolve as resolve2 } from "path";
@@ -4313,539 +4309,7 @@ var analyzeRepositoryEvolutionFromGit = (input, onProgress) => {
   return analyzeRepositoryEvolution(input, historyProvider, onProgress);
 };
 
-// ../quality-signals/dist/index.js
-import { readFile as readFile2 } from "fs/promises";
-import { existsSync as existsSync2 } from "fs";
-import { join as join4, relative as relative2, resolve as resolve3 } from "path";
-import { ESLint } from "eslint";
-import * as ts2 from "typescript";
-import * as ts3 from "typescript";
-var markerRegex = /\b(?:TODO|FIXME)\b/gi;
-var countMarkers = (text) => text.match(markerRegex)?.length ?? 0;
-var countTodoFixmeInComments = (content) => {
-  const scanner = ts3.createScanner(
-    ts3.ScriptTarget.Latest,
-    false,
-    ts3.LanguageVariant.Standard,
-    content
-  );
-  let total = 0;
-  let token = scanner.scan();
-  while (token !== ts3.SyntaxKind.EndOfFileToken) {
-    if (token === ts3.SyntaxKind.SingleLineCommentTrivia || token === ts3.SyntaxKind.MultiLineCommentTrivia) {
-      total += countMarkers(scanner.getTokenText());
-    }
-    token = scanner.scan();
-  }
-  return total;
-};
-var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"]);
-var normalizePath2 = (value) => value.replaceAll("\\", "/");
-var isTestPath = (path) => {
-  const normalized = normalizePath2(path);
-  return normalized.includes("/__tests__/") || normalized.includes("\\__tests__\\") || normalized.includes(".test.") || normalized.includes(".spec.");
-};
-var collectTodoFixmeCommentCount = 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 collectEslintSignals = async (targetPath, structural, logger) => {
-  const absoluteFiles = structural.files.map((file) => join4(targetPath, file.relativePath));
-  if (absoluteFiles.length === 0) {
-    return {
-      errorCount: 0,
-      warningCount: 0,
-      filesWithIssues: 0,
-      ruleCounts: []
-    };
-  }
-  try {
-    const eslint = new ESLint({ cwd: targetPath, errorOnUnmatchedPattern: false });
-    const results = await eslint.lintFiles(absoluteFiles);
-    let errorCount = 0;
-    let warningCount = 0;
-    let filesWithIssues = 0;
-    const ruleCounts = /* @__PURE__ */ new Map();
-    for (const result of results) {
-      if (result.errorCount + result.warningCount > 0) {
-        filesWithIssues += 1;
-      }
-      errorCount += result.errorCount;
-      warningCount += result.warningCount;
-      for (const message of result.messages) {
-        if (message.ruleId === null) {
-          continue;
-        }
-        const severity = message.severity >= 2 ? "error" : "warn";
-        const current = ruleCounts.get(message.ruleId);
-        if (current === void 0) {
-          ruleCounts.set(message.ruleId, {
-            ruleId: message.ruleId,
-            severity,
-            count: 1
-          });
-        } else {
-          ruleCounts.set(message.ruleId, {
-            ruleId: current.ruleId,
-            severity: current.severity === "error" || severity === "error" ? "error" : "warn",
-            count: current.count + 1
-          });
-        }
-      }
-    }
-    return {
-      errorCount,
-      warningCount,
-      filesWithIssues,
-      ruleCounts: [...ruleCounts.values()].sort(
-        (a, b) => b.count - a.count || a.ruleId.localeCompare(b.ruleId)
-      )
-    };
-  } catch (error) {
-    logger.warn(
-      `quality signals: eslint collection unavailable (${error instanceof Error ? error.message : "unknown error"})`
-    );
-    return void 0;
-  }
-};
-var collectTypeScriptSignals = (targetPath, logger) => {
-  const tsconfigPath = ts2.findConfigFile(targetPath, ts2.sys.fileExists, "tsconfig.json");
-  if (tsconfigPath === void 0) {
-    return void 0;
-  }
-  try {
-    const parsed = ts2.getParsedCommandLineOfConfigFile(
-      tsconfigPath,
-      {},
-      {
-        ...ts2.sys,
-        onUnRecoverableConfigFileDiagnostic: () => {
-          throw new Error(`failed to parse ${tsconfigPath}`);
-        }
-      }
-    );
-    if (parsed === void 0) {
-      return void 0;
-    }
-    const program2 = ts2.createProgram({ rootNames: parsed.fileNames, options: parsed.options });
-    const diagnostics = [
-      ...program2.getOptionsDiagnostics(),
-      ...program2.getGlobalDiagnostics(),
-      ...program2.getSyntacticDiagnostics(),
-      ...program2.getSemanticDiagnostics()
-    ];
-    let errorCount = 0;
-    let warningCount = 0;
-    const fileSet = /* @__PURE__ */ new Set();
-    for (const diagnostic of diagnostics) {
-      if (diagnostic.category === ts2.DiagnosticCategory.Error) {
-        errorCount += 1;
-      } else if (diagnostic.category === ts2.DiagnosticCategory.Warning) {
-        warningCount += 1;
-      }
-      if (diagnostic.file !== void 0) {
-        const path = normalizePath2(relative2(targetPath, diagnostic.file.fileName));
-        fileSet.add(path);
-      }
-    }
-    return {
-      errorCount,
-      warningCount,
-      filesWithDiagnostics: fileSet.size
-    };
-  } catch (error) {
-    logger.warn(
-      `quality signals: typescript diagnostic collection unavailable (${error instanceof Error ? error.message : "unknown error"})`
-    );
-    return void 0;
-  }
-};
-var cyclomaticIncrement = (node) => {
-  if (ts2.isIfStatement(node) || ts2.isForStatement(node) || ts2.isForInStatement(node) || ts2.isForOfStatement(node) || ts2.isWhileStatement(node) || ts2.isDoStatement(node) || ts2.isCatchClause(node) || ts2.isConditionalExpression(node)) {
-    return 1;
-  }
-  if (ts2.isCaseClause(node)) {
-    return 1;
-  }
-  if (ts2.isBinaryExpression(node)) {
-    if (node.operatorToken.kind === ts2.SyntaxKind.AmpersandAmpersandToken || node.operatorToken.kind === ts2.SyntaxKind.BarBarToken || node.operatorToken.kind === ts2.SyntaxKind.QuestionQuestionToken) {
-      return 1;
-    }
-  }
-  return 0;
-};
-var computeCyclomaticComplexity = (node) => {
-  let complexity = 1;
-  const visit = (current) => {
-    complexity += cyclomaticIncrement(current);
-    if (current !== node && (ts2.isFunctionLike(current) || ts2.isArrowFunction(current) || ts2.isMethodDeclaration(current) || ts2.isConstructorDeclaration(current))) {
-      return;
-    }
-    ts2.forEachChild(current, visit);
-  };
-  visit(node);
-  return complexity;
-};
-var collectFunctionComplexities = (content, fileName) => {
-  const sourceFile = ts2.createSourceFile(fileName, content, ts2.ScriptTarget.Latest, true);
-  const complexities = [];
-  const visit = (node) => {
-    if (ts2.isFunctionDeclaration(node) || ts2.isMethodDeclaration(node) || ts2.isFunctionExpression(node) || ts2.isArrowFunction(node) || ts2.isConstructorDeclaration(node) || ts2.isGetAccessorDeclaration(node) || ts2.isSetAccessorDeclaration(node)) {
-      complexities.push(computeCyclomaticComplexity(node));
-    }
-    ts2.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  if (complexities.length === 0) {
-    return [computeCyclomaticComplexity(sourceFile)];
-  }
-  return complexities;
-};
-var collectComplexitySignals = async (targetPath, structural) => {
-  const complexities = [];
-  for (const file of structural.files) {
-    const extension = file.relativePath.slice(file.relativePath.lastIndexOf("."));
-    if (!SOURCE_EXTENSIONS2.has(extension)) {
-      continue;
-    }
-    try {
-      const content = await readFile2(join4(targetPath, file.relativePath), "utf8");
-      complexities.push(...collectFunctionComplexities(content, file.relativePath));
-    } catch {
-    }
-  }
-  if (complexities.length === 0) {
-    return void 0;
-  }
-  const averageCyclomatic = complexities.reduce((sum, value) => sum + value, 0) / complexities.length;
-  const maxCyclomatic = Math.max(...complexities);
-  const highComplexityFileCount = complexities.filter((value) => value >= 15).length;
-  return {
-    averageCyclomatic,
-    maxCyclomatic,
-    highComplexityFileCount,
-    analyzedFileCount: complexities.length
-  };
-};
-var DUPLICATION_MIN_BLOCK_TOKENS = 40;
-var DUPLICATION_KGRAM_TOKENS = 25;
-var DUPLICATION_WINDOW_SIZE = 4;
-var DUPLICATION_MAX_FILES = 5e3;
-var DUPLICATION_MAX_TOKENS_PER_FILE = 12e3;
-var DUPLICATION_MAX_FINGERPRINTS_PER_FILE = 1200;
-var DUPLICATION_EXACT_MAX_WINDOWS = 25e4;
-var HASH_BASE = 16777619;
-var hashString32 = (value) => {
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619) >>> 0;
-  }
-  return hash >>> 0;
-};
-var computeRollingBasePower = (kgramSize) => {
-  let value = 1;
-  for (let index = 1; index < kgramSize; index += 1) {
-    value = Math.imul(value, HASH_BASE) >>> 0;
-  }
-  return value;
-};
-var tokenizeForDuplication = (content, filePath) => {
-  const languageVariant = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? ts2.LanguageVariant.JSX : ts2.LanguageVariant.Standard;
-  const scanner = ts2.createScanner(ts2.ScriptTarget.Latest, true, languageVariant, content);
-  const tokens = [];
-  let token = scanner.scan();
-  while (token !== ts2.SyntaxKind.EndOfFileToken) {
-    if (token !== ts2.SyntaxKind.WhitespaceTrivia && token !== ts2.SyntaxKind.NewLineTrivia && token !== ts2.SyntaxKind.SingleLineCommentTrivia && token !== ts2.SyntaxKind.MultiLineCommentTrivia) {
-      if (token === ts2.SyntaxKind.Identifier || token === ts2.SyntaxKind.PrivateIdentifier) {
-        tokens.push("id");
-      } else if (token === ts2.SyntaxKind.StringLiteral || token === ts2.SyntaxKind.NoSubstitutionTemplateLiteral || token === ts2.SyntaxKind.TemplateHead || token === ts2.SyntaxKind.TemplateMiddle || token === ts2.SyntaxKind.TemplateTail || token === ts2.SyntaxKind.NumericLiteral || token === ts2.SyntaxKind.BigIntLiteral || token === ts2.SyntaxKind.RegularExpressionLiteral) {
-        tokens.push("lit");
-      } else {
-        const stable = ts2.tokenToString(token) ?? ts2.SyntaxKind[token] ?? `${token}`;
-        tokens.push(stable);
-      }
-    }
-    token = scanner.scan();
-  }
-  return tokens;
-};
-var buildKgramHashes = (tokenValues, kgramSize) => {
-  if (tokenValues.length < kgramSize) {
-    return [];
-  }
-  const fingerprints = [];
-  const removePower = computeRollingBasePower(kgramSize);
-  let hash = 0;
-  for (let index = 0; index < kgramSize; index += 1) {
-    hash = Math.imul(hash, HASH_BASE) + (tokenValues[index] ?? 0) >>> 0;
-  }
-  fingerprints.push({ hash, start: 0 });
-  for (let start = 1; start <= tokenValues.length - kgramSize; start += 1) {
-    const removed = tokenValues[start - 1] ?? 0;
-    const added = tokenValues[start + kgramSize - 1] ?? 0;
-    const removedContribution = Math.imul(removed, removePower) >>> 0;
-    const shifted = Math.imul(hash - removedContribution >>> 0, HASH_BASE) >>> 0;
-    hash = shifted + added >>> 0;
-    fingerprints.push({ hash, start });
-  }
-  return fingerprints;
-};
-var winnowFingerprints = (kgrams, windowSize) => {
-  if (kgrams.length === 0) {
-    return [];
-  }
-  if (kgrams.length <= windowSize) {
-    const minimum = [...kgrams].sort(
-      (left, right) => left.hash - right.hash || right.start - left.start
-    )[0];
-    return minimum === void 0 ? [] : [minimum];
-  }
-  const selected = /* @__PURE__ */ new Map();
-  for (let start = 0; start <= kgrams.length - windowSize; start += 1) {
-    let best = kgrams[start];
-    if (best === void 0) {
-      continue;
-    }
-    for (let offset = 1; offset < windowSize; offset += 1) {
-      const candidate = kgrams[start + offset];
-      if (candidate === void 0) {
-        continue;
-      }
-      if (candidate.hash < best.hash || candidate.hash === best.hash && candidate.start > best.start) {
-        best = candidate;
-      }
-    }
-    selected.set(`${best.hash}:${best.start}`, best);
-  }
-  return [...selected.values()].sort((left, right) => left.start - right.start);
-};
-var capFingerprints = (fingerprints, maxFingerprints) => {
-  if (fingerprints.length <= maxFingerprints) {
-    return fingerprints;
-  }
-  const step = fingerprints.length / maxFingerprints;
-  const capped = [];
-  for (let index = 0; index < maxFingerprints; index += 1) {
-    const selected = fingerprints[Math.floor(index * step)];
-    if (selected !== void 0) {
-      capped.push(selected);
-    }
-  }
-  return capped;
-};
-var tokenBlockSignature = (tokens, start, blockLength) => {
-  if (start < 0 || start + blockLength > tokens.length) {
-    return void 0;
-  }
-  return tokens.slice(start, start + blockLength).join(" ");
-};
-var mergeTokenRanges = (ranges) => {
-  if (ranges.length === 0) {
-    return [];
-  }
-  const sorted = [...ranges].sort(
-    (left, right) => left.start - right.start || left.end - right.end
-  );
-  const merged = [];
-  for (const range of sorted) {
-    const previous = merged[merged.length - 1];
-    if (previous === void 0 || range.start > previous.end) {
-      merged.push({ ...range });
-      continue;
-    }
-    previous.end = Math.max(previous.end, range.end);
-  }
-  return merged;
-};
-var aggregateDuplicationFromSignatures = (signatures, fileByPath) => {
-  let duplicatedBlockCount = 0;
-  const duplicatedRanges = /* @__PURE__ */ new Map();
-  for (const entries of signatures.values()) {
-    if (entries.length <= 1) {
-      continue;
-    }
-    const uniqueEntries = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      uniqueEntries.set(`${entry.file}:${entry.start}`, entry);
-    }
-    if (uniqueEntries.size <= 1) {
-      continue;
-    }
-    duplicatedBlockCount += uniqueEntries.size - 1;
-    for (const entry of uniqueEntries.values()) {
-      const source = fileByPath.get(entry.file);
-      if (source === void 0) {
-        continue;
-      }
-      const signature = tokenBlockSignature(
-        source.tokens,
-        entry.start,
-        DUPLICATION_MIN_BLOCK_TOKENS
-      );
-      if (signature === void 0) {
-        continue;
-      }
-      const ranges = duplicatedRanges.get(entry.file) ?? [];
-      ranges.push({
-        start: entry.start,
-        end: Math.min(source.tokens.length, entry.start + DUPLICATION_MIN_BLOCK_TOKENS)
-      });
-      duplicatedRanges.set(entry.file, ranges);
-    }
-  }
-  let duplicatedTokenCount = 0;
-  for (const ranges of duplicatedRanges.values()) {
-    const mergedRanges = mergeTokenRanges(ranges);
-    duplicatedTokenCount += mergedRanges.reduce((sum, range) => sum + (range.end - range.start), 0);
-  }
-  return {
-    duplicatedBlockCount,
-    duplicatedTokenCount,
-    filesWithDuplication: duplicatedRanges.size
-  };
-};
-var collectExactTokenDuplication = (analyzedFiles) => {
-  const signatures = /* @__PURE__ */ new Map();
-  for (const file of analyzedFiles) {
-    const tokenValues = file.tokens.map((token) => hashString32(token));
-    const windows = buildKgramHashes(tokenValues, DUPLICATION_MIN_BLOCK_TOKENS);
-    for (const window of windows) {
-      const signature = tokenBlockSignature(
-        file.tokens,
-        window.start,
-        DUPLICATION_MIN_BLOCK_TOKENS
-      );
-      if (signature === void 0) {
-        continue;
-      }
-      const entries = signatures.get(signature) ?? [];
-      entries.push({ file: file.file, start: window.start });
-      signatures.set(signature, entries);
-    }
-  }
-  const fileByPath = new Map(analyzedFiles.map((file) => [file.file, file]));
-  return aggregateDuplicationFromSignatures(signatures, fileByPath);
-};
-var collectWinnowingDuplication = (analyzedFiles) => {
-  const signatures = /* @__PURE__ */ new Map();
-  for (const file of analyzedFiles) {
-    const tokenValues = file.tokens.map((token) => hashString32(token));
-    const kgrams = buildKgramHashes(tokenValues, DUPLICATION_KGRAM_TOKENS);
-    const fingerprints = capFingerprints(
-      winnowFingerprints(kgrams, DUPLICATION_WINDOW_SIZE),
-      DUPLICATION_MAX_FINGERPRINTS_PER_FILE
-    );
-    for (const fingerprint of fingerprints) {
-      const signature = tokenBlockSignature(
-        file.tokens,
-        fingerprint.start,
-        DUPLICATION_MIN_BLOCK_TOKENS
-      );
-      if (signature === void 0) {
-        continue;
-      }
-      const entries = signatures.get(signature) ?? [];
-      entries.push({ file: file.file, start: fingerprint.start });
-      signatures.set(signature, entries);
-    }
-  }
-  const fileByPath = new Map(analyzedFiles.map((file) => [file.file, file]));
-  return aggregateDuplicationFromSignatures(signatures, fileByPath);
-};
-var collectDuplicationSignals = async (targetPath, structural) => {
-  const files = [...structural.files].map((file) => file.relativePath).sort((left, right) => left.localeCompare(right)).filter((filePath) => SOURCE_EXTENSIONS2.has(filePath.slice(filePath.lastIndexOf(".")))).filter((filePath) => isTestPath(filePath) === false).slice(0, DUPLICATION_MAX_FILES);
-  const analyzedFiles = [];
-  let significantTokenCount = 0;
-  let exactWindowCount = 0;
-  for (const relativePath of files) {
-    try {
-      const content = await readFile2(join4(targetPath, relativePath), "utf8");
-      const tokens = tokenizeForDuplication(content, relativePath).slice(
-        0,
-        DUPLICATION_MAX_TOKENS_PER_FILE
-      );
-      significantTokenCount += tokens.length;
-      if (tokens.length < DUPLICATION_MIN_BLOCK_TOKENS) {
-        continue;
-      }
-      exactWindowCount += tokens.length - DUPLICATION_MIN_BLOCK_TOKENS + 1;
-      analyzedFiles.push({
-        file: relativePath,
-        tokens
-      });
-    } catch {
-    }
-  }
-  if (analyzedFiles.length === 0) {
-    return void 0;
-  }
-  const mode = exactWindowCount <= DUPLICATION_EXACT_MAX_WINDOWS ? "exact-token" : "winnowing";
-  const aggregated = mode === "exact-token" ? collectExactTokenDuplication(analyzedFiles) : collectWinnowingDuplication(analyzedFiles);
-  const duplicatedLineRatio = significantTokenCount === 0 ? 0 : Math.min(1, aggregated.duplicatedTokenCount / significantTokenCount);
-  return {
-    mode,
-    duplicatedLineRatio,
-    duplicatedBlockCount: aggregated.duplicatedBlockCount,
-    filesWithDuplication: aggregated.filesWithDuplication
-  };
-};
-var toRatio = (value) => {
-  if (typeof value !== "number" || Number.isFinite(value) === false) {
-    return null;
-  }
-  return Math.min(1, Math.max(0, value / 100));
-};
-var collectCoverageSignals = async (targetPath, logger) => {
-  const configuredPath = process.env["CODESENTINEL_QUALITY_COVERAGE_SUMMARY"];
-  const summaryPath = configuredPath === void 0 || configuredPath.trim().length === 0 ? join4(targetPath, "coverage", "coverage-summary.json") : resolve3(targetPath, configuredPath);
-  if (!existsSync2(summaryPath)) {
-    return void 0;
-  }
-  try {
-    const raw = await readFile2(summaryPath, "utf8");
-    const parsed = JSON.parse(raw);
-    return {
-      lineCoverage: toRatio(parsed.total?.lines?.pct),
-      branchCoverage: toRatio(parsed.total?.branches?.pct),
-      functionCoverage: toRatio(parsed.total?.functions?.pct),
-      statementCoverage: toRatio(parsed.total?.statements?.pct)
-    };
-  } catch (error) {
-    logger.warn(
-      `quality signals: coverage summary parse failed at ${summaryPath} (${error instanceof Error ? error.message : "unknown error"})`
-    );
-    return void 0;
-  }
-};
-var collectQualitySignals = async (targetPath, structural, logger) => {
-  const [todoFixmeCommentCount, eslint, complexity, duplication, coverage] = await Promise.all([
-    collectTodoFixmeCommentCount(targetPath, structural),
-    collectEslintSignals(targetPath, structural, logger),
-    collectComplexitySignals(targetPath, structural),
-    collectDuplicationSignals(targetPath, structural),
-    collectCoverageSignals(targetPath, logger)
-  ]);
-  const typescript = collectTypeScriptSignals(targetPath, logger);
-  return {
-    todoFixmeCommentCount,
-    ...eslint === void 0 ? {} : { eslint },
-    ...typescript === void 0 ? {} : { typescript },
-    ...complexity === void 0 ? {} : { complexity },
-    ...duplication === void 0 ? {} : { duplication },
-    ...coverage === void 0 ? {} : { coverage }
-  };
-};
-
-// ../quality-engine/dist/index.js
+// ../health-engine/dist/index.js
 var clamp01 = (value) => {
   if (!Number.isFinite(value)) {
     return 0;
@@ -4885,20 +4349,45 @@ var concentration = (rawValues) => {
   return clamp01(normalized);
 };
 var DIMENSION_WEIGHTS = {
-  modularity: 0.2,
-  changeHygiene: 0.2,
-  staticAnalysis: 0.2,
-  complexity: 0.15,
-  duplication: 0.1,
-  testHealth: 0.15
-};
-var QUALITY_TRACE_VERSION = "1";
-var toPercentage = (normalizedQuality) => round45(clamp01(normalizedQuality) * 100);
-var logScaled = (value, scale) => {
-  if (scale <= 0) {
+  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;
   }
-  return clamp01(Math.log1p(Math.max(0, value)) / Math.log1p(scale));
+  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 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,
@@ -4909,22 +4398,32 @@ var toFactorTrace = (spec) => ({
   weight: round45(spec.weight),
   evidence: spec.evidence
 });
-var createDimensionTrace = (dimension, quality, factors) => ({
+var createDimensionTrace = (dimension, health, factors) => ({
   dimension,
-  normalizedScore: round45(clamp01(quality)),
-  score: toPercentage(quality),
+  normalizedScore: round45(clamp01(health)),
+  score: toPercentage(health),
   factors: factors.map((factor) => toFactorTrace(factor))
 });
 var filePaths = (structural) => structural.files.map((file) => file.relativePath);
-var isTestPath2 = (path) => {
-  const normalized = path.toLowerCase();
-  return normalized.includes("/__tests__/") || normalized.includes("\\__tests__\\") || normalized.includes(".test.") || normalized.includes(".spec.");
+var normalizePath2 = (value) => value.replaceAll("\\", "/").toLowerCase();
+var isTestPath = (path) => {
+  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")) {
     return false;
   }
-  return !isTestPath2(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({
@@ -4932,484 +4431,704 @@ var pushIssue = (issues, 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 signals = input.signals;
-  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;
+  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 centralityConcentration = average([fanInConcentration, fanOutConcentration]);
-  if (cycleCount > 0) {
-    pushIssue(issues, {
-      id: "quality.modularity.structural_cycles",
-      ruleId: "graph.structural_cycles",
-      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.55)
-    });
-  }
-  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",
-      ruleId: "graph.centrality_concentration",
-      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.45)
-    });
+  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: "quality.modularity.structural_cycles",
-      penalty: cyclePenalty,
+      factorId: "health.modularity.cycle_density",
+      penalty: cycleDensityPenalty,
       rawMetrics: {
-        cycleCount,
-        averageCycleSize: round45(cycleSizeAverage)
+        cycleCount: input.structural.metrics.cycleCount,
+        cycleEdgeRatio: round45(cycleEdgeRatio),
+        cycleNodeRatio: round45(cycleNodeRatio)
       },
       normalizedMetrics: {
-        cyclePenalty: round45(cyclePenalty)
+        cycleDensityPenalty: round45(cycleDensityPenalty)
       },
-      weight: 0.55,
-      evidence: [{ kind: "repository_metric", metric: "structural.cycles" }]
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "structural.cycleEdgeRatio" }]
     },
     {
-      factorId: "quality.modularity.centrality_concentration",
-      penalty: centralityConcentration,
+      factorId: "health.modularity.fan_concentration",
+      penalty: fanConcentration,
       rawMetrics: {
         fanInConcentration: round45(fanInConcentration),
         fanOutConcentration: round45(fanOutConcentration)
       },
       normalizedMetrics: {
-        centralityConcentration: round45(centralityConcentration)
+        fanConcentration: round45(fanConcentration)
       },
-      weight: 0.45,
+      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 = clamp01(
-    modularityFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
+  const modularityPenalty = dampenForSmallSamples(
+    weightedPenalty(modularityFactors),
+    sourceFileCount,
+    8,
+    0.45
   );
-  let churnConcentration = 0;
-  let volatilityConcentration = 0;
-  let couplingDensity = 0;
-  let couplingIntensity = 0;
+  if (cycleDensityPenalty >= 0.35) {
+    const firstCycle = input.structural.cycles[0];
+    pushIssue(issues, {
+      id: "health.modularity.cycle_density",
+      ruleId: "graph.cycle_density",
+      signal: "structural.cycleEdgeRatio",
+      dimension: "modularity",
+      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)
+    });
+  }
+  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: "health.modularity.centrality_concentration",
+      ruleId: "graph.centrality_concentration",
+      signal: "structural.centralityPressure",
+      dimension: "modularity",
+      target: hottest?.path ?? input.structural.targetPath,
+      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)
+    });
+  }
+  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",
-        ruleId: "git.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.4)
+        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",
-        ruleId: "git.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.3)
+        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",
-        ruleId: "git.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.3)
+        message: "Dense co-change clusters suggest wider coordination scope per change.",
+        evidenceMetrics: {
+          denseCoChangePairRatio: round45(denseCoChangePairRatio)
+        },
+        impact: round45(coChangeClusterPenalty * 0.3)
       });
     }
   }
-  const todoFixmeCommentCount = Math.max(0, signals?.todoFixmeCommentCount ?? 0);
-  const todoFixmePenalty = logScaled(todoFixmeCommentCount, 80) * 0.08;
-  if (todoFixmeCommentCount > 0) {
-    pushIssue(issues, {
-      id: "quality.change_hygiene.todo_fixme_load",
-      ruleId: "comments.todo_fixme",
-      dimension: "changeHygiene",
-      target: input.structural.targetPath,
-      message: `Found ${todoFixmeCommentCount} TODO/FIXME comment marker(s); cleanup debt is accumulating.`,
-      impact: round45(todoFixmePenalty * 0.4)
-    });
-  }
   const changeHygieneFactors = [
     {
-      factorId: "quality.change_hygiene.churn_concentration",
-      penalty: churnConcentration,
+      factorId: "health.change_hygiene.churn_concentration",
+      penalty: churnConcentrationPenalty,
       rawMetrics: {
-        churnConcentration: round45(churnConcentration)
+        top10PercentFilesChurnShare: round45(top10PercentFilesChurnShare)
       },
       normalizedMetrics: {
-        churnConcentration: round45(churnConcentration)
-      },
-      weight: 0.35,
-      evidence: [{ kind: "repository_metric", metric: "evolution.churn" }]
-    },
-    {
-      factorId: "quality.change_hygiene.volatility_concentration",
-      penalty: volatilityConcentration,
-      rawMetrics: {
-        volatilityConcentration: round45(volatilityConcentration)
+        churnConcentrationPenalty: round45(churnConcentrationPenalty)
       },
-      normalizedMetrics: {
-        volatilityConcentration: round45(volatilityConcentration)
-      },
-      weight: 0.25,
-      evidence: [{ kind: "repository_metric", metric: "evolution.recentVolatility" }]
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "evolution.top10PercentFilesChurnShare" }]
     },
     {
-      factorId: "quality.change_hygiene.coupling_density",
-      penalty: average([couplingDensity, couplingIntensity]),
+      factorId: "health.change_hygiene.volatility_concentration",
+      penalty: volatilityConcentrationPenalty,
       rawMetrics: {
-        couplingDensity: round45(couplingDensity),
-        couplingIntensity: round45(couplingIntensity)
+        top10PercentFilesVolatilityShare: round45(top10PercentFilesVolatilityShare)
       },
       normalizedMetrics: {
-        couplingPressure: round45(average([couplingDensity, couplingIntensity]))
+        volatilityConcentrationPenalty: round45(volatilityConcentrationPenalty)
       },
       weight: 0.3,
-      evidence: [{ kind: "repository_metric", metric: "evolution.coupling" }]
+      evidence: [
+        {
+          kind: "repository_metric",
+          metric: "evolution.top10PercentFilesVolatilityShare"
+        }
+      ]
     },
     {
-      factorId: "quality.change_hygiene.todo_fixme_load",
-      penalty: todoFixmePenalty,
+      factorId: "health.change_hygiene.dense_co_change_clusters",
+      penalty: coChangeClusterPenalty,
       rawMetrics: {
-        todoFixmeCommentCount
+        denseCoChangePairRatio: round45(denseCoChangePairRatio)
       },
       normalizedMetrics: {
-        todoFixmePenalty: round45(todoFixmePenalty)
+        coChangeClusterPenalty: round45(coChangeClusterPenalty)
       },
-      weight: 0.1,
-      evidence: [{ kind: "repository_metric", metric: "comments.todo_fixme" }]
+      weight: 0.3,
+      evidence: [{ kind: "repository_metric", metric: "evolution.denseCoChangePairRatio" }]
     }
   ];
-  const changeHygienePenalty = input.evolution.available ? clamp01(changeHygieneFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)) : 0.2;
-  const eslint = signals?.eslint;
-  const tsc = signals?.typescript;
-  const sourceCount = Math.max(1, input.structural.files.length);
-  const eslintErrorRate = (eslint?.errorCount ?? 0) / sourceCount;
-  const eslintWarnRate = (eslint?.warningCount ?? 0) / sourceCount;
-  const tsErrorRate = (tsc?.errorCount ?? 0) / sourceCount;
-  const tsWarnRate = (tsc?.warningCount ?? 0) / sourceCount;
-  const staticAnalysisFactors = [
-    {
-      factorId: "quality.static_analysis.eslint_errors",
-      penalty: clamp01(eslintErrorRate / 0.5),
-      rawMetrics: {
-        eslintErrorCount: eslint?.errorCount ?? 0,
-        eslintFilesWithIssues: eslint?.filesWithIssues ?? 0
-      },
-      normalizedMetrics: {
-        eslintErrorRate: round45(eslintErrorRate)
-      },
-      weight: 0.5,
-      evidence: [{ kind: "repository_metric", metric: "eslint.errorCount" }]
-    },
+  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 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: "quality.static_analysis.eslint_warnings",
-      penalty: clamp01(eslintWarnRate / 1.2),
+      factorId: "health.test_health.test_file_presence",
+      penalty: testPresencePenalty,
       rawMetrics: {
-        eslintWarningCount: eslint?.warningCount ?? 0
+        sourceFiles,
+        testFiles
       },
       normalizedMetrics: {
-        eslintWarningRate: round45(eslintWarnRate)
+        testPresencePenalty: round45(testPresencePenalty)
       },
-      weight: 0.2,
-      evidence: [{ kind: "repository_metric", metric: "eslint.warningCount" }]
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "tests.filePresence" }]
     },
     {
-      factorId: "quality.static_analysis.typescript_errors",
-      penalty: clamp01(tsErrorRate / 0.35),
+      factorId: "health.test_health.test_to_source_ratio",
+      penalty: testRatioPenalty,
       rawMetrics: {
-        typeScriptErrorCount: tsc?.errorCount ?? 0,
-        typeScriptFilesWithDiagnostics: tsc?.filesWithDiagnostics ?? 0
+        testToSourceRatio: round45(testRatio)
       },
       normalizedMetrics: {
-        typeScriptErrorRate: round45(tsErrorRate)
+        testRatioPenalty: round45(testRatioPenalty)
       },
-      weight: 0.2,
-      evidence: [{ kind: "repository_metric", metric: "typescript.errorCount" }]
+      weight: 0.45,
+      evidence: [{ kind: "repository_metric", metric: "tests.testToSourceRatio" }]
     },
     {
-      factorId: "quality.static_analysis.typescript_warnings",
-      penalty: clamp01(tsWarnRate / 0.9),
+      factorId: "health.test_health.testing_directory_presence",
+      penalty: testingDirectoryPenalty,
       rawMetrics: {
-        typeScriptWarningCount: tsc?.warningCount ?? 0
+        testingDirectoryPresent: testingDirectoryPresent ? 1 : 0
       },
       normalizedMetrics: {
-        typeScriptWarningRate: round45(tsWarnRate)
+        testingDirectoryPenalty: round45(testingDirectoryPenalty)
       },
-      weight: 0.1,
-      evidence: [{ kind: "repository_metric", metric: "typescript.warningCount" }]
+      weight: 0.15,
+      evidence: [{ kind: "repository_metric", metric: "tests.directoryPresence" }]
     }
   ];
-  const staticAnalysisPenalty = clamp01(
-    staticAnalysisFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
+  const testHealthPenalty = dampenForSmallSamples(
+    weightedPenalty(testHealthFactors),
+    sourceFiles,
+    10,
+    0.3
   );
-  if ((eslint?.errorCount ?? 0) > 0) {
-    const topRule = [...eslint?.ruleCounts ?? []].sort(
-      (a, b) => b.count - a.count || a.ruleId.localeCompare(b.ruleId)
-    )[0];
+  if (sourceFiles > 0 && testFiles === 0) {
     pushIssue(issues, {
-      id: "quality.static_analysis.eslint_errors",
-      ruleId: topRule?.ruleId ?? "eslint",
-      dimension: "staticAnalysis",
+      id: "health.test_health.low_test_presence",
+      ruleId: "tests.file_presence",
+      signal: "tests.filePresence",
+      dimension: "testHealth",
       target: input.structural.targetPath,
-      message: topRule === void 0 ? `ESLint reported ${eslint?.errorCount ?? 0} error(s).` : `ESLint reported ${eslint?.errorCount ?? 0} error(s); top rule ${topRule.ruleId} (${topRule.count}).`,
-      severity: "error",
-      impact: round45(staticAnalysisPenalty * 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)
     });
   }
-  if ((tsc?.errorCount ?? 0) > 0) {
+  if (sourceFiles > 0 && testRatio < 0.12) {
     pushIssue(issues, {
-      id: "quality.static_analysis.typescript_errors",
-      ruleId: "typescript",
-      dimension: "staticAnalysis",
+      id: "health.test_health.low_test_ratio",
+      ruleId: "tests.ratio",
+      signal: "tests.testToSourceRatio",
+      dimension: "testHealth",
       target: input.structural.targetPath,
-      message: `TypeScript reported ${tsc?.errorCount ?? 0} error diagnostic(s).`,
-      severity: "error",
-      impact: round45(staticAnalysisPenalty * 0.4)
+      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 complexity = signals?.complexity;
-  const avgComplexity = complexity?.averageCyclomatic ?? 0;
-  const maxComplexity = complexity?.maxCyclomatic ?? 0;
-  const highComplexityRatio = (complexity?.analyzedFileCount ?? 0) === 0 ? 0 : (complexity?.highComplexityFileCount ?? 0) / Math.max(1, complexity?.analyzedFileCount ?? 1);
-  const complexityFactors = [
-    {
-      factorId: "quality.complexity.average_cyclomatic",
-      penalty: clamp01(avgComplexity / 16),
-      rawMetrics: {
-        averageCyclomatic: round45(avgComplexity)
+  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" }]
       },
-      normalizedMetrics: {
-        averageCyclomaticPenalty: round45(clamp01(avgComplexity / 16))
+      {
+        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"
+          }
+        ]
       },
-      weight: 0.4,
-      evidence: [{ kind: "repository_metric", metric: "complexity.averageCyclomatic" }]
-    },
-    {
-      factorId: "quality.complexity.max_cyclomatic",
-      penalty: clamp01(maxComplexity / 35),
-      rawMetrics: {
-        maxCyclomatic: round45(maxComplexity)
+      {
+        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" }]
       },
-      normalizedMetrics: {
-        maxCyclomaticPenalty: round45(clamp01(maxComplexity / 35))
+      {
+        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" }]
       },
-      weight: 0.35,
-      evidence: [{ kind: "repository_metric", metric: "complexity.maxCyclomatic" }]
-    },
-    {
-      factorId: "quality.complexity.high_complexity_ratio",
-      penalty: clamp01(highComplexityRatio / 0.35),
-      rawMetrics: {
-        highComplexityFileCount: complexity?.highComplexityFileCount ?? 0,
-        analyzedFileCount: complexity?.analyzedFileCount ?? 0
+      {
+        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"
+          }
+        ]
       },
-      normalizedMetrics: {
-        highComplexityRatio: round45(highComplexityRatio)
+      {
+        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" }]
       },
-      weight: 0.25,
-      evidence: [{ kind: "repository_metric", metric: "complexity.highComplexityFileCount" }]
+      {
+        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)
+      });
     }
-  ];
-  const complexityPenalty = clamp01(
-    complexityFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
-  );
-  if (maxComplexity >= 20 || highComplexityRatio >= 0.2) {
-    pushIssue(issues, {
-      id: "quality.complexity.high_cyclomatic",
-      ruleId: "complexity.cyclomatic",
-      dimension: "complexity",
-      target: input.structural.targetPath,
-      message: `Complexity is elevated (avg=${round45(avgComplexity)}, max=${round45(maxComplexity)}).`,
-      impact: round45(complexityPenalty * 0.6)
-    });
-  }
-  const duplication = signals?.duplication;
-  const duplicatedLineRatio = duplication?.duplicatedLineRatio ?? 0;
-  const duplicatedBlockCount = duplication?.duplicatedBlockCount ?? 0;
-  const duplicationFactors = [
-    {
-      factorId: "quality.duplication.line_ratio",
-      penalty: clamp01(duplicatedLineRatio / 0.25),
-      rawMetrics: {
-        duplicatedLineRatio: round45(duplicatedLineRatio)
-      },
-      normalizedMetrics: {
-        duplicatedLineRatioPenalty: round45(clamp01(duplicatedLineRatio / 0.25))
-      },
-      weight: 0.7,
-      evidence: [{ kind: "repository_metric", metric: "duplication.duplicatedLineRatio" }]
-    },
-    {
-      factorId: "quality.duplication.block_count",
-      penalty: logScaled(duplicatedBlockCount, 120),
-      rawMetrics: {
-        duplicatedBlockCount,
-        filesWithDuplication: duplication?.filesWithDuplication ?? 0
-      },
-      normalizedMetrics: {
-        duplicatedBlockPenalty: round45(logScaled(duplicatedBlockCount, 120))
-      },
-      weight: 0.3,
-      evidence: [{ kind: "repository_metric", metric: "duplication.duplicatedBlockCount" }]
+    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)
+      });
     }
-  ];
-  const duplicationPenalty = clamp01(
-    duplicationFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
-  );
-  if (duplicatedLineRatio >= 0.08) {
-    pushIssue(issues, {
-      id: "quality.duplication.high_duplication",
-      ruleId: "duplication.line_ratio",
-      dimension: "duplication",
-      target: input.structural.targetPath,
-      message: `Duplication ratio is high (${toPercentage(duplicatedLineRatio)}%).`,
-      impact: round45(duplicationPenalty * 0.6)
-    });
-  }
-  const paths = filePaths(input.structural);
-  const testFiles = paths.filter((path) => isTestPath2(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.35);
-  const coverageSignals = signals?.coverage;
-  const coverageValues = [
-    coverageSignals?.lineCoverage,
-    coverageSignals?.branchCoverage,
-    coverageSignals?.functionCoverage,
-    coverageSignals?.statementCoverage
-  ].filter((value) => value !== null && value !== void 0);
-  const coverageRatio = coverageValues.length === 0 ? null : average(coverageValues);
-  const coveragePenalty = coverageRatio === null ? 0.2 : 1 - clamp01(coverageRatio / 0.8);
-  const testHealthFactors = [
-    {
-      factorId: "quality.test_health.test_presence",
-      penalty: testPresencePenalty,
-      rawMetrics: {
-        sourceFiles,
-        testFiles,
-        testRatio: round45(testRatio)
-      },
-      normalizedMetrics: {
-        testPresencePenalty: round45(testPresencePenalty)
+    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)
       },
-      weight: 0.55,
-      evidence: [{ kind: "repository_metric", metric: "tests.file_ratio" }]
-    },
+      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: "quality.test_health.coverage",
-      penalty: coveragePenalty,
+      factorId: "health.ownership.missing_git_history",
+      penalty: ownershipDistributionPenalty,
       rawMetrics: {
-        lineCoverage: coverageSignals?.lineCoverage ?? null,
-        branchCoverage: coverageSignals?.branchCoverage ?? null,
-        functionCoverage: coverageSignals?.functionCoverage ?? null,
-        statementCoverage: coverageSignals?.statementCoverage ?? null
+        gitHistoryAvailable: 0
       },
       normalizedMetrics: {
-        coverageRatio: coverageRatio === null ? null : round45(coverageRatio),
-        coveragePenalty: round45(coveragePenalty)
+        ownershipDistributionPenalty: round45(ownershipDistributionPenalty)
       },
-      weight: 0.45,
-      evidence: [{ kind: "repository_metric", metric: "coverage.summary" }]
+      weight: 1,
+      evidence: [{ kind: "repository_metric", metric: "evolution.available" }]
     }
   ];
-  const testHealthPenalty = clamp01(
-    testHealthFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
-  );
-  if (sourceFiles > 0 && testRatio < 0.2) {
-    pushIssue(issues, {
-      id: "quality.test_health.low_test_presence",
-      ruleId: "tests.file_ratio",
-      dimension: "testHealth",
-      target: input.structural.targetPath,
-      message: `Detected ${testFiles} test file(s) for ${sourceFiles} source file(s).`,
-      severity: testRatio === 0 ? "error" : "warn",
-      impact: round45(testHealthPenalty * 0.4)
-    });
-  }
-  if (coverageRatio !== null && coverageRatio < 0.6) {
-    pushIssue(issues, {
-      id: "quality.test_health.low_coverage",
-      ruleId: "coverage.threshold",
-      dimension: "testHealth",
-      target: input.structural.targetPath,
-      message: `Coverage is below threshold (${toPercentage(coverageRatio)}%).`,
-      impact: round45(testHealthPenalty * 0.35)
-    });
-  }
-  const modularityQuality = clamp01(1 - modularityPenalty);
-  const changeHygieneQuality = clamp01(1 - changeHygienePenalty);
-  const staticAnalysisQuality = clamp01(1 - staticAnalysisPenalty);
-  const complexityQuality = clamp01(1 - complexityPenalty);
-  const duplicationQuality = clamp01(1 - duplicationPenalty);
-  const testHealthQuality = clamp01(1 - testHealthPenalty);
+  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 + staticAnalysisQuality * DIMENSION_WEIGHTS.staticAnalysis + complexityQuality * DIMENSION_WEIGHTS.complexity + duplicationQuality * DIMENSION_WEIGHTS.duplication + 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, 12).map(({ impact: _impact, ...issue }) => issue);
   return {
-    qualityScore: toPercentage(normalizedScore),
+    healthScore: toPercentage(normalizedScore),
     normalizedScore: round45(normalizedScore),
     dimensions: {
-      modularity: toPercentage(modularityQuality),
-      changeHygiene: toPercentage(changeHygieneQuality),
-      staticAnalysis: toPercentage(staticAnalysisQuality),
-      complexity: toPercentage(complexityQuality),
-      duplication: toPercentage(duplicationQuality),
-      testHealth: toPercentage(testHealthQuality)
+      modularity: toPercentage(modularityHealth),
+      changeHygiene: toPercentage(changeHygieneHealth),
+      testHealth: toPercentage(testHealthScore),
+      ownershipDistribution: toPercentage(ownershipDistributionHealth)
     },
     topIssues,
     trace: {
-      schemaVersion: QUALITY_TRACE_VERSION,
+      schemaVersion: HEALTH_TRACE_VERSION,
       dimensions: [
-        createDimensionTrace("modularity", modularityQuality, modularityFactors),
-        createDimensionTrace("changeHygiene", changeHygieneQuality, changeHygieneFactors),
-        createDimensionTrace("staticAnalysis", staticAnalysisQuality, staticAnalysisFactors),
-        createDimensionTrace("complexity", complexityQuality, complexityFactors),
-        createDimensionTrace("duplication", duplicationQuality, duplicationFactors),
-        createDimensionTrace("testHealth", testHealthQuality, testHealthFactors)
+        createDimensionTrace("modularity", modularityHealth, modularityFactors),
+        createDimensionTrace("changeHygiene", changeHygieneHealth, changeHygieneFactors),
+        createDimensionTrace("testHealth", testHealthScore, testHealthFactors),
+        createDimensionTrace(
+          "ownershipDistribution",
+          ownershipDistributionHealth,
+          ownershipDistributionFactors
+        )
       ]
     }
   };
@@ -6653,8 +6372,8 @@ var evaluateRepositoryRisk = (input, options = {}) => {
 };
 
 // src/application/run-analyze-command.ts
-var resolveTargetPath = (inputPath, cwd) => resolve4(cwd, inputPath ?? ".");
-var riskProfileConfig = {
+var resolveTargetPath = (inputPath, cwd) => resolve3(cwd, inputPath ?? ".");
+var scoringProfileConfig = {
   default: void 0,
   personal: {
     evolutionFactorWeights: {
@@ -6666,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;
@@ -6822,16 +6550,10 @@ var collectAnalysisInputs = async (inputPath, authorIdentityMode, options = {},
   } else {
     logger.warn(`external analysis unavailable: ${external.reason}`);
   }
-  logger.info("collecting quality signals");
-  const qualitySignals = await collectQualitySignals(targetPath, structural, logger);
-  logger.debug(
-    `quality signals: todoFixmeCommentCount=${qualitySignals.todoFixmeCommentCount ?? 0}, eslintErrors=${qualitySignals.eslint?.errorCount ?? 0}, tscErrors=${qualitySignals.typescript?.errorCount ?? 0}`
-  );
   return {
     structural,
     evolution,
-    external,
-    qualitySignals
+    external
   };
 };
 var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logger = createSilentLogger()) => {
@@ -6842,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,
-    signals: analysisInputs.qualitySignals
+    ...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) => {
@@ -6879,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,
@@ -6894,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,
-      signals: analysisInputs.qualitySignals
+      ...healthConfig === void 0 ? {} : { config: healthConfig }
     })
   };
   return createSnapshot({
@@ -6906,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
     }
   });
@@ -6941,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
@@ -6950,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) {
@@ -6989,8 +6713,8 @@ 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 { relative as relative3, resolve as resolve5 } from "path";
+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("..\\");
 };
@@ -7003,14 +6727,14 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
   if (options.baselineSha !== void 0 && options.baselineRef !== "auto") {
     throw new GovernanceConfigurationError("baseline-sha requires --baseline-ref auto");
   }
-  const resolvedTargetPath = resolve5(inputPath ?? process.cwd());
+  const resolvedTargetPath = resolve4(inputPath ?? process.cwd());
   logger.info("building current snapshot");
   const current = await buildAnalysisSnapshot(
     inputPath,
     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
@@ -7057,19 +6781,19 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
         repositoryPath: resolvedTargetPath,
         baselineRef,
         analyzeWorktree: async (worktreePath, repositoryRoot) => {
-          const relativeTargetPath = relative3(repositoryRoot, resolvedTargetPath);
+          const relativeTargetPath = relative2(repositoryRoot, resolvedTargetPath);
           if (isPathOutsideBase(relativeTargetPath)) {
             throw new GovernanceConfigurationError(
               `target path is outside git repository root: ${resolvedTargetPath}`
             );
           }
-          const baselineTargetPath = relativeTargetPath.length === 0 || relativeTargetPath === "." ? worktreePath : resolve5(worktreePath, relativeTargetPath);
+          const baselineTargetPath = relativeTargetPath.length === 0 || relativeTargetPath === "." ? worktreePath : resolve4(worktreePath, relativeTargetPath);
           return buildAnalysisSnapshot(
             baselineTargetPath,
             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
@@ -7089,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) {
@@ -7137,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(
@@ -7145,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
@@ -7159,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);
@@ -7202,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,
@@ -7220,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,
-      signals: analysisInputs.qualitySignals
+      ...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,
@@ -7238,7 +6963,7 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
 
 // src/index.ts
 var program = new Command();
-var packageJsonPath = resolve6(dirname2(fileURLToPath(import.meta.url)), "../package.json");
+var packageJsonPath = resolve5(dirname2(fileURLToPath(import.meta.url)), "../package.json");
 var { version } = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
 var parseRecentWindowDays = (value) => {
   const parsed = Number.parseInt(value, 10);
@@ -7284,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("");
@@ -7300,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("");
@@ -7318,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"}`
@@ -7344,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"}\``
@@ -7363,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)"
@@ -7391,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;
@@ -7399,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)"
@@ -7425,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);
@@ -7463,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)"
@@ -7492,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
@@ -7503,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)"
@@ -7535,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
     );
@@ -7549,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");
@@ -7593,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
@@ -7742,27 +7467,27 @@ var parseMainBranches = (options) => {
 };
 var buildGateConfigFromOptions = (options) => {
   const maxRiskDelta = parseGateNumber(options.maxRiskDelta, "--max-risk-delta");
-  const maxQualityDelta = parseGateNumber(options.maxQualityDelta, "--max-quality-delta");
+  const maxHealthDelta = parseGateNumber(options.maxHealthDelta, "--max-health-delta");
   const maxNewHotspots = parseGateNumber(options.maxNewHotspots, "--max-new-hotspots");
   const maxRiskScore = parseGateNumber(options.maxRiskScore, "--max-risk-score");
-  const minQualityScore = parseGateNumber(options.minQualityScore, "--min-quality-score");
+  const minHealthScore = parseGateNumber(options.minHealthScore, "--min-health-score");
   const newHotspotScoreThreshold = parseGateNumber(
     options.newHotspotScoreThreshold,
     "--new-hotspot-score-threshold"
   );
   return {
     ...maxRiskDelta === void 0 ? {} : { maxRiskDelta },
-    ...maxQualityDelta === void 0 ? {} : { maxQualityDelta },
+    ...maxHealthDelta === void 0 ? {} : { maxHealthDelta },
     ...options.noNewCycles === true ? { noNewCycles: true } : {},
     ...options.noNewHighRiskDeps === true ? { noNewHighRiskDeps: true } : {},
     ...maxNewHotspots === void 0 ? {} : { maxNewHotspots },
     ...maxRiskScore === void 0 ? {} : { maxRiskScore },
-    ...minQualityScore === void 0 ? {} : { minQualityScore },
+    ...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)"
@@ -7773,9 +7498,9 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
     "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-risk-delta <value>", "maximum allowed normalized risk score increase").option(
-  "--max-quality-delta <value>",
-  "maximum allowed normalized quality 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-quality-score <score>", "minimum quality score threshold (0..100)").addOption(
+  "--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")
@@ -7795,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,
@@ -7819,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)"
@@ -7844,9 +7569,9 @@ program.command("ci").argument("[path]", "path to the project to analyze").addOp
   "--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-risk-delta <value>", "maximum allowed normalized risk score increase").option(
-  "--max-quality-delta <value>",
-  "maximum allowed normalized quality 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-quality-score <score>", "minimum quality score threshold (0..100)").addOption(
+  "--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(
@@ -7871,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
         },