@getcodesentinel/codesentinel 1.15.0 → 1.16.0

package/dist/index.js

@@ -1733,11 +1733,15 @@ var renderTextReport = (report) => {
   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} @ ${issue.target}: ${issue.message}`
+      `    - [${issue.severity}] (${issue.dimension}) ${issue.id}${ruleSuffix} @ ${issue.target}: ${issue.message}`
     );
   }
   if (report.quality.topIssues.length === 0) {
@@ -1824,14 +1828,18 @@ var renderMarkdownReport = (report) => {
   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}\` (\`${issue.dimension}\`) @ \`${issue.target}\`: ${issue.message}`
+        `  - [${issue.severity}] \`${issue.id}\`${ruleSuffix} (\`${issue.dimension}\`) @ \`${issue.target}\`: ${issue.message}`
       );
     }
   }
@@ -1981,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(
@@ -2001,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");
@@ -2494,7 +2543,7 @@ var resolveAutoBaselineRef = async (input) => {
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
 import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve5 } from "path";
+import { dirname as dirname2, resolve as resolve6 } from "path";
 import { fileURLToPath } from "url";
 
 // src/application/format-analyze-output.ts
@@ -2890,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.-]+)?$/;
@@ -3082,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;
@@ -3095,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
@@ -3108,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);
@@ -3134,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") {
@@ -3193,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);
     }
@@ -3216,8 +3265,7 @@ var checkForCliUpdates = async (input) => {
 };
 
 // src/application/run-analyze-command.ts
-import { readFile as readFile2 } from "fs/promises";
-import { join as join4, resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 
 // ../code-graph/dist/index.js
 import { extname, isAbsolute, relative, resolve as resolve2 } from "path";
@@ -4265,6 +4313,538 @@ 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)) {
@@ -4305,14 +4885,38 @@ var concentration = (rawValues) => {
   return clamp01(normalized);
 };
 var DIMENSION_WEIGHTS = {
-  modularity: 0.45,
-  changeHygiene: 0.35,
-  testHealth: 0.2
-};
-var TODO_FIXME_MAX_IMPACT = 0.08;
+  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 isTestPath = (path) => {
+var isTestPath2 = (path) => {
   const normalized = path.toLowerCase();
   return normalized.includes("/__tests__/") || normalized.includes("\\__tests__\\") || normalized.includes(".test.") || normalized.includes(".spec.");
 };
@@ -4320,7 +4924,7 @@ var isSourcePath = (path) => {
   if (path.endsWith(".d.ts")) {
     return false;
   }
-  return !isTestPath(path);
+  return !isTestPath2(path);
 };
 var pushIssue = (issues, issue) => {
   issues.push({
@@ -4331,22 +4935,24 @@ var pushIssue = (issues, issue) => {
 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.6)
+      impact: round45(cyclePenalty * 0.55)
     });
   }
-  const fanInConcentration = concentration(input.structural.files.map((file) => file.fanIn));
-  const fanOutConcentration = concentration(input.structural.files.map((file) => file.fanOut));
-  const centralityConcentration = average([fanInConcentration, fanOutConcentration]);
   if (centralityConcentration >= 0.5) {
     const hottest = [...input.structural.files].map((file) => ({
       path: file.relativePath,
@@ -4354,12 +4960,44 @@ var computeRepositoryQualitySummary = (input) => {
     })).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.5)
+      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;
@@ -4385,10 +5023,11 @@ var computeRepositoryQualitySummary = (input) => {
       )[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.45)
+        impact: round45(churnConcentration * 0.4)
       });
     }
     if (volatilityConcentration >= 0.45) {
@@ -4397,10 +5036,11 @@ var computeRepositoryQualitySummary = (input) => {
       )[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.4)
+        impact: round45(volatilityConcentration * 0.3)
       });
     }
     if (couplingDensity >= 0.35 || couplingIntensity >= 0.45) {
@@ -4409,61 +5049,369 @@ var computeRepositoryQualitySummary = (input) => {
       )[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.35)
+        impact: round45(average([couplingDensity, couplingIntensity]) * 0.3)
       });
     }
   }
-  const modularityPenalty = clamp01(cyclePenalty * 0.55 + centralityConcentration * 0.45);
-  const changeHygienePenalty = input.evolution.available ? clamp01(
-    churnConcentration * 0.4 + volatilityConcentration * 0.35 + couplingDensity * 0.15 + couplingIntensity * 0.1
-  ) : 0.25;
+  const 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) => isTestPath(path)).length;
+  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.3);
+  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(testPresencePenalty * 0.5)
+      impact: round45(testHealthPenalty * 0.4)
     });
   }
-  const todoFixmeCount = Math.max(0, input.todoFixmeCount ?? 0);
-  const todoFixmePenalty = clamp01(todoFixmeCount / 120) * TODO_FIXME_MAX_IMPACT;
-  if (todoFixmeCount > 0) {
+  if (coverageRatio !== null && coverageRatio < 0.6) {
     pushIssue(issues, {
-      id: "quality.change_hygiene.todo_fixme_load",
-      dimension: "changeHygiene",
+      id: "quality.test_health.low_coverage",
+      ruleId: "coverage.threshold",
+      dimension: "testHealth",
       target: input.structural.targetPath,
-      message: `Found ${todoFixmeCount} TODO/FIXME marker(s); cleanup debt is accumulating.`,
-      impact: round45(todoFixmePenalty * 0.2)
+      message: `Coverage is below threshold (${toPercentage(coverageRatio)}%).`,
+      impact: round45(testHealthPenalty * 0.35)
     });
   }
   const modularityQuality = clamp01(1 - modularityPenalty);
-  const changeHygieneQuality = clamp01(1 - clamp01(changeHygienePenalty + todoFixmePenalty));
-  const testHealthQuality = clamp01(1 - testPresencePenalty);
+  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 + testHealthQuality * DIMENSION_WEIGHTS.testHealth
+    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, 8).map(({ impact: _impact, ...issue }) => issue);
+  ).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
+    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)
+      ]
+    }
   };
 };
 
@@ -4640,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) {
@@ -4715,7 +5663,7 @@ var computeEvolutionHistoryConfidence = (structural, evolution, evolutionByFile)
   }
   let coveredFiles = 0;
   for (const file of structural.files) {
-    if (evolutionByFile.has(normalizePath2(file.id))) {
+    if (evolutionByFile.has(normalizePath3(file.id))) {
       coveredFiles += 1;
     }
   }
@@ -4909,7 +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) => {
@@ -4933,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;
@@ -4954,7 +5902,7 @@ var buildFragileClusters = (structural, evolution, fileScoresByFile, config) =>
   const clusters = [];
   let cycleClusterCount = 0;
   for (const cycle of structural.cycles) {
-    const files = [...new Set(cycle.nodes.map((node) => normalizePath2(node)))].filter(
+    const files = [...new Set(cycle.nodes.map((node) => normalizePath3(node)))].filter(
       (filePath) => fileScoresByFile.has(filePath)
     );
     if (files.length < 2) {
@@ -4986,8 +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)
@@ -5065,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)),
@@ -5088,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);
@@ -5704,30 +6652,8 @@ var evaluateRepositoryRisk = (input, options = {}) => {
   };
 };
 
-// src/application/todo-fixme-counter.ts
-import * as ts2 from "typescript";
-var markerRegex = /\b(?:TODO|FIXME)\b/gi;
-var countMarkers = (text) => text.match(markerRegex)?.length ?? 0;
-var countTodoFixmeInComments = (content) => {
-  const scanner = ts2.createScanner(
-    ts2.ScriptTarget.Latest,
-    false,
-    ts2.LanguageVariant.Standard,
-    content
-  );
-  let total = 0;
-  let token = scanner.scan();
-  while (token !== ts2.SyntaxKind.EndOfFileToken) {
-    if (token === ts2.SyntaxKind.SingleLineCommentTrivia || token === ts2.SyntaxKind.MultiLineCommentTrivia) {
-      total += countMarkers(scanner.getTokenText());
-    }
-    token = scanner.scan();
-  }
-  return total;
-};
-
 // src/application/run-analyze-command.ts
-var resolveTargetPath = (inputPath, cwd) => resolve3(cwd, inputPath ?? ".");
+var resolveTargetPath = (inputPath, cwd) => resolve4(cwd, inputPath ?? ".");
 var riskProfileConfig = {
   default: void 0,
   personal: {
@@ -5854,18 +6780,6 @@ var createEvolutionProgressReporter = (logger) => {
     }
   };
 };
-var collectTodoFixmeCount = async (targetPath, structural) => {
-  const filePaths2 = [...structural.files].map((file) => file.relativePath).sort((a, b) => a.localeCompare(b));
-  let total = 0;
-  for (const relativePath of filePaths2) {
-    try {
-      const content = await readFile2(join4(targetPath, relativePath), "utf8");
-      total += countTodoFixmeInComments(content);
-    } catch {
-    }
-  }
-  return total;
-};
 var collectAnalysisInputs = async (inputPath, authorIdentityMode, options = {}, logger = createSilentLogger()) => {
   const invocationCwd = process.env["INIT_CWD"] ?? process.cwd();
   const targetPath = resolveTargetPath(inputPath, invocationCwd);
@@ -5908,14 +6822,16 @@ var collectAnalysisInputs = async (inputPath, authorIdentityMode, options = {},
   } else {
     logger.warn(`external analysis unavailable: ${external.reason}`);
   }
-  logger.info("collecting quality text signals");
-  const todoFixmeCount = await collectTodoFixmeCount(targetPath, structural);
-  logger.debug(`quality text signals: todoFixmeCount=${todoFixmeCount}`);
+  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,
-    todoFixmeCount
+    qualitySignals
   };
 };
 var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logger = createSilentLogger()) => {
@@ -5936,7 +6852,7 @@ var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logg
   const quality = computeRepositoryQualitySummary({
     structural: analysisInputs.structural,
     evolution: analysisInputs.evolution,
-    todoFixmeCount: analysisInputs.todoFixmeCount
+    signals: analysisInputs.qualitySignals
   });
   logger.info(
     `analysis completed (riskScore=${risk.riskScore}, qualityScore=${quality.qualityScore})`
@@ -5981,7 +6897,7 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
     quality: computeRepositoryQualitySummary({
       structural: analysisInputs.structural,
       evolution: analysisInputs.evolution,
-      todoFixmeCount: analysisInputs.todoFixmeCount
+      signals: analysisInputs.qualitySignals
     })
   };
   return createSnapshot({
@@ -6074,7 +6990,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
 
 // src/application/run-ci-command.ts
 import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { relative as relative2, resolve as resolve4 } from "path";
+import { relative as relative3, resolve as resolve5 } from "path";
 var isPathOutsideBase = (value) => {
   return value === ".." || value.startsWith("../") || value.startsWith("..\\");
 };
@@ -6087,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,
@@ -6141,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,
@@ -6307,7 +7223,7 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
     quality: computeRepositoryQualitySummary({
       structural: analysisInputs.structural,
       evolution: analysisInputs.evolution,
-      todoFixmeCount: analysisInputs.todoFixmeCount
+      signals: analysisInputs.qualitySignals
     })
   };
   logger.info(
@@ -6322,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);
@@ -6598,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(
@@ -6825,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
   };
@@ -6852,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")
@@ -6920,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(