@getcodesentinel/codesentinel 1.14.0 → 1.16.0

package/dist/index.js

@@ -1656,6 +1656,7 @@ var createReport = (snapshot, diff) => {
       confidence: repositoryConfidence(snapshot),
       dimensionScores: repositoryDimensionScores(snapshot)
     },
+    quality: snapshot.analysis.quality,
     hotspots: hotspotItems(snapshot),
     structural: {
       cycleCount: snapshot.analysis.structural.metrics.cycleCount,
@@ -1727,6 +1728,26 @@ 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("  topIssues:");
+  for (const issue of report.quality.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) {
+    lines.push("    - none");
+  }
+  lines.push("");
   lines.push("Top Hotspots");
   for (const hotspot of report.hotspots) {
     lines.push(`  - ${hotspot.target} | score=${hotspot.score}`);
@@ -1802,6 +1823,27 @@ 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("- top issues: none");
+  } else {
+    lines.push("- top issues:");
+    for (const issue of report.quality.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}`
+      );
+    }
+  }
+  lines.push("");
   lines.push("## Top Hotspots");
   for (const hotspot of report.hotspots) {
     lines.push(`- **${hotspot.target}** (score: \`${hotspot.score}\`)`);
@@ -1947,14 +1989,20 @@ var requireDiff = (input, gateId) => {
 };
 var validateGateConfig = (input) => {
   const config = input.gateConfig;
-  if (config.maxRepoDelta !== void 0 && (!Number.isFinite(config.maxRepoDelta) || config.maxRepoDelta < 0)) {
-    throw new GovernanceConfigurationError("max-repo-delta must be a finite number >= 0");
+  if (config.maxRiskDelta !== void 0 && (!Number.isFinite(config.maxRiskDelta) || config.maxRiskDelta < 0)) {
+    throw new GovernanceConfigurationError("max-risk-delta must be a finite number >= 0");
+  }
+  if (config.maxQualityDelta !== void 0 && (!Number.isFinite(config.maxQualityDelta) || config.maxQualityDelta < 0)) {
+    throw new GovernanceConfigurationError("max-quality-delta must be a finite number >= 0");
   }
   if (config.maxNewHotspots !== void 0 && (!Number.isInteger(config.maxNewHotspots) || config.maxNewHotspots < 0)) {
     throw new GovernanceConfigurationError("max-new-hotspots must be an integer >= 0");
   }
-  if (config.maxRepoScore !== void 0 && (!Number.isFinite(config.maxRepoScore) || config.maxRepoScore < 0 || config.maxRepoScore > 100)) {
-    throw new GovernanceConfigurationError("max-repo-score must be a number in [0, 100]");
+  if (config.maxRiskScore !== void 0 && (!Number.isFinite(config.maxRiskScore) || config.maxRiskScore < 0 || config.maxRiskScore > 100)) {
+    throw new GovernanceConfigurationError("max-risk-score must be a number in [0, 100]");
+  }
+  if (config.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.newHotspotScoreThreshold !== void 0 && (!Number.isFinite(config.newHotspotScoreThreshold) || config.newHotspotScoreThreshold < 0 || config.newHotspotScoreThreshold > 100)) {
     throw new GovernanceConfigurationError(
@@ -1967,41 +2015,76 @@ var evaluateGates = (input) => {
   const config = input.gateConfig;
   const violations = [];
   const evaluatedGates = [];
-  if (config.maxRepoScore !== void 0) {
-    evaluatedGates.push("max-repo-score");
+  if (config.maxRiskScore !== void 0) {
+    evaluatedGates.push("max-risk-score");
     const current = input.current.analysis.risk.riskScore;
-    if (current > config.maxRepoScore) {
+    if (current > config.maxRiskScore) {
       violations.push(
         makeViolation(
-          "max-repo-score",
+          "max-risk-score",
           "error",
-          `Repository score ${current} exceeds configured max ${config.maxRepoScore}.`,
+          `Risk score ${current} exceeds configured max ${config.maxRiskScore}.`,
           [input.current.analysis.structural.targetPath],
           [{ kind: "repository_metric", metric: "riskScore" }]
         )
       );
     }
   }
-  if (config.maxRepoDelta !== void 0) {
-    evaluatedGates.push("max-repo-delta");
-    requireDiff(input, "max-repo-delta");
+  if (config.minQualityScore !== void 0) {
+    evaluatedGates.push("min-quality-score");
+    const current = input.current.analysis.quality.qualityScore;
+    if (current < config.minQualityScore) {
+      violations.push(
+        makeViolation(
+          "min-quality-score",
+          "error",
+          `Quality score ${current} is below configured minimum ${config.minQualityScore}.`,
+          [input.current.analysis.structural.targetPath],
+          [{ kind: "repository_metric", metric: "qualityScore" }]
+        )
+      );
+    }
+  }
+  if (config.maxRiskDelta !== void 0) {
+    evaluatedGates.push("max-risk-delta");
+    requireDiff(input, "max-risk-delta");
     const baseline = input.baseline;
     if (baseline === void 0) {
-      throw new GovernanceConfigurationError("max-repo-delta requires baseline snapshot");
+      throw new GovernanceConfigurationError("max-risk-delta requires baseline snapshot");
     }
     const delta = input.current.analysis.risk.normalizedScore - baseline.analysis.risk.normalizedScore;
-    if (delta > config.maxRepoDelta) {
+    if (delta > config.maxRiskDelta) {
       violations.push(
         makeViolation(
-          "max-repo-delta",
+          "max-risk-delta",
           "error",
-          `Repository normalized score delta ${delta.toFixed(4)} exceeds allowed ${config.maxRepoDelta}.`,
+          `Risk normalized score delta ${delta.toFixed(4)} exceeds allowed ${config.maxRiskDelta}.`,
           [input.current.analysis.structural.targetPath],
           [{ kind: "repository_metric", metric: "normalizedScore" }]
         )
       );
     }
   }
+  if (config.maxQualityDelta !== void 0) {
+    evaluatedGates.push("max-quality-delta");
+    requireDiff(input, "max-quality-delta");
+    const baseline = input.baseline;
+    if (baseline === void 0) {
+      throw new GovernanceConfigurationError("max-quality-delta requires baseline snapshot");
+    }
+    const delta = input.current.analysis.quality.normalizedScore - baseline.analysis.quality.normalizedScore;
+    if (delta < -config.maxQualityDelta) {
+      violations.push(
+        makeViolation(
+          "max-quality-delta",
+          "error",
+          `Quality normalized score delta ${delta.toFixed(4)} is below allowed minimum ${(-config.maxQualityDelta).toFixed(4)}.`,
+          [input.current.analysis.structural.targetPath],
+          [{ kind: "repository_metric", metric: "qualityNormalizedScore" }]
+        )
+      );
+    }
+  }
   if (config.noNewCycles === true) {
     evaluatedGates.push("no-new-cycles");
     requireDiff(input, "no-new-cycles");
@@ -2459,8 +2542,8 @@ var resolveAutoBaselineRef = async (input) => {
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve5 } from "path";
+import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve6 } from "path";
 import { fileURLToPath } from "url";
 
 // src/application/format-analyze-output.ts
@@ -2500,6 +2583,12 @@ 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)
   }
 });
 var formatAnalyzeOutput = (summary, mode) => mode === "json" ? JSON.stringify(summary, null, 2) : JSON.stringify(createSummaryShape(summary), null, 2);
@@ -2850,7 +2939,7 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import { dirname, join as join3 } from "path";
 import { stderr, stdin } from "process";
-import { clearScreenDown, cursorTo, emitKeypressEvents, moveCursor } from "readline";
+import { clearScreenDown, cursorTo, emitKeypressEvents } from "readline";
 var UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var UPDATE_CACHE_PATH = join3(homedir(), ".cache", "codesentinel", "update-check.json");
 var SEMVER_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
@@ -3042,11 +3131,15 @@ var fetchLatestVersion = async (packageName) => {
   }
   return parseNpmViewVersionOutput(result.stdout);
 };
-var renderUpdatePrompt = (latestVersion, currentVersion, selectedIndex) => {
-  const options = ["Install update now", "Not now (continue current command)"];
+var renderUpdatePrompt = (packageName, latestVersion, currentVersion, selectedIndex) => {
+  const options = [
+    `1. Update now (runs \`npm install -g ${packageName}\`)`,
+    "2. Skip"
+  ];
   const lines = [
-    `${ANSI.cyan}${ANSI.bold}CodeSentinel Update Available${ANSI.reset}`,
-    `${ANSI.dim}Current: ${currentVersion}  Latest: ${latestVersion}${ANSI.reset}`,
+    `  ${ANSI.bold}${ANSI.cyan}\u2728 Update available! ${currentVersion} -> ${latestVersion}${ANSI.reset}`,
+    "",
+    `  ${ANSI.dim}Release notes: https://github.com/getcodesentinel/codesentinel/releases/latest${ANSI.reset}`,
     "",
     ...options.map((option, index) => {
       const selected = index === selectedIndex;
@@ -3055,12 +3148,12 @@ var renderUpdatePrompt = (latestVersion, currentVersion, selectedIndex) => {
       return `${prefix} ${text}`;
     }),
     "",
-    `${ANSI.dim}Use \u2191/\u2193 to choose, Enter to confirm.${ANSI.reset}`
+    `  ${ANSI.dim}Use \u2191/\u2193 to choose. Press enter to continue${ANSI.reset}`
   ];
   stderr.write(lines.join("\n"));
   return lines.length;
 };
-var promptInstall = async (latestVersion, currentVersion) => {
+var promptInstall = async (packageName, latestVersion, currentVersion) => {
   if (!stdin.isTTY || !stderr.isTTY || typeof stdin.setRawMode !== "function") {
     stderr.write(
       `New version ${latestVersion} is available (current ${currentVersion}). Run: npm install -g @getcodesentinel/codesentinel@latest
@@ -3068,21 +3161,17 @@ var promptInstall = async (latestVersion, currentVersion) => {
     );
     return "skip";
   }
-  return await new Promise((resolve6) => {
+  return await new Promise((resolve7) => {
     emitKeypressEvents(stdin);
     let selectedIndex = 0;
-    let renderedLines = 0;
     const previousRawMode = stdin.isRaw;
     const clearPromptArea = () => {
-      if (renderedLines > 0) {
-        moveCursor(stderr, 0, -(renderedLines - 1));
-      }
-      cursorTo(stderr, 0);
+      cursorTo(stderr, 0, 0);
       clearScreenDown(stderr);
     };
     const redraw = () => {
       clearPromptArea();
-      renderedLines = renderUpdatePrompt(latestVersion, currentVersion, selectedIndex);
+      renderUpdatePrompt(packageName, latestVersion, currentVersion, selectedIndex);
     };
     const cleanup = (choice) => {
       stdin.off("keypress", onKeypress);
@@ -3094,10 +3183,10 @@ var promptInstall = async (latestVersion, currentVersion) => {
       if (choice === "install") {
         stderr.write(`${ANSI.yellow}Installing latest CodeSentinel...${ANSI.reset}
 `);
-      } else if (renderedLines > 0) {
+      } else {
         stderr.write("\n");
       }
-      resolve6(choice);
+      resolve7(choice);
     };
     const onKeypress = (_str, key) => {
       if (key.ctrl === true && key.name === "c") {
@@ -3153,7 +3242,7 @@ var checkForCliUpdates = async (input) => {
     if (comparison === null || comparison <= 0) {
       return;
     }
-    const choice = await promptInstall(latestVersion, input.currentVersion);
+    const choice = await promptInstall(input.packageName, latestVersion, input.currentVersion);
     if (choice === "interrupt") {
       process.exit(130);
     }
@@ -3176,7 +3265,7 @@ var checkForCliUpdates = async (input) => {
 };
 
 // src/application/run-analyze-command.ts
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 
 // ../code-graph/dist/index.js
 import { extname, isAbsolute, relative, resolve as resolve2 } from "path";
@@ -4224,6 +4313,1108 @@ 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
+var clamp01 = (value) => {
+  if (!Number.isFinite(value)) {
+    return 0;
+  }
+  if (value <= 0) {
+    return 0;
+  }
+  if (value >= 1) {
+    return 1;
+  }
+  return value;
+};
+var round45 = (value) => Number(value.toFixed(4));
+var average = (values) => {
+  if (values.length === 0) {
+    return 0;
+  }
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return total / values.length;
+};
+var concentration = (rawValues) => {
+  const values = rawValues.filter((value) => value > 0);
+  const count = values.length;
+  if (count <= 1) {
+    return 0;
+  }
+  const total = values.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return 0;
+  }
+  const hhi = values.reduce((sum, value) => {
+    const share = value / total;
+    return sum + share * share;
+  }, 0);
+  const minHhi = 1 / count;
+  const normalized = (hhi - minHhi) / (1 - minHhi);
+  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) {
+    return 0;
+  }
+  return clamp01(Math.log1p(Math.max(0, value)) / Math.log1p(scale));
+};
+var toFactorTrace = (spec) => ({
+  factorId: spec.factorId,
+  contribution: round45(spec.penalty * spec.weight * 100),
+  penalty: round45(spec.penalty),
+  rawMetrics: spec.rawMetrics,
+  normalizedMetrics: spec.normalizedMetrics,
+  weight: round45(spec.weight),
+  evidence: spec.evidence
+});
+var createDimensionTrace = (dimension, quality, factors) => ({
+  dimension,
+  normalizedScore: round45(clamp01(quality)),
+  score: toPercentage(quality),
+  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 isSourcePath = (path) => {
+  if (path.endsWith(".d.ts")) {
+    return false;
+  }
+  return !isTestPath2(path);
+};
+var pushIssue = (issues, issue) => {
+  issues.push({
+    ...issue,
+    severity: issue.severity ?? "warn"
+  });
+};
+var computeRepositoryQualitySummary = (input) => {
+  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 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 modularityFactors = [
+    {
+      factorId: "quality.modularity.structural_cycles",
+      penalty: cyclePenalty,
+      rawMetrics: {
+        cycleCount,
+        averageCycleSize: round45(cycleSizeAverage)
+      },
+      normalizedMetrics: {
+        cyclePenalty: round45(cyclePenalty)
+      },
+      weight: 0.55,
+      evidence: [{ kind: "repository_metric", metric: "structural.cycles" }]
+    },
+    {
+      factorId: "quality.modularity.centrality_concentration",
+      penalty: centralityConcentration,
+      rawMetrics: {
+        fanInConcentration: round45(fanInConcentration),
+        fanOutConcentration: round45(fanOutConcentration)
+      },
+      normalizedMetrics: {
+        centralityConcentration: round45(centralityConcentration)
+      },
+      weight: 0.45,
+      evidence: [{ kind: "repository_metric", metric: "structural.files.fanIn/fanOut" }]
+    }
+  ];
+  const modularityPenalty = clamp01(
+    modularityFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
+  );
+  let churnConcentration = 0;
+  let volatilityConcentration = 0;
+  let couplingDensity = 0;
+  let couplingIntensity = 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 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 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",
+        dimension: "changeHygiene",
+        target: mostChurn?.filePath ?? input.structural.targetPath,
+        message: "Churn is concentrated in a narrow part of the codebase.",
+        impact: round45(churnConcentration * 0.4)
+      });
+    }
+    if (volatilityConcentration >= 0.45) {
+      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",
+        dimension: "changeHygiene",
+        target: volatileFile?.filePath ?? input.structural.targetPath,
+        message: "Recent volatility is concentrated in files that change frequently.",
+        impact: round45(volatilityConcentration * 0.3)
+      });
+    }
+    if (couplingDensity >= 0.35 || couplingIntensity >= 0.45) {
+      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",
+        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)
+      });
+    }
+  }
+  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,
+      rawMetrics: {
+        churnConcentration: round45(churnConcentration)
+      },
+      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)
+      },
+      normalizedMetrics: {
+        volatilityConcentration: round45(volatilityConcentration)
+      },
+      weight: 0.25,
+      evidence: [{ kind: "repository_metric", metric: "evolution.recentVolatility" }]
+    },
+    {
+      factorId: "quality.change_hygiene.coupling_density",
+      penalty: average([couplingDensity, couplingIntensity]),
+      rawMetrics: {
+        couplingDensity: round45(couplingDensity),
+        couplingIntensity: round45(couplingIntensity)
+      },
+      normalizedMetrics: {
+        couplingPressure: round45(average([couplingDensity, couplingIntensity]))
+      },
+      weight: 0.3,
+      evidence: [{ kind: "repository_metric", metric: "evolution.coupling" }]
+    },
+    {
+      factorId: "quality.change_hygiene.todo_fixme_load",
+      penalty: todoFixmePenalty,
+      rawMetrics: {
+        todoFixmeCommentCount
+      },
+      normalizedMetrics: {
+        todoFixmePenalty: round45(todoFixmePenalty)
+      },
+      weight: 0.1,
+      evidence: [{ kind: "repository_metric", metric: "comments.todo_fixme" }]
+    }
+  ];
+  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" }]
+    },
+    {
+      factorId: "quality.static_analysis.eslint_warnings",
+      penalty: clamp01(eslintWarnRate / 1.2),
+      rawMetrics: {
+        eslintWarningCount: eslint?.warningCount ?? 0
+      },
+      normalizedMetrics: {
+        eslintWarningRate: round45(eslintWarnRate)
+      },
+      weight: 0.2,
+      evidence: [{ kind: "repository_metric", metric: "eslint.warningCount" }]
+    },
+    {
+      factorId: "quality.static_analysis.typescript_errors",
+      penalty: clamp01(tsErrorRate / 0.35),
+      rawMetrics: {
+        typeScriptErrorCount: tsc?.errorCount ?? 0,
+        typeScriptFilesWithDiagnostics: tsc?.filesWithDiagnostics ?? 0
+      },
+      normalizedMetrics: {
+        typeScriptErrorRate: round45(tsErrorRate)
+      },
+      weight: 0.2,
+      evidence: [{ kind: "repository_metric", metric: "typescript.errorCount" }]
+    },
+    {
+      factorId: "quality.static_analysis.typescript_warnings",
+      penalty: clamp01(tsWarnRate / 0.9),
+      rawMetrics: {
+        typeScriptWarningCount: tsc?.warningCount ?? 0
+      },
+      normalizedMetrics: {
+        typeScriptWarningRate: round45(tsWarnRate)
+      },
+      weight: 0.1,
+      evidence: [{ kind: "repository_metric", metric: "typescript.warningCount" }]
+    }
+  ];
+  const staticAnalysisPenalty = clamp01(
+    staticAnalysisFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
+  );
+  if ((eslint?.errorCount ?? 0) > 0) {
+    const topRule = [...eslint?.ruleCounts ?? []].sort(
+      (a, b) => b.count - a.count || a.ruleId.localeCompare(b.ruleId)
+    )[0];
+    pushIssue(issues, {
+      id: "quality.static_analysis.eslint_errors",
+      ruleId: topRule?.ruleId ?? "eslint",
+      dimension: "staticAnalysis",
+      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)
+    });
+  }
+  if ((tsc?.errorCount ?? 0) > 0) {
+    pushIssue(issues, {
+      id: "quality.static_analysis.typescript_errors",
+      ruleId: "typescript",
+      dimension: "staticAnalysis",
+      target: input.structural.targetPath,
+      message: `TypeScript reported ${tsc?.errorCount ?? 0} error diagnostic(s).`,
+      severity: "error",
+      impact: round45(staticAnalysisPenalty * 0.4)
+    });
+  }
+  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)
+      },
+      normalizedMetrics: {
+        averageCyclomaticPenalty: round45(clamp01(avgComplexity / 16))
+      },
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "complexity.averageCyclomatic" }]
+    },
+    {
+      factorId: "quality.complexity.max_cyclomatic",
+      penalty: clamp01(maxComplexity / 35),
+      rawMetrics: {
+        maxCyclomatic: round45(maxComplexity)
+      },
+      normalizedMetrics: {
+        maxCyclomaticPenalty: round45(clamp01(maxComplexity / 35))
+      },
+      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
+      },
+      normalizedMetrics: {
+        highComplexityRatio: round45(highComplexityRatio)
+      },
+      weight: 0.25,
+      evidence: [{ kind: "repository_metric", metric: "complexity.highComplexityFileCount" }]
+    }
+  ];
+  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" }]
+    }
+  ];
+  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)
+      },
+      weight: 0.55,
+      evidence: [{ kind: "repository_metric", metric: "tests.file_ratio" }]
+    },
+    {
+      factorId: "quality.test_health.coverage",
+      penalty: coveragePenalty,
+      rawMetrics: {
+        lineCoverage: coverageSignals?.lineCoverage ?? null,
+        branchCoverage: coverageSignals?.branchCoverage ?? null,
+        functionCoverage: coverageSignals?.functionCoverage ?? null,
+        statementCoverage: coverageSignals?.statementCoverage ?? null
+      },
+      normalizedMetrics: {
+        coverageRatio: coverageRatio === null ? null : round45(coverageRatio),
+        coveragePenalty: round45(coveragePenalty)
+      },
+      weight: 0.45,
+      evidence: [{ kind: "repository_metric", metric: "coverage.summary" }]
+    }
+  ];
+  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 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
+  );
+  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),
+    normalizedScore: round45(normalizedScore),
+    dimensions: {
+      modularity: toPercentage(modularityQuality),
+      changeHygiene: toPercentage(changeHygieneQuality),
+      staticAnalysis: toPercentage(staticAnalysisQuality),
+      complexity: toPercentage(complexityQuality),
+      duplication: toPercentage(duplicationQuality),
+      testHealth: toPercentage(testHealthQuality)
+    },
+    topIssues,
+    trace: {
+      schemaVersion: QUALITY_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)
+      ]
+    }
+  };
+};
+
 // ../risk-engine/dist/index.js
 var DEFAULT_RISK_ENGINE_CONFIG = {
   // Base dimensional influence. Risk is never dominated by a single dimension by default.
@@ -4309,8 +5500,8 @@ var DEFAULT_RISK_ENGINE_CONFIG = {
   }
 };
 var toUnitInterval = (value) => Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
-var round45 = (value) => Number(value.toFixed(4));
-var average = (values) => {
+var round46 = (value) => Number(value.toFixed(4));
+var average2 = (values) => {
   if (values.length === 0) {
     return 0;
   }
@@ -4397,7 +5588,7 @@ var normalizeWithScale = (value, scale) => {
   }
   return toUnitInterval((value - scale.lower) / (scale.upper - scale.lower));
 };
-var normalizePath2 = (path) => path.replaceAll("\\", "/");
+var normalizePath3 = (path) => path.replaceAll("\\", "/");
 var computeAggregatorAttenuation = (input) => {
   const { fanIn, fanOut, inCycle, evolutionMetrics, config } = input;
   if (!config.enabled || inCycle > 0) {
@@ -4418,14 +5609,14 @@ var computeAggregatorAttenuation = (input) => {
   const fanOutSignal = toUnitInterval((fanOut - config.minFanOut) / Math.max(1, config.minFanOut));
   const lowChurnPerCommitSignal = 1 - toUnitInterval(churnPerCommit / config.maxChurnPerCommit);
   const lowChurnPerDependencySignal = 1 - toUnitInterval(churnPerDependency / config.maxChurnPerDependency);
-  const attenuationConfidence = average([
+  const attenuationConfidence = average2([
     fanInSignal,
     fanOutSignal,
     lowChurnPerCommitSignal,
     lowChurnPerDependencySignal
   ]);
   const reduction = toUnitInterval(config.maxStructuralReduction) * attenuationConfidence;
-  return round45(toUnitInterval(1 - reduction));
+  return round46(toUnitInterval(1 - reduction));
 };
 var dependencySignalWeights = {
   single_maintainer: 0.3,
@@ -4455,12 +5646,12 @@ var computeDependencySignalScore = (ownSignals, inheritedSignals, inheritedSigna
   }
   return toUnitInterval(weightedTotal / maxWeightedTotal);
 };
-var clampConfidence = (value) => round45(toUnitInterval(value));
+var clampConfidence = (value) => round46(toUnitInterval(value));
 var computeExternalMetadataConfidence = (external) => {
   if (!external.available) {
     return 0;
   }
-  return round45(toUnitInterval(0.35 + external.metrics.metadataCoverage * 0.65));
+  return round46(toUnitInterval(0.35 + external.metrics.metadataCoverage * 0.65));
 };
 var computeEvolutionHistoryConfidence = (structural, evolution, evolutionByFile) => {
   if (!evolution.available) {
@@ -4472,12 +5663,12 @@ var computeEvolutionHistoryConfidence = (structural, evolution, evolutionByFile)
   }
   let coveredFiles = 0;
   for (const file of structural.files) {
-    if (evolutionByFile.has(normalizePath2(file.id))) {
+    if (evolutionByFile.has(normalizePath3(file.id))) {
       coveredFiles += 1;
     }
   }
   const coverage = coveredFiles / totalFiles;
-  return round45(toUnitInterval(0.3 + coverage * 0.7));
+  return round46(toUnitInterval(0.3 + coverage * 0.7));
 };
 var buildFactorTraces = (totalScore, inputs) => {
   const positiveInputs = inputs.filter((input) => input.strength > 0);
@@ -4515,7 +5706,7 @@ var buildFactorTraces = (totalScore, inputs) => {
       continue;
     }
     if (index === scored.length - 1) {
-      const remaining = round45(totalScore - distributed);
+      const remaining = round46(totalScore - distributed);
       traces[traceIndex] = {
         ...existing,
         contribution: Math.max(0, remaining)
@@ -4523,7 +5714,7 @@ var buildFactorTraces = (totalScore, inputs) => {
       distributed += Math.max(0, remaining);
       continue;
     }
-    const rounded = round45(current.contribution);
+    const rounded = round46(current.contribution);
     traces[traceIndex] = {
       ...existing,
       contribution: rounded
@@ -4534,15 +5725,15 @@ var buildFactorTraces = (totalScore, inputs) => {
 };
 var buildReductionLevers = (factors) => factors.filter((factor) => factor.contribution > 0).sort((a, b) => b.contribution - a.contribution || a.factorId.localeCompare(b.factorId)).slice(0, 3).map((factor) => ({
   factorId: factor.factorId,
-  estimatedImpact: round45(factor.contribution)
+  estimatedImpact: round46(factor.contribution)
 }));
 var buildTargetTrace = (targetType, targetId, totalScore, normalizedScore, factors) => {
   const dominantFactors = [...factors].filter((factor) => factor.contribution > 0).sort((a, b) => b.contribution - a.contribution || a.factorId.localeCompare(b.factorId)).slice(0, 3).map((factor) => factor.factorId);
   return {
     targetType,
     targetId,
-    totalScore: round45(totalScore),
-    normalizedScore: round45(normalizedScore),
+    totalScore: round46(totalScore),
+    normalizedScore: round46(normalizedScore),
     factors,
     dominantFactors,
     reductionLevers: buildReductionLevers(factors)
@@ -4616,14 +5807,14 @@ var computeDependencyScores = (external, config) => {
     ].filter((value) => value !== null).length;
     const confidence = toUnitInterval((0.5 + availableMetricCount * 0.125) * metadataConfidence);
     dependencyContexts.set(dependency.name, {
-      signalScore: round45(signalScore),
-      stalenessRisk: round45(stalenessRisk),
-      maintainerConcentrationRisk: round45(maintainerConcentrationRisk),
-      transitiveBurdenRisk: round45(transitiveBurdenRisk),
-      centralityRisk: round45(centralityRisk),
-      chainDepthRisk: round45(chainDepthRisk),
-      busFactorRisk: round45(busFactorRisk),
-      popularityDampener: round45(popularityDampener),
+      signalScore: round46(signalScore),
+      stalenessRisk: round46(stalenessRisk),
+      maintainerConcentrationRisk: round46(maintainerConcentrationRisk),
+      transitiveBurdenRisk: round46(transitiveBurdenRisk),
+      centralityRisk: round46(centralityRisk),
+      chainDepthRisk: round46(chainDepthRisk),
+      busFactorRisk: round46(busFactorRisk),
+      popularityDampener: round46(popularityDampener),
       rawMetrics: {
         daysSinceLastRelease: dependency.daysSinceLastRelease,
         maintainerCount: dependency.maintainerCount,
@@ -4633,12 +5824,12 @@ var computeDependencyScores = (external, config) => {
         busFactor: dependency.busFactor,
         weeklyDownloads: dependency.weeklyDownloads
       },
-      confidence: round45(confidence)
+      confidence: round46(confidence)
     });
     return {
       dependency: dependency.name,
-      score: round45(normalizedScore * 100),
-      normalizedScore: round45(normalizedScore),
+      score: round46(normalizedScore * 100),
+      normalizedScore: round46(normalizedScore),
       ownRiskSignals: dependency.ownRiskSignals,
       inheritedRiskSignals: dependency.inheritedRiskSignals
     };
@@ -4647,7 +5838,7 @@ var computeDependencyScores = (external, config) => {
   );
   const normalizedValues = dependencyScores.map((score) => score.normalizedScore);
   const highDependencyRisk = dependencyScores.length === 0 ? 0 : percentile(normalizedValues, config.externalDimension.topDependencyPercentile);
-  const averageDependencyRisk = average(normalizedValues);
+  const averageDependencyRisk = average2(normalizedValues);
   const depthRisk = halfLifeRisk(
     external.metrics.dependencyDepth,
     config.externalDimension.dependencyDepthHalfLife
@@ -4657,7 +5848,7 @@ var computeDependencyScores = (external, config) => {
   );
   return {
     dependencyScores,
-    repositoryExternalPressure: round45(repositoryExternalPressure),
+    repositoryExternalPressure: round46(repositoryExternalPressure),
     dependencyContexts
   };
 };
@@ -4666,7 +5857,7 @@ var mapEvolutionByFile = (evolution) => {
     return /* @__PURE__ */ new Map();
   }
   return new Map(
-    evolution.files.map((fileMetrics) => [normalizePath2(fileMetrics.filePath), fileMetrics])
+    evolution.files.map((fileMetrics) => [normalizePath3(fileMetrics.filePath), fileMetrics])
   );
 };
 var computeEvolutionScales = (evolutionByFile, config) => {
@@ -4690,7 +5881,7 @@ var computeEvolutionScales = (evolutionByFile, config) => {
   };
 };
 var inferModuleName = (filePath, config) => {
-  const normalized = normalizePath2(filePath);
+  const normalized = normalizePath3(filePath);
   const parts = normalized.split("/").filter((part) => part.length > 0);
   if (parts.length <= 1) {
     return config.module.rootLabel;
@@ -4711,18 +5902,18 @@ var buildFragileClusters = (structural, evolution, fileScoresByFile, config) =>
   const clusters = [];
   let cycleClusterCount = 0;
   for (const cycle of structural.cycles) {
-    const files = [...new Set(cycle.nodes.map((node) => normalizePath2(node)))].filter(
+    const files = [...new Set(cycle.nodes.map((node) => normalizePath3(node)))].filter(
       (filePath) => fileScoresByFile.has(filePath)
     );
     if (files.length < 2) {
       continue;
     }
     files.sort((a, b) => a.localeCompare(b));
-    const averageRisk = average(
+    const averageRisk = average2(
       files.map((filePath) => fileScoresByFile.get(filePath)?.normalizedScore ?? 0)
     );
     const cycleSizeRisk = toUnitInterval((files.length - 1) / 5);
-    const score = round45(toUnitInterval(averageRisk * 0.75 + cycleSizeRisk * 0.25) * 100);
+    const score = round46(toUnitInterval(averageRisk * 0.75 + cycleSizeRisk * 0.25) * 100);
     cycleClusterCount += 1;
     clusters.push({
       id: `cycle:${cycleClusterCount}`,
@@ -4743,8 +5934,8 @@ var buildFragileClusters = (structural, evolution, fileScoresByFile, config) =>
       )
     );
     const selectedPairs = candidates.filter((pair) => pair.couplingScore >= threshold).map((pair) => ({
-      fileA: normalizePath2(pair.fileA),
-      fileB: normalizePath2(pair.fileB),
+      fileA: normalizePath3(pair.fileA),
+      fileB: normalizePath3(pair.fileB),
       couplingScore: pair.couplingScore
     })).filter(
       (pair) => pair.fileA !== pair.fileB && fileScoresByFile.has(pair.fileA) && fileScoresByFile.has(pair.fileB)
@@ -4792,11 +5983,11 @@ var buildFragileClusters = (structural, evolution, fileScoresByFile, config) =>
       const componentPairs = selectedPairs.filter(
         (pair) => fileSet.has(pair.fileA) && fileSet.has(pair.fileB)
       );
-      const meanFileRisk = average(
+      const meanFileRisk = average2(
         files.map((filePath) => fileScoresByFile.get(filePath)?.normalizedScore ?? 0)
       );
-      const meanCoupling = average(componentPairs.map((pair) => pair.couplingScore));
-      const score = round45(toUnitInterval(meanFileRisk * 0.65 + meanCoupling * 0.35) * 100);
+      const meanCoupling = average2(componentPairs.map((pair) => pair.couplingScore));
+      const score = round46(toUnitInterval(meanFileRisk * 0.65 + meanCoupling * 0.35) * 100);
       couplingClusterCount += 1;
       clusters.push({
         id: `coupling:${couplingClusterCount}`,
@@ -4822,7 +6013,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
   );
   const evolutionScales = computeEvolutionScales(evolutionByFile, config);
   const cycleFileSet = new Set(
-    structural.cycles.flatMap((cycle) => cycle.nodes.map((node) => normalizePath2(node)))
+    structural.cycles.flatMap((cycle) => cycle.nodes.map((node) => normalizePath3(node)))
   );
   const fanInScale = buildQuantileScale(
     structural.files.map((file) => logScale(file.fanIn)),
@@ -4845,7 +6036,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
     external: external.available
   });
   const fileRiskContexts = structural.files.map((file) => {
-    const filePath = normalizePath2(file.id);
+    const filePath = normalizePath3(file.id);
     const inCycle = cycleFileSet.has(filePath) ? 1 : 0;
     const fanInRisk = normalizeWithScale(logScale(file.fanIn), fanInScale);
     const fanOutRisk = normalizeWithScale(logScale(file.fanOut), fanOutScale);
@@ -4907,21 +6098,21 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
     const normalizedScore = saturatingComposite(baseline, interactions);
     return {
       file: filePath,
-      score: round45(normalizedScore * 100),
-      normalizedScore: round45(normalizedScore),
+      score: round46(normalizedScore * 100),
+      normalizedScore: round46(normalizedScore),
       factors: {
-        structural: round45(structuralFactor),
-        evolution: round45(evolutionFactor),
-        external: round45(externalFactor)
+        structural: round46(structuralFactor),
+        evolution: round46(evolutionFactor),
+        external: round46(externalFactor)
       },
-      structuralCentrality: round45(structuralCentrality),
+      structuralCentrality: round46(structuralCentrality),
       traceTerms: {
-        structuralBase: round45(structuralBase),
-        evolutionBase: round45(evolutionBase),
-        externalBase: round45(externalBase),
-        interactionStructuralEvolution: round45(interactionStructuralEvolution),
-        interactionCentralInstability: round45(interactionCentralInstability),
-        interactionDependencyAmplification: round45(interactionDependencyAmplification)
+        structuralBase: round46(structuralBase),
+        evolutionBase: round46(evolutionBase),
+        externalBase: round46(externalBase),
+        interactionStructuralEvolution: round46(interactionStructuralEvolution),
+        interactionCentralInstability: round46(interactionCentralInstability),
+        interactionDependencyAmplification: round46(interactionDependencyAmplification)
       },
       rawMetrics: {
         fanIn: file.fanIn,
@@ -4933,19 +6124,19 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         recentVolatility: evolutionMetrics?.recentVolatility ?? null,
         topAuthorShare: evolutionMetrics?.topAuthorShare ?? null,
         busFactor: evolutionMetrics?.busFactor ?? null,
-        dependencyAffinity: round45(dependencyAffinity),
-        repositoryExternalPressure: round45(dependencyComputation.repositoryExternalPressure),
-        structuralAttenuation: round45(structuralAttenuation)
+        dependencyAffinity: round46(dependencyAffinity),
+        repositoryExternalPressure: round46(dependencyComputation.repositoryExternalPressure),
+        structuralAttenuation: round46(structuralAttenuation)
       },
       normalizedMetrics: {
-        fanInRisk: round45(fanInRisk),
-        fanOutRisk: round45(fanOutRisk),
-        depthRisk: round45(depthRisk),
-        frequencyRisk: round45(frequencyRisk),
-        churnRisk: round45(churnRisk),
-        volatilityRisk: round45(volatilityRisk),
-        ownershipConcentrationRisk: round45(ownershipConcentrationRisk),
-        busFactorRisk: round45(busFactorRisk)
+        fanInRisk: round46(fanInRisk),
+        fanOutRisk: round46(fanOutRisk),
+        depthRisk: round46(depthRisk),
+        frequencyRisk: round46(frequencyRisk),
+        churnRisk: round46(churnRisk),
+        volatilityRisk: round46(volatilityRisk),
+        ownershipConcentrationRisk: round46(ownershipConcentrationRisk),
+        busFactorRisk: round46(busFactorRisk)
       }
     };
   }).sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
@@ -5071,29 +6262,29 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
     moduleFiles.set(moduleName, values);
   }
   const moduleScores = [...moduleFiles.entries()].map(([module, values]) => {
-    const averageScore = average(values);
+    const averageScore = average2(values);
     const peakScore = values.reduce((max, value) => Math.max(max, value), 0);
     const normalizedScore = toUnitInterval(averageScore * 0.65 + peakScore * 0.35);
     return {
       module,
-      score: round45(normalizedScore * 100),
-      normalizedScore: round45(normalizedScore),
+      score: round46(normalizedScore * 100),
+      normalizedScore: round46(normalizedScore),
       fileCount: values.length
     };
   }).sort((a, b) => b.score - a.score || a.module.localeCompare(b.module));
   if (collector !== void 0) {
     for (const [module, values] of moduleFiles.entries()) {
-      const averageScore = average(values);
+      const averageScore = average2(values);
       const peakScore = values.reduce((max, value) => Math.max(max, value), 0);
       const normalizedScore = toUnitInterval(averageScore * 0.65 + peakScore * 0.35);
-      const totalScore = round45(normalizedScore * 100);
+      const totalScore = round46(normalizedScore * 100);
       const factors = buildFactorTraces(totalScore, [
         {
           factorId: "module.average_file_risk",
           family: "composite",
           strength: averageScore * 0.65,
-          rawMetrics: { averageFileRisk: round45(averageScore), fileCount: values.length },
-          normalizedMetrics: { normalizedModuleRisk: round45(normalizedScore) },
+          rawMetrics: { averageFileRisk: round46(averageScore), fileCount: values.length },
+          normalizedMetrics: { normalizedModuleRisk: round46(normalizedScore) },
           weight: 0.65,
           amplification: null,
           evidence: [{ kind: "repository_metric", metric: "moduleAggregation.average" }],
@@ -5103,8 +6294,8 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
           factorId: "module.peak_file_risk",
           family: "composite",
           strength: peakScore * 0.35,
-          rawMetrics: { peakFileRisk: round45(peakScore), fileCount: values.length },
-          normalizedMetrics: { normalizedModuleRisk: round45(normalizedScore) },
+          rawMetrics: { peakFileRisk: round46(peakScore), fileCount: values.length },
+          normalizedMetrics: { normalizedModuleRisk: round46(normalizedScore) },
           weight: 0.35,
           amplification: null,
           evidence: [{ kind: "repository_metric", metric: "moduleAggregation.peak" }],
@@ -5127,12 +6318,12 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
     const normalizedZoneScore = toUnitInterval(intensity * 0.7 + fileScore.normalizedScore * 0.3);
     return {
       file: fileScore.file,
-      score: round45(normalizedZoneScore * 100),
+      score: round46(normalizedZoneScore * 100),
       externalPressure: fileScore.factors.external
     };
   }).filter((zone) => external.available && zone.externalPressure >= pressureThreshold).sort((a, b) => b.score - a.score || a.file.localeCompare(b.file)).slice(0, config.amplificationZone.maxZones).map((zone) => ({
     ...zone,
-    externalPressure: round45(zone.externalPressure)
+    externalPressure: round46(zone.externalPressure)
   }));
   if (collector !== void 0 && external.available) {
     const dependencyByName = new Map(
@@ -5245,16 +6436,16 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
       );
     }
   }
-  const structuralDimension = average(fileScores.map((fileScore) => fileScore.factors.structural));
-  const evolutionDimension = average(fileScores.map((fileScore) => fileScore.factors.evolution));
+  const structuralDimension = average2(fileScores.map((fileScore) => fileScore.factors.structural));
+  const evolutionDimension = average2(fileScores.map((fileScore) => fileScore.factors.evolution));
   const externalDimension = dependencyComputation.repositoryExternalPressure;
   const topCentralSlice = Math.max(1, Math.ceil(fileRiskContexts.length * 0.1));
-  const criticalInstability = average(
+  const criticalInstability = average2(
     [...fileRiskContexts].sort(
       (a, b) => b.structuralCentrality * b.factors.evolution - a.structuralCentrality * a.factors.evolution || a.file.localeCompare(b.file)
     ).slice(0, topCentralSlice).map((context) => context.structuralCentrality * context.factors.evolution)
   );
-  const dependencyAmplification = average(
+  const dependencyAmplification = average2(
     dependencyAmplificationZones.map(
       (zone) => toUnitInterval(zone.externalPressure * zone.score / 100)
     )
@@ -5265,15 +6456,15 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
     criticalInstability * config.interactionWeights.centralInstability,
     dependencyAmplification * config.interactionWeights.dependencyAmplification
   ]);
-  const riskScore = round45(repositoryNormalizedScore * 100);
+  const riskScore = round46(repositoryNormalizedScore * 100);
   if (collector !== void 0) {
     const repositoryFactors = buildFactorTraces(riskScore, [
       {
         factorId: "repository.structural",
         family: "structural",
         strength: structuralDimension * dimensionWeights.structural,
-        rawMetrics: { structuralDimension: round45(structuralDimension) },
-        normalizedMetrics: { dimensionWeight: round45(dimensionWeights.structural) },
+        rawMetrics: { structuralDimension: round46(structuralDimension) },
+        normalizedMetrics: { dimensionWeight: round46(dimensionWeights.structural) },
         weight: dimensionWeights.structural,
         amplification: null,
         evidence: [{ kind: "repository_metric", metric: "structuralDimension" }],
@@ -5283,8 +6474,8 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         factorId: "repository.evolution",
         family: "evolution",
         strength: evolutionDimension * dimensionWeights.evolution,
-        rawMetrics: { evolutionDimension: round45(evolutionDimension) },
-        normalizedMetrics: { dimensionWeight: round45(dimensionWeights.evolution) },
+        rawMetrics: { evolutionDimension: round46(evolutionDimension) },
+        normalizedMetrics: { dimensionWeight: round46(dimensionWeights.evolution) },
         weight: dimensionWeights.evolution,
         amplification: null,
         evidence: [{ kind: "repository_metric", metric: "evolutionDimension" }],
@@ -5294,8 +6485,8 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         factorId: "repository.external",
         family: "external",
         strength: externalDimension * dimensionWeights.external,
-        rawMetrics: { externalDimension: round45(externalDimension) },
-        normalizedMetrics: { dimensionWeight: round45(dimensionWeights.external) },
+        rawMetrics: { externalDimension: round46(externalDimension) },
+        normalizedMetrics: { dimensionWeight: round46(dimensionWeights.external) },
         weight: dimensionWeights.external,
         amplification: null,
         evidence: [{ kind: "repository_metric", metric: "externalDimension" }],
@@ -5306,19 +6497,19 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
         family: "composite",
         strength: structuralDimension * evolutionDimension * config.interactionWeights.structuralEvolution + criticalInstability * config.interactionWeights.centralInstability + dependencyAmplification * config.interactionWeights.dependencyAmplification,
         rawMetrics: {
-          structuralEvolution: round45(
+          structuralEvolution: round46(
             structuralDimension * evolutionDimension * config.interactionWeights.structuralEvolution
           ),
-          centralInstability: round45(
+          centralInstability: round46(
             criticalInstability * config.interactionWeights.centralInstability
           ),
-          dependencyAmplification: round45(
+          dependencyAmplification: round46(
             dependencyAmplification * config.interactionWeights.dependencyAmplification
           )
         },
         normalizedMetrics: {
-          criticalInstability: round45(criticalInstability),
-          dependencyAmplification: round45(dependencyAmplification)
+          criticalInstability: round46(criticalInstability),
+          dependencyAmplification: round46(dependencyAmplification)
         },
         weight: null,
         amplification: config.interactionWeights.structuralEvolution + config.interactionWeights.centralInstability + config.interactionWeights.dependencyAmplification,
@@ -5338,7 +6529,7 @@ var computeRiskSummary = (structural, evolution, external, config, traceCollecto
   }
   return {
     riskScore,
-    normalizedScore: round45(repositoryNormalizedScore),
+    normalizedScore: round46(repositoryNormalizedScore),
     hotspots,
     fragileClusters,
     dependencyAmplificationZones,
@@ -5462,7 +6653,7 @@ var evaluateRepositoryRisk = (input, options = {}) => {
 };
 
 // src/application/run-analyze-command.ts
-var resolveTargetPath = (inputPath, cwd) => resolve3(cwd, inputPath ?? ".");
+var resolveTargetPath = (inputPath, cwd) => resolve4(cwd, inputPath ?? ".");
 var riskProfileConfig = {
   default: void 0,
   personal: {
@@ -5631,10 +6822,16 @@ 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
+    external,
+    qualitySignals
   };
 };
 var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logger = createSilentLogger()) => {
@@ -5647,18 +6844,30 @@ var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logg
   logger.info("computing risk summary");
   const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
   const risk = computeRepositoryRiskSummary({
-    ...analysisInputs,
+    structural: analysisInputs.structural,
+    evolution: analysisInputs.evolution,
+    external: analysisInputs.external,
     ...riskConfig === void 0 ? {} : { config: riskConfig }
   });
-  logger.info(`analysis completed (riskScore=${risk.riskScore})`);
+  const quality = computeRepositoryQualitySummary({
+    structural: analysisInputs.structural,
+    evolution: analysisInputs.evolution,
+    signals: analysisInputs.qualitySignals
+  });
+  logger.info(
+    `analysis completed (riskScore=${risk.riskScore}, qualityScore=${quality.qualityScore})`
+  );
   return {
-    ...analysisInputs,
-    risk
+    structural: analysisInputs.structural,
+    evolution: analysisInputs.evolution,
+    external: analysisInputs.external,
+    risk,
+    quality
   };
 };
 
 // src/application/run-check-command.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 
 // src/application/build-analysis-snapshot.ts
 var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logger) => {
@@ -5673,14 +6882,23 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
   const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
   const evaluation = evaluateRepositoryRisk(
     {
-      ...analysisInputs,
+      structural: analysisInputs.structural,
+      evolution: analysisInputs.evolution,
+      external: analysisInputs.external,
       ...riskConfig === void 0 ? {} : { config: riskConfig }
     },
     { explain: options.includeTrace }
   );
   const summary = {
-    ...analysisInputs,
-    risk: evaluation.summary
+    structural: analysisInputs.structural,
+    evolution: analysisInputs.evolution,
+    external: analysisInputs.external,
+    risk: evaluation.summary,
+    quality: computeRepositoryQualitySummary({
+      structural: analysisInputs.structural,
+      evolution: analysisInputs.evolution,
+      signals: analysisInputs.qualitySignals
+    })
   };
   return createSnapshot({
     analysis: summary,
@@ -5732,7 +6950,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 readFile2(options.baselinePath, "utf8");
+    const baselineRaw = await readFile3(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -5771,8 +6989,8 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
 };
 
 // src/application/run-ci-command.ts
-import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import { relative as relative2, resolve as resolve4 } from "path";
+import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { relative as relative3, resolve as resolve5 } from "path";
 var isPathOutsideBase = (value) => {
   return value === ".." || value.startsWith("../") || value.startsWith("..\\");
 };
@@ -5785,7 +7003,7 @@ 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 = resolve4(inputPath ?? process.cwd());
+  const resolvedTargetPath = resolve5(inputPath ?? process.cwd());
   logger.info("building current snapshot");
   const current = await buildAnalysisSnapshot(
     inputPath,
@@ -5839,13 +7057,13 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
         repositoryPath: resolvedTargetPath,
         baselineRef,
         analyzeWorktree: async (worktreePath, repositoryRoot) => {
-          const relativeTargetPath = relative2(repositoryRoot, resolvedTargetPath);
+          const relativeTargetPath = relative3(repositoryRoot, resolvedTargetPath);
           if (isPathOutsideBase(relativeTargetPath)) {
             throw new GovernanceConfigurationError(
               `target path is outside git repository root: ${resolvedTargetPath}`
             );
           }
-          const baselineTargetPath = relativeTargetPath.length === 0 || relativeTargetPath === "." ? worktreePath : resolve4(worktreePath, relativeTargetPath);
+          const baselineTargetPath = relativeTargetPath.length === 0 || relativeTargetPath === "." ? worktreePath : resolve5(worktreePath, relativeTargetPath);
           return buildAnalysisSnapshot(
             baselineTargetPath,
             authorIdentityMode,
@@ -5871,7 +7089,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 readFile3(options.baselinePath, "utf8");
+    const baselineRaw = await readFile4(options.baselinePath, "utf8");
     try {
       baseline = parseSnapshot(baselineRaw);
     } catch (error) {
@@ -5919,7 +7137,7 @@ ${ciMarkdown}`;
 };
 
 // src/application/run-report-command.ts
-import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 var runReportCommand = async (inputPath, authorIdentityMode, options, logger = createSilentLogger()) => {
   logger.info("building analysis snapshot");
   const current = await buildAnalysisSnapshot(
@@ -5941,7 +7159,7 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     report = createReport(current);
   } else {
     logger.info(`loading baseline snapshot: ${options.comparePath}`);
-    const baselineRaw = await readFile4(options.comparePath, "utf8");
+    const baselineRaw = await readFile5(options.comparePath, "utf8");
     const baseline = parseSnapshot(baselineRaw);
     const diff = compareSnapshots(current, baseline);
     report = createReport(current, diff);
@@ -5987,7 +7205,9 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
   const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
   const evaluation = evaluateRepositoryRisk(
     {
-      ...analysisInputs,
+      structural: analysisInputs.structural,
+      evolution: analysisInputs.evolution,
+      external: analysisInputs.external,
       ...riskConfig === void 0 ? {} : { config: riskConfig }
     },
     { explain: true }
@@ -5996,10 +7216,19 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
     throw new Error("risk trace unavailable");
   }
   const summary = {
-    ...analysisInputs,
-    risk: evaluation.summary
+    structural: analysisInputs.structural,
+    evolution: analysisInputs.evolution,
+    external: analysisInputs.external,
+    risk: evaluation.summary,
+    quality: computeRepositoryQualitySummary({
+      structural: analysisInputs.structural,
+      evolution: analysisInputs.evolution,
+      signals: analysisInputs.qualitySignals
+    })
   };
-  logger.info(`explanation completed (riskScore=${summary.risk.riskScore})`);
+  logger.info(
+    `explanation completed (riskScore=${summary.risk.riskScore}, qualityScore=${summary.quality.qualityScore})`
+  );
   return {
     summary,
     trace: evaluation.trace,
@@ -6009,7 +7238,7 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
 
 // src/index.ts
 var program = new Command();
-var packageJsonPath = resolve5(dirname2(fileURLToPath(import.meta.url)), "../package.json");
+var packageJsonPath = resolve6(dirname2(fileURLToPath(import.meta.url)), "../package.json");
 var { version } = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
 var parseRecentWindowDays = (value) => {
   const parsed = Number.parseInt(value, 10);
@@ -6055,6 +7284,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(`  normalizedScore: ${report.repository.normalizedScore}`);
   lines.push(`  riskTier: ${report.repository.riskTier}`);
   lines.push("");
@@ -6070,6 +7300,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(`- normalizedScore: \`${report.repository.normalizedScore}\``);
   lines.push(`- riskTier: \`${report.repository.riskTier}\``);
   lines.push("");
@@ -6087,6 +7318,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(`  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"}`
@@ -6112,6 +7344,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(`- 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"}\``
@@ -6281,7 +7514,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
     "log verbosity: silent, error, warn, info, debug (logs are written to stderr)"
   ).choices(["silent", "error", "warn", "info", "debug"]).default(parseLogLevel(process.env["CODESENTINEL_LOG_LEVEL"]))
 ).addOption(
-  new Option("--format <mode>", "combined output format: text, md, json").choices(["text", "md", "json"]).default("text")
+  new Option("--format <mode>", "combined output format: text, md, json").choices(["text", "md", "json"]).default("md")
 ).addOption(
   new Option("--detail <level>", "run detail level: compact (default), standard, full").choices(["compact", "standard", "full"]).default("compact")
 ).option("--file <path>", "explain a specific file target").option("--module <name>", "explain a specific module target").option("--top <count>", "number of top hotspots to explain when no target is selected", "5").option("--compare <baseline>", "compare against a baseline snapshot JSON file").option("--snapshot <path>", "write current snapshot JSON artifact").option("--no-trace", "disable trace embedding in generated snapshot").addOption(
@@ -6316,7 +7549,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 readFile5(options.compare, "utf8")))
+      compareSnapshots(snapshot, parseSnapshot(await readFile6(options.compare, "utf8")))
     );
     if (options.format === "json") {
       const analyzeSummaryOutput = formatAnalyzeOutput(explain.summary, "summary");
@@ -6360,6 +7593,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
               },
               report: {
                 repository: report.repository,
+                quality: report.quality,
                 hotspots: report.hotspots.slice(0, 5),
                 structural: report.structural,
                 external: report.external
@@ -6507,19 +7741,23 @@ var parseMainBranches = (options) => {
   return unique.length > 0 ? unique : void 0;
 };
 var buildGateConfigFromOptions = (options) => {
-  const maxRepoDelta = parseGateNumber(options.maxRepoDelta, "--max-repo-delta");
+  const maxRiskDelta = parseGateNumber(options.maxRiskDelta, "--max-risk-delta");
+  const maxQualityDelta = parseGateNumber(options.maxQualityDelta, "--max-quality-delta");
   const maxNewHotspots = parseGateNumber(options.maxNewHotspots, "--max-new-hotspots");
-  const maxRepoScore = parseGateNumber(options.maxRepoScore, "--max-repo-score");
+  const maxRiskScore = parseGateNumber(options.maxRiskScore, "--max-risk-score");
+  const minQualityScore = parseGateNumber(options.minQualityScore, "--min-quality-score");
   const newHotspotScoreThreshold = parseGateNumber(
     options.newHotspotScoreThreshold,
     "--new-hotspot-score-threshold"
   );
   return {
-    ...maxRepoDelta === void 0 ? {} : { maxRepoDelta },
+    ...maxRiskDelta === void 0 ? {} : { maxRiskDelta },
+    ...maxQualityDelta === void 0 ? {} : { maxQualityDelta },
     ...options.noNewCycles === true ? { noNewCycles: true } : {},
     ...options.noNewHighRiskDeps === true ? { noNewHighRiskDeps: true } : {},
     ...maxNewHotspots === void 0 ? {} : { maxNewHotspots },
-    ...maxRepoScore === void 0 ? {} : { maxRepoScore },
+    ...maxRiskScore === void 0 ? {} : { maxRiskScore },
+    ...minQualityScore === void 0 ? {} : { minQualityScore },
     ...newHotspotScoreThreshold === void 0 ? {} : { newHotspotScoreThreshold },
     failOn: options.failOn
   };
@@ -6534,7 +7772,10 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
     "--log-level <level>",
     "log verbosity: silent, error, warn, info, debug (logs are written to stderr)"
   ).choices(["silent", "error", "warn", "info", "debug"]).default(parseLogLevel(process.env["CODESENTINEL_LOG_LEVEL"]))
-).option("--compare <baseline>", "baseline snapshot path").option("--max-repo-delta <value>", "maximum allowed normalized repository score increase").option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-repo-score <score>", "absolute repository score limit (0..100)").addOption(
+).option("--compare <baseline>", "baseline snapshot path").option("--max-risk-delta <value>", "maximum allowed normalized risk score increase").option(
+  "--max-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(
   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")
@@ -6602,7 +7843,10 @@ program.command("ci").argument("[path]", "path to the project to analyze").addOp
 ).option(
   "--main-branches <names>",
   "comma-separated default branch candidates for auto baseline resolution (for example: main,master)"
-).option("--snapshot <path>", "write current snapshot JSON to path").option("--report <path>", "write markdown CI summary report").option("--json-output <path>", "write machine-readable CI JSON output").option("--max-repo-delta <value>", "maximum allowed normalized repository score increase").option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-repo-score <score>", "absolute repository score limit (0..100)").addOption(
+).option("--snapshot <path>", "write current snapshot JSON to path").option("--report <path>", "write markdown CI summary report").option("--json-output <path>", "write machine-readable CI JSON output").option("--max-risk-delta <value>", "maximum allowed normalized risk score increase").option(
+  "--max-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(
   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(