@getcodesentinel/codesentinel 1.16.0 → 1.17.1

package/dist/index.js

@@ -7,6 +7,12 @@ import { Command, Option } from "commander";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { setTimeout as sleep } from "timers/promises";
+import { join as join4 } from "path";
+import { homedir } from "os";
+import { join as join2 } from "path";
+import { createHash } from "crypto";
+import { mkdir, readdir, readFile, rename, stat, unlink, writeFile } from "fs/promises";
+import { join as join3 } from "path";
 var round4 = (value) => Number(value.toFixed(4));
 var normalizeNodes = (nodes) => {
   const byName = /* @__PURE__ */ new Map();
@@ -614,6 +620,23 @@ var parseLockfileExtraction = (lockfileKind, lockfileRaw, directSpecs) => {
       throw new Error("unsupported_lockfile_format");
   }
 };
+var cachedFetch = async (options) => {
+  const nowMs = options.nowMs ?? Date.now();
+  const cachedEntry = options.cacheStore === null ? null : await options.cacheStore.get(options.key);
+  if (cachedEntry !== null && nowMs - cachedEntry.fetchedAtMs <= options.ttlMs) {
+    return cachedEntry.value;
+  }
+  try {
+    const fresh = await options.fetchFresh();
+    if (fresh !== null) {
+      void options.cacheStore?.set(options.key, { value: fresh, fetchedAtMs: nowMs }).catch(() => {
+      });
+      return fresh;
+    }
+  } catch {
+  }
+  return cachedEntry?.value ?? null;
+};
 var parseRetryAfterMs = (value) => {
   if (value === null) {
     return null;
@@ -640,8 +663,202 @@ var fetchJsonWithRetry = async (url, options) => {
   }
   return null;
 };
+var resolveCodesentinelCacheDir = (env = process.env) => {
+  const explicit = env["CODESENTINEL_CACHE_DIR"]?.trim();
+  if (explicit !== void 0 && explicit.length > 0) {
+    return explicit;
+  }
+  if (process.platform === "win32") {
+    const localAppData = env["LOCALAPPDATA"]?.trim();
+    if (localAppData !== void 0 && localAppData.length > 0) {
+      return join2(localAppData, "codesentinel", "Cache");
+    }
+    return join2(homedir(), "AppData", "Local", "codesentinel", "Cache");
+  }
+  const xdgCacheHome = env["XDG_CACHE_HOME"]?.trim();
+  if (xdgCacheHome !== void 0 && xdgCacheHome.length > 0) {
+    return join2(xdgCacheHome, "codesentinel");
+  }
+  return join2(homedir(), ".cache", "codesentinel");
+};
+var parseCacheEntryPayload = (value) => {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const payload = value;
+  if (typeof payload.key !== "string" || payload.key.length === 0) {
+    return null;
+  }
+  if (typeof payload.fetchedAtMs !== "number" || !Number.isFinite(payload.fetchedAtMs)) {
+    return null;
+  }
+  return {
+    key: payload.key,
+    fetchedAtMs: payload.fetchedAtMs,
+    value: payload.value
+  };
+};
+var DEFAULT_OPTIONS = {
+  maxBytes: 100 * 1024 * 1024,
+  maxEntryBytes: 4 * 1024 * 1024,
+  sweepIntervalWrites: 25
+};
+var FileCacheStore = class {
+  constructor(directoryPath, options = DEFAULT_OPTIONS) {
+    this.directoryPath = directoryPath;
+    this.options = options;
+  }
+  byKey = /* @__PURE__ */ new Map();
+  inFlightWrites = /* @__PURE__ */ new Map();
+  writesSinceSweep = 0;
+  sweepPromise = Promise.resolve();
+  toEntryPath(key) {
+    const digest = createHash("sha256").update(key).digest("hex");
+    return join3(this.directoryPath, `${digest}.json`);
+  }
+  async writeEntry(key, entry) {
+    const filePath = this.toEntryPath(key);
+    await mkdir(this.directoryPath, { recursive: true });
+    const tempPath = `${filePath}.tmp`;
+    const payload = {
+      key,
+      fetchedAtMs: entry.fetchedAtMs,
+      value: entry.value
+    };
+    const raw = JSON.stringify(payload);
+    if (Buffer.byteLength(raw, "utf8") > this.options.maxEntryBytes) {
+      return;
+    }
+    await writeFile(tempPath, raw, "utf8");
+    await rename(tempPath, filePath);
+  }
+  async sweepIfNeeded() {
+    this.writesSinceSweep += 1;
+    if (this.writesSinceSweep < this.options.sweepIntervalWrites) {
+      return;
+    }
+    this.writesSinceSweep = 0;
+    this.sweepPromise = this.sweepPromise.catch(() => {
+    }).then(async () => {
+      await this.evictToSizeLimit();
+    });
+    await this.sweepPromise;
+  }
+  async evictToSizeLimit() {
+    let entries;
+    try {
+      const dirEntries = await readdir(this.directoryPath, { withFileTypes: true });
+      entries = (await Promise.all(
+        dirEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map(async (entry) => {
+          const path = join3(this.directoryPath, entry.name);
+          const info = await stat(path);
+          return { path, size: info.size, mtimeMs: info.mtimeMs };
+        })
+      )).filter((entry) => Number.isFinite(entry.size) && entry.size > 0);
+    } catch {
+      return;
+    }
+    let totalBytes = entries.reduce((sum, entry) => sum + entry.size, 0);
+    if (totalBytes <= this.options.maxBytes) {
+      return;
+    }
+    entries.sort((a, b) => a.mtimeMs - b.mtimeMs);
+    for (const entry of entries) {
+      if (totalBytes <= this.options.maxBytes) {
+        break;
+      }
+      try {
+        await unlink(entry.path);
+        totalBytes -= entry.size;
+      } catch {
+      }
+    }
+  }
+  async get(key) {
+    if (this.byKey.has(key)) {
+      return this.byKey.get(key) ?? null;
+    }
+    try {
+      const raw = await readFile(this.toEntryPath(key), "utf8");
+      const parsed = parseCacheEntryPayload(JSON.parse(raw));
+      if (parsed === null || parsed.key !== key) {
+        this.byKey.set(key, null);
+        return null;
+      }
+      const value = { fetchedAtMs: parsed.fetchedAtMs, value: parsed.value };
+      this.byKey.set(key, value);
+      return value;
+    } catch {
+      this.byKey.set(key, null);
+      return null;
+    }
+  }
+  async set(key, entry) {
+    const normalized = entry;
+    this.byKey.set(key, normalized);
+    const previous = this.inFlightWrites.get(key) ?? Promise.resolve();
+    const next = previous.catch(() => {
+    }).then(async () => {
+      await this.writeEntry(key, normalized);
+      await this.sweepIfNeeded();
+    });
+    this.inFlightWrites.set(key, next);
+    await next;
+  }
+};
+var SIX_HOURS_MS = 6 * 60 * 60 * 1e3;
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
+var DEFAULT_MAX_ENTRY_BYTES = 4 * 1024 * 1024;
+var DEFAULT_SWEEP_INTERVAL_WRITES = 25;
+var cacheStoreSingleton;
+var parsePositiveIntegerFromEnv = (value, fallback) => {
+  if (value === void 0) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return fallback;
+  }
+  return parsed;
+};
+var cacheDisabled = (env) => {
+  const mode = env["CODESENTINEL_CACHE_MODE"]?.trim().toLowerCase();
+  return mode === "none";
+};
+var getNpmMetadataCacheStore = () => {
+  if (cacheStoreSingleton !== void 0) {
+    return cacheStoreSingleton;
+  }
+  if (cacheDisabled(process.env)) {
+    cacheStoreSingleton = null;
+    return cacheStoreSingleton;
+  }
+  const path = join4(resolveCodesentinelCacheDir(process.env), "npm-metadata-v2");
+  cacheStoreSingleton = new FileCacheStore(path, {
+    maxBytes: parsePositiveIntegerFromEnv(
+      process.env["CODESENTINEL_CACHE_MAX_BYTES"],
+      DEFAULT_MAX_BYTES
+    ),
+    maxEntryBytes: parsePositiveIntegerFromEnv(
+      process.env["CODESENTINEL_CACHE_MAX_ENTRY_BYTES"],
+      DEFAULT_MAX_ENTRY_BYTES
+    ),
+    sweepIntervalWrites: parsePositiveIntegerFromEnv(
+      process.env["CODESENTINEL_CACHE_SWEEP_INTERVAL_WRITES"],
+      DEFAULT_SWEEP_INTERVAL_WRITES
+    )
+  });
+  return cacheStoreSingleton;
+};
+var getPackumentCacheTtlMs = () => parsePositiveIntegerFromEnv(process.env["CODESENTINEL_CACHE_TTL_PACKUMENT_MS"], SIX_HOURS_MS);
+var getWeeklyDownloadsCacheTtlMs = () => parsePositiveIntegerFromEnv(process.env["CODESENTINEL_CACHE_TTL_DOWNLOADS_MS"], ONE_DAY_MS);
+var toMetadataPackumentCacheKey = (name) => `npm:packument:metadata:${name}`;
+var toGraphPackumentCacheKey = (name) => `npm:packument:graph:${name}`;
+var toWeeklyDownloadsCacheKey = (name) => `npm:downloads:last-week:${name}`;
 var MAX_RETRIES = 3;
 var RETRY_BASE_DELAY_MS = 500;
+var PACKUMENT_CACHE_STORE = getNpmMetadataCacheStore();
 var parsePrerelease = (value) => {
   if (value === void 0 || value.length === 0) {
     return [];
@@ -892,23 +1109,62 @@ var resolveRangeVersion = (versions, requested) => {
   }
   return null;
 };
+var slimPackumentForGraph = (payload) => {
+  const versions = payload.versions ?? {};
+  const dependenciesByVersion = {};
+  const versionNames = Object.keys(versions);
+  for (const [version2, manifest] of Object.entries(versions)) {
+    const dependenciesRaw = manifest?.dependencies ?? {};
+    const dependencies = {};
+    for (const [dependencyName, dependencyRange] of Object.entries(dependenciesRaw)) {
+      if (dependencyName.length > 0 && dependencyRange.length > 0) {
+        dependencies[dependencyName] = dependencyRange;
+      }
+    }
+    if (Object.keys(dependencies).length > 0) {
+      dependenciesByVersion[version2] = dependencies;
+    }
+  }
+  const slim = {
+    versionNames,
+    dependenciesByVersion
+  };
+  if (payload["dist-tags"] !== void 0) {
+    slim["dist-tags"] = payload["dist-tags"];
+  }
+  return slim;
+};
 var fetchPackument = async (name) => {
   const encodedName = encodeURIComponent(name);
   try {
-    return await fetchJsonWithRetry(`https://registry.npmjs.org/${encodedName}`, {
-      retries: MAX_RETRIES,
-      baseDelayMs: RETRY_BASE_DELAY_MS
+    return await cachedFetch({
+      key: toGraphPackumentCacheKey(name),
+      ttlMs: getPackumentCacheTtlMs(),
+      cacheStore: PACKUMENT_CACHE_STORE,
+      fetchFresh: async () => {
+        const payload = await fetchJsonWithRetry(
+          `https://registry.npmjs.org/${encodedName}`,
+          {
+            retries: MAX_RETRIES,
+            baseDelayMs: RETRY_BASE_DELAY_MS
+          }
+        );
+        if (payload === null) {
+          return null;
+        }
+        return slimPackumentForGraph(payload);
+      }
     });
   } catch {
     return null;
   }
 };
 var resolveRequestedVersion = (packument, requested) => {
-  const versions = packument.versions ?? {};
-  const versionKeys = Object.keys(versions);
+  const versionKeys = [...packument.versionNames];
+  const versionSet = new Set(versionKeys);
   const tags = packument["dist-tags"] ?? {};
   const latest = tags["latest"];
-  if (requested !== null && versions[requested] !== void 0) {
+  if (requested !== null && versionSet.has(requested)) {
     return {
       version: requested,
       resolution: "exact",
@@ -917,7 +1173,7 @@ var resolveRequestedVersion = (packument, requested) => {
   }
   if (requested !== null) {
     const tagged = tags[requested];
-    if (tagged !== void 0 && versions[tagged] !== void 0) {
+    if (tagged !== void 0 && versionSet.has(tagged)) {
       return {
         version: tagged,
         resolution: "tag",
@@ -927,7 +1183,7 @@ var resolveRequestedVersion = (packument, requested) => {
   }
   if (requested !== null) {
     const matched = resolveRangeVersion(versionKeys, requested);
-    if (matched !== null && versions[matched] !== void 0) {
+    if (matched !== null && versionSet.has(matched)) {
       return {
         version: matched,
         resolution: "range",
@@ -935,7 +1191,7 @@ var resolveRequestedVersion = (packument, requested) => {
       };
     }
   }
-  if (latest !== void 0 && versions[latest] !== void 0) {
+  if (latest !== void 0 && versionSet.has(latest)) {
     return {
       version: latest,
       resolution: "latest",
@@ -1016,8 +1272,8 @@ var resolveRegistryGraphFromDirectSpecs = async (directSpecs, options) => {
     if (nodesByKey.has(nodeKey)) {
       continue;
     }
-    const manifest = (packument.versions ?? {})[resolved.version] ?? {};
-    const dependencies = Object.entries(manifest.dependencies ?? {}).filter(
+    const manifestDependencies = packument.dependenciesByVersion[resolved.version] ?? {};
+    const dependencies = Object.entries(manifestDependencies).filter(
       ([dependencyName, dependencyRange]) => dependencyName.length > 0 && dependencyRange.length > 0
     ).sort((a, b) => a[0].localeCompare(b[0]));
     nodesByKey.set(nodeKey, {
@@ -1301,7 +1557,7 @@ var analyzeDependencyCandidate = async (input, metadataProvider) => {
     external
   };
 };
-var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var ONE_DAY_MS2 = 24 * 60 * 60 * 1e3;
 var MAX_RETRIES2 = 3;
 var RETRY_BASE_DELAY_MS2 = 500;
 var round42 = (value) => Number(value.toFixed(4));
@@ -1314,12 +1570,18 @@ var parseDate = (iso) => {
 };
 var NpmRegistryMetadataProvider = class {
   cache = /* @__PURE__ */ new Map();
+  cacheStore = getNpmMetadataCacheStore();
   async fetchWeeklyDownloads(name) {
     const encodedName = encodeURIComponent(name);
-    const payload = await fetchJsonWithRetry(
-      `https://api.npmjs.org/downloads/point/last-week/${encodedName}`,
-      { retries: MAX_RETRIES2, baseDelayMs: RETRY_BASE_DELAY_MS2 }
-    );
+    const payload = await cachedFetch({
+      key: toWeeklyDownloadsCacheKey(name),
+      ttlMs: getWeeklyDownloadsCacheTtlMs(),
+      cacheStore: this.cacheStore,
+      fetchFresh: async () => await fetchJsonWithRetry(
+        `https://api.npmjs.org/downloads/point/last-week/${encodedName}`,
+        { retries: MAX_RETRIES2, baseDelayMs: RETRY_BASE_DELAY_MS2 }
+      )
+    });
     if (payload === null) {
       return null;
     }
@@ -1336,10 +1598,31 @@ var NpmRegistryMetadataProvider = class {
     }
     try {
       const encodedName = encodeURIComponent(name);
-      const payload = await fetchJsonWithRetry(
-        `https://registry.npmjs.org/${encodedName}`,
-        { retries: MAX_RETRIES2, baseDelayMs: RETRY_BASE_DELAY_MS2 }
-      );
+      const payload = await cachedFetch({
+        key: toMetadataPackumentCacheKey(name),
+        ttlMs: getPackumentCacheTtlMs(),
+        cacheStore: this.cacheStore,
+        fetchFresh: async () => {
+          const fresh = await fetchJsonWithRetry(
+            `https://registry.npmjs.org/${encodedName}`,
+            {
+              retries: MAX_RETRIES2,
+              baseDelayMs: RETRY_BASE_DELAY_MS2
+            }
+          );
+          if (fresh === null) {
+            return null;
+          }
+          const slim = {};
+          if (fresh.time !== void 0) {
+            slim.time = fresh.time;
+          }
+          if (fresh.maintainers !== void 0) {
+            slim.maintainers = fresh.maintainers;
+          }
+          return slim;
+        }
+      });
       if (payload === null) {
         this.cache.set(key, null);
         return null;
@@ -1348,7 +1631,7 @@ var NpmRegistryMetadataProvider = class {
       const publishDates = Object.entries(timeEntries).filter(([tag]) => tag !== "created" && tag !== "modified").map(([, date]) => parseDate(date)).filter((value) => value !== null).sort((a, b) => a - b);
       const modifiedAt = parseDate(timeEntries["modified"]);
       const now = Date.now();
-      const daysSinceLastRelease = modifiedAt === null ? null : Math.max(0, round42((now - modifiedAt) / ONE_DAY_MS));
+      const daysSinceLastRelease = modifiedAt === null ? null : Math.max(0, round42((now - modifiedAt) / ONE_DAY_MS2));
       let releaseFrequencyDays = null;
       if (publishDates.length >= 2) {
         const totalIntervals = publishDates.length - 1;
@@ -1360,7 +1643,7 @@ var NpmRegistryMetadataProvider = class {
             sum += current - previous;
           }
         }
-        releaseFrequencyDays = round42(sum / totalIntervals / ONE_DAY_MS);
+        releaseFrequencyDays = round42(sum / totalIntervals / ONE_DAY_MS2);
       }
       const maintainers = payload.maintainers ?? [];
       const maintainerCount = maintainers.length > 0 ? maintainers.length : null;
@@ -1656,7 +1939,7 @@ var createReport = (snapshot, diff) => {
       confidence: repositoryConfidence(snapshot),
       dimensionScores: repositoryDimensionScores(snapshot)
     },
-    quality: snapshot.analysis.quality,
+    health: snapshot.analysis.health,
     hotspots: hotspotItems(snapshot),
     structural: {
       cycleCount: snapshot.analysis.structural.metrics.cycleCount,
@@ -1728,23 +2011,21 @@ var renderTextReport = (report) => {
   lines.push(`  external: ${report.repository.dimensionScores.external ?? "n/a"}`);
   lines.push(`  interactions: ${report.repository.dimensionScores.interactions ?? "n/a"}`);
   lines.push("");
-  lines.push("Quality Summary");
-  lines.push(`  qualityScore: ${report.quality.qualityScore}`);
-  lines.push(`  normalizedScore: ${report.quality.normalizedScore}`);
-  lines.push(`  modularity: ${report.quality.dimensions.modularity}`);
-  lines.push(`  changeHygiene: ${report.quality.dimensions.changeHygiene}`);
-  lines.push(`  staticAnalysis: ${report.quality.dimensions.staticAnalysis}`);
-  lines.push(`  complexity: ${report.quality.dimensions.complexity}`);
-  lines.push(`  duplication: ${report.quality.dimensions.duplication}`);
-  lines.push(`  testHealth: ${report.quality.dimensions.testHealth}`);
+  lines.push("Health Summary");
+  lines.push(`  healthScore: ${report.health.healthScore}`);
+  lines.push(`  normalizedScore: ${report.health.normalizedScore}`);
+  lines.push(`  modularity: ${report.health.dimensions.modularity}`);
+  lines.push(`  changeHygiene: ${report.health.dimensions.changeHygiene}`);
+  lines.push(`  testHealth: ${report.health.dimensions.testHealth}`);
+  lines.push(`  ownershipDistribution: ${report.health.dimensions.ownershipDistribution}`);
   lines.push("  topIssues:");
-  for (const issue of report.quality.topIssues.slice(0, 5)) {
+  for (const issue of report.health.topIssues.slice(0, 5)) {
     const ruleSuffix = issue.ruleId === void 0 ? "" : ` [rule=${issue.ruleId}]`;
     lines.push(
       `    - [${issue.severity}] (${issue.dimension}) ${issue.id}${ruleSuffix} @ ${issue.target}: ${issue.message}`
     );
   }
-  if (report.quality.topIssues.length === 0) {
+  if (report.health.topIssues.length === 0) {
     lines.push("    - none");
   }
   lines.push("");
@@ -1823,20 +2104,18 @@ var renderMarkdownReport = (report) => {
   lines.push(`- external: \`${report.repository.dimensionScores.external ?? "n/a"}\``);
   lines.push(`- interactions: \`${report.repository.dimensionScores.interactions ?? "n/a"}\``);
   lines.push("");
-  lines.push("## Quality Summary");
-  lines.push(`- qualityScore: \`${report.quality.qualityScore}\``);
-  lines.push(`- normalizedScore: \`${report.quality.normalizedScore}\``);
-  lines.push(`- modularity: \`${report.quality.dimensions.modularity}\``);
-  lines.push(`- changeHygiene: \`${report.quality.dimensions.changeHygiene}\``);
-  lines.push(`- staticAnalysis: \`${report.quality.dimensions.staticAnalysis}\``);
-  lines.push(`- complexity: \`${report.quality.dimensions.complexity}\``);
-  lines.push(`- duplication: \`${report.quality.dimensions.duplication}\``);
-  lines.push(`- testHealth: \`${report.quality.dimensions.testHealth}\``);
-  if (report.quality.topIssues.length === 0) {
+  lines.push("## Health Summary");
+  lines.push(`- healthScore: \`${report.health.healthScore}\``);
+  lines.push(`- normalizedScore: \`${report.health.normalizedScore}\``);
+  lines.push(`- modularity: \`${report.health.dimensions.modularity}\``);
+  lines.push(`- changeHygiene: \`${report.health.dimensions.changeHygiene}\``);
+  lines.push(`- testHealth: \`${report.health.dimensions.testHealth}\``);
+  lines.push(`- ownershipDistribution: \`${report.health.dimensions.ownershipDistribution}\``);
+  if (report.health.topIssues.length === 0) {
     lines.push("- top issues: none");
   } else {
     lines.push("- top issues:");
-    for (const issue of report.quality.topIssues.slice(0, 5)) {
+    for (const issue of report.health.topIssues.slice(0, 5)) {
       const ruleSuffix = issue.ruleId === void 0 ? "" : ` [rule=${issue.ruleId}]`;
       lines.push(
         `  - [${issue.severity}] \`${issue.id}\`${ruleSuffix} (\`${issue.dimension}\`) @ \`${issue.target}\`: ${issue.message}`
@@ -1929,7 +2208,7 @@ var formatReport = (report, format) => {
 
 // ../governance/dist/index.js
 import { mkdirSync, rmSync } from "fs";
-import { basename, join as join2, resolve } from "path";
+import { basename, join as join5, resolve } from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var EXIT_CODES = {
@@ -1992,8 +2271,8 @@ var validateGateConfig = (input) => {
   if (config.maxRiskDelta !== void 0 && (!Number.isFinite(config.maxRiskDelta) || config.maxRiskDelta < 0)) {
     throw new GovernanceConfigurationError("max-risk-delta must be a finite number >= 0");
   }
-  if (config.maxQualityDelta !== void 0 && (!Number.isFinite(config.maxQualityDelta) || config.maxQualityDelta < 0)) {
-    throw new GovernanceConfigurationError("max-quality-delta must be a finite number >= 0");
+  if (config.maxHealthDelta !== void 0 && (!Number.isFinite(config.maxHealthDelta) || config.maxHealthDelta < 0)) {
+    throw new GovernanceConfigurationError("max-health-delta must be a finite number >= 0");
   }
   if (config.maxNewHotspots !== void 0 && (!Number.isInteger(config.maxNewHotspots) || config.maxNewHotspots < 0)) {
     throw new GovernanceConfigurationError("max-new-hotspots must be an integer >= 0");
@@ -2001,8 +2280,8 @@ var validateGateConfig = (input) => {
   if (config.maxRiskScore !== void 0 && (!Number.isFinite(config.maxRiskScore) || config.maxRiskScore < 0 || config.maxRiskScore > 100)) {
     throw new GovernanceConfigurationError("max-risk-score must be a number in [0, 100]");
   }
-  if (config.minQualityScore !== void 0 && (!Number.isFinite(config.minQualityScore) || config.minQualityScore < 0 || config.minQualityScore > 100)) {
-    throw new GovernanceConfigurationError("min-quality-score must be a number in [0, 100]");
+  if (config.minHealthScore !== void 0 && (!Number.isFinite(config.minHealthScore) || config.minHealthScore < 0 || config.minHealthScore > 100)) {
+    throw new GovernanceConfigurationError("min-health-score must be a number in [0, 100]");
   }
   if (config.newHotspotScoreThreshold !== void 0 && (!Number.isFinite(config.newHotspotScoreThreshold) || config.newHotspotScoreThreshold < 0 || config.newHotspotScoreThreshold > 100)) {
     throw new GovernanceConfigurationError(
@@ -2030,17 +2309,17 @@ var evaluateGates = (input) => {
       );
     }
   }
-  if (config.minQualityScore !== void 0) {
-    evaluatedGates.push("min-quality-score");
-    const current = input.current.analysis.quality.qualityScore;
-    if (current < config.minQualityScore) {
+  if (config.minHealthScore !== void 0) {
+    evaluatedGates.push("min-health-score");
+    const current = input.current.analysis.health.healthScore;
+    if (current < config.minHealthScore) {
       violations.push(
         makeViolation(
-          "min-quality-score",
+          "min-health-score",
           "error",
-          `Quality score ${current} is below configured minimum ${config.minQualityScore}.`,
+          `Health score ${current} is below configured minimum ${config.minHealthScore}.`,
           [input.current.analysis.structural.targetPath],
-          [{ kind: "repository_metric", metric: "qualityScore" }]
+          [{ kind: "repository_metric", metric: "healthScore" }]
         )
       );
     }
@@ -2065,22 +2344,22 @@ var evaluateGates = (input) => {
       );
     }
   }
-  if (config.maxQualityDelta !== void 0) {
-    evaluatedGates.push("max-quality-delta");
-    requireDiff(input, "max-quality-delta");
+  if (config.maxHealthDelta !== void 0) {
+    evaluatedGates.push("max-health-delta");
+    requireDiff(input, "max-health-delta");
     const baseline = input.baseline;
     if (baseline === void 0) {
-      throw new GovernanceConfigurationError("max-quality-delta requires baseline snapshot");
+      throw new GovernanceConfigurationError("max-health-delta requires baseline snapshot");
     }
-    const delta = input.current.analysis.quality.normalizedScore - baseline.analysis.quality.normalizedScore;
-    if (delta < -config.maxQualityDelta) {
+    const delta = input.current.analysis.health.normalizedScore - baseline.analysis.health.normalizedScore;
+    if (delta < -config.maxHealthDelta) {
       violations.push(
         makeViolation(
-          "max-quality-delta",
+          "max-health-delta",
           "error",
-          `Quality normalized score delta ${delta.toFixed(4)} is below allowed minimum ${(-config.maxQualityDelta).toFixed(4)}.`,
+          `Health normalized score delta ${delta.toFixed(4)} is below allowed minimum ${(-config.maxHealthDelta).toFixed(4)}.`,
           [input.current.analysis.structural.targetPath],
-          [{ kind: "repository_metric", metric: "qualityNormalizedScore" }]
+          [{ kind: "repository_metric", metric: "healthNormalizedScore" }]
         )
       );
     }
@@ -2450,7 +2729,7 @@ var tryRunGit = async (repositoryPath, args) => {
   }
 };
 var buildWorktreePath = (repoRoot, sha) => {
-  const tmpRoot = join2(repoRoot, SENTINEL_TMP_DIR, WORKTREE_DIR);
+  const tmpRoot = join5(repoRoot, SENTINEL_TMP_DIR, WORKTREE_DIR);
   mkdirSync(tmpRoot, { recursive: true });
   const baseName = `baseline-${sha.slice(0, 12)}-${process.pid}`;
   const candidate = resolve(tmpRoot, baseName);
@@ -2542,8 +2821,8 @@ var resolveAutoBaselineRef = async (input) => {
 
 // src/index.ts
 import { readFileSync as readFileSync2 } from "fs";
-import { readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname2, resolve as resolve6 } from "path";
+import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname2, resolve as resolve5 } from "path";
 import { fileURLToPath } from "url";
 
 // src/application/format-analyze-output.ts
@@ -2584,11 +2863,11 @@ var createSummaryShape = (summary) => ({
     fragileClusterCount: summary.risk.fragileClusters.length,
     dependencyAmplificationZoneCount: summary.risk.dependencyAmplificationZones.length
   },
-  quality: {
-    qualityScore: summary.quality.qualityScore,
-    normalizedScore: summary.quality.normalizedScore,
-    dimensions: summary.quality.dimensions,
-    topIssues: summary.quality.topIssues.slice(0, 5)
+  health: {
+    healthScore: summary.health.healthScore,
+    normalizedScore: summary.health.normalizedScore,
+    dimensions: summary.health.dimensions,
+    topIssues: summary.health.topIssues.slice(0, 5)
   }
 });
 var formatAnalyzeOutput = (summary, mode) => mode === "json" ? JSON.stringify(summary, null, 2) : JSON.stringify(createSummaryShape(summary), null, 2);
@@ -2935,13 +3214,13 @@ var parseLogLevel = (value) => {
 
 // src/application/check-for-updates.ts
 import { spawn } from "child_process";
-import { mkdir, readFile, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { dirname, join as join3 } from "path";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join6 } from "path";
 import { stderr, stdin } from "process";
 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 UPDATE_CACHE_PATH = join6(homedir2(), ".cache", "codesentinel", "update-check.json");
 var SEMVER_PATTERN = /^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<prerelease>[0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
 var ANSI = {
   reset: "\x1B[0m",
@@ -3065,7 +3344,7 @@ var parseNpmViewVersionOutput = (output) => {
 };
 var readCache = async () => {
   try {
-    const raw = await readFile(UPDATE_CACHE_PATH, "utf8");
+    const raw = await readFile2(UPDATE_CACHE_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && typeof parsed.lastCheckedAt === "string") {
       return { lastCheckedAt: parsed.lastCheckedAt };
@@ -3076,8 +3355,8 @@ var readCache = async () => {
   return null;
 };
 var writeCache = async (cache) => {
-  await mkdir(dirname(UPDATE_CACHE_PATH), { recursive: true });
-  await writeFile(UPDATE_CACHE_PATH, JSON.stringify(cache), "utf8");
+  await mkdir2(dirname(UPDATE_CACHE_PATH), { recursive: true });
+  await writeFile2(UPDATE_CACHE_PATH, JSON.stringify(cache), "utf8");
 };
 var shouldRunUpdateCheck = (input) => {
   if (!input.isInteractive) {
@@ -3161,7 +3440,7 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
     );
     return "skip";
   }
-  return await new Promise((resolve7) => {
+  return await new Promise((resolve6) => {
     emitKeypressEvents(stdin);
     let selectedIndex = 0;
     const previousRawMode = stdin.isRaw;
@@ -3186,7 +3465,7 @@ var promptInstall = async (packageName, latestVersion, currentVersion) => {
       } else {
         stderr.write("\n");
       }
-      resolve7(choice);
+      resolve6(choice);
     };
     const onKeypress = (_str, key) => {
       if (key.ctrl === true && key.name === "c") {
@@ -3265,7 +3544,7 @@ var checkForCliUpdates = async (input) => {
 };
 
 // src/application/run-analyze-command.ts
-import { resolve as resolve4 } from "path";
+import { resolve as resolve3 } from "path";
 
 // ../code-graph/dist/index.js
 import { extname, isAbsolute, relative, resolve as resolve2 } from "path";
@@ -4313,618 +4592,121 @@ 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;
+// ../health-engine/dist/index.js
+var clamp01 = (value) => {
+  if (!Number.isFinite(value)) {
+    return 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 (value <= 0) {
+    return 0;
   }
-  if (ts2.isCaseClause(node)) {
+  if (value >= 1) {
     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;
+  return value;
 };
-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)];
+var round45 = (value) => Number(value.toFixed(4));
+var average = (values) => {
+  if (values.length === 0) {
+    return 0;
   }
-  return complexities;
+  const total = values.reduce((sum, value) => sum + value, 0);
+  return total / values.length;
 };
-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 {
-    }
+var concentration = (rawValues) => {
+  const values = rawValues.filter((value) => value > 0);
+  const count = values.length;
+  if (count <= 1) {
+    return 0;
   }
-  if (complexities.length === 0) {
-    return void 0;
+  const total = values.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return 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
-  };
+  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 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;
+var DIMENSION_WEIGHTS = {
+  modularity: 0.35,
+  changeHygiene: 0.3,
+  testHealth: 0.2,
+  ownershipDistribution: 0.15
+};
+var HEALTH_TRACE_VERSION = "1";
+var toPercentage = (normalizedHealth) => round45(clamp01(normalizedHealth) * 100);
+var dampenForSmallSamples = (penalty, sampleSize, warmupSize, minimumWeight = 0.35) => {
+  const reliability = clamp01(sampleSize / Math.max(1, warmupSize));
+  const dampeningWeight = minimumWeight + (1 - minimumWeight) * reliability;
+  return clamp01(penalty) * dampeningWeight;
+};
+var topPercentShare = (values, fraction) => {
+  const positive = values.filter((value) => value > 0).sort((a, b) => b - a);
+  if (positive.length === 0) {
+    return 0;
   }
-  return 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();
+  const topCount = Math.max(1, Math.ceil(positive.length * clamp01(fraction)));
+  const total = positive.reduce((sum, value) => sum + value, 0);
+  const topTotal = positive.slice(0, topCount).reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return 0;
   }
-  return tokens;
+  return clamp01(topTotal / total);
 };
-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];
+var normalizedEntropy = (weights) => {
+  const positive = weights.filter((value) => value > 0);
+  if (positive.length <= 1) {
+    return 0;
   }
-  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);
+  const total = positive.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return 0;
   }
-  return [...selected.values()].sort((left, right) => left.start - right.start);
+  const entropy = positive.reduce((sum, value) => {
+    const p = value / total;
+    return sum - p * Math.log(p);
+  }, 0);
+  return clamp01(entropy / Math.log(positive.length));
 };
-var 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 toFactorTrace = (spec) => ({
+  factorId: spec.factorId,
+  contribution: round45(spec.penalty * spec.weight * 100),
+  penalty: round45(spec.penalty),
+  rawMetrics: spec.rawMetrics,
+  normalizedMetrics: spec.normalizedMetrics,
+  weight: round45(spec.weight),
+  evidence: spec.evidence
+});
+var createDimensionTrace = (dimension, health, factors) => ({
+  dimension,
+  normalizedScore: round45(clamp01(health)),
+  score: toPercentage(health),
+  factors: factors.map((factor) => toFactorTrace(factor))
+});
+var filePaths = (structural) => structural.files.map((file) => file.relativePath);
+var normalizePath2 = (value) => value.replaceAll("\\", "/").toLowerCase();
+var isTestPath = (path) => {
+  const normalized = normalizePath2(path);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/") || normalized.includes(".test.") || normalized.includes(".spec.");
 };
-var tokenBlockSignature = (tokens, start, blockLength) => {
-  if (start < 0 || start + blockLength > tokens.length) {
-    return void 0;
+var isSourcePath = (path) => {
+  if (path.endsWith(".d.ts")) {
+    return false;
   }
-  return tokens.slice(start, start + blockLength).join(" ");
+  return !isTestPath(path);
 };
-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 hasTestDirectory = (paths) => paths.some((path) => {
+  const normalized = normalizePath2(path);
+  return normalized.includes("/__tests__/") || normalized.includes("/tests/") || normalized.includes("/test/");
+});
+var moduleNameFromPath = (path) => {
+  const normalized = path.replaceAll("\\", "/");
+  const firstSegment = normalized.split("/")[0] ?? normalized;
+  return firstSegment.length === 0 ? normalized : firstSegment;
 };
 var pushIssue = (issues, issue) => {
   issues.push({
@@ -4932,484 +4714,704 @@ var pushIssue = (issues, issue) => {
     severity: issue.severity ?? "warn"
   });
 };
-var computeRepositoryQualitySummary = (input) => {
+var weightedPenalty = (factors) => clamp01(factors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0));
+var computeRepositoryHealthSummary = (input) => {
+  const ownershipPenaltyMultiplier = clamp01(input.config?.ownershipPenaltyMultiplier ?? 1);
   const issues = [];
   const sourceFileSet = new Set(input.structural.files.map((file) => file.relativePath));
-  const signals = input.signals;
-  const cycleCount = input.structural.metrics.cycleCount;
-  const cycleSizeAverage = input.structural.cycles.length === 0 ? 0 : average(input.structural.cycles.map((cycle) => cycle.nodes.length));
-  const cyclePenalty = clamp01(cycleCount / 6) * 0.7 + clamp01((cycleSizeAverage - 2) / 8) * 0.3;
+  const sourceFileCount = Math.max(1, input.structural.files.length);
+  const structuralEdges = input.structural.edges;
+  const cycleSets = input.structural.cycles.map((cycle) => new Set(cycle.nodes)).filter((set) => set.size >= 2);
+  const cycleNodeSet = /* @__PURE__ */ new Set();
+  for (const cycleSet of cycleSets) {
+    for (const node of cycleSet) {
+      cycleNodeSet.add(node);
+    }
+  }
+  const edgesInsideCycles = structuralEdges.filter(
+    (edge) => cycleSets.some((cycleSet) => cycleSet.has(edge.from) && cycleSet.has(edge.to))
+  ).length;
+  const cycleEdgeRatio = structuralEdges.length === 0 ? 0 : clamp01(edgesInsideCycles / structuralEdges.length);
+  const cycleNodeRatio = clamp01(cycleNodeSet.size / sourceFileCount);
+  const cycleDensityPenalty = clamp01(
+    clamp01(cycleEdgeRatio / 0.2) * 0.75 + clamp01(cycleNodeRatio / 0.35) * 0.25
+  );
   const fanInConcentration = concentration(input.structural.files.map((file) => file.fanIn));
   const fanOutConcentration = concentration(input.structural.files.map((file) => file.fanOut));
-  const centralityConcentration = average([fanInConcentration, fanOutConcentration]);
-  if (cycleCount > 0) {
-    pushIssue(issues, {
-      id: "quality.modularity.structural_cycles",
-      ruleId: "graph.structural_cycles",
-      dimension: "modularity",
-      target: input.structural.cycles[0]?.nodes.slice().sort((a, b) => a.localeCompare(b)).join(" -> ") ?? input.structural.targetPath,
-      message: `${cycleCount} structural cycle(s) increase coupling and refactor cost.`,
-      severity: cycleCount >= 3 ? "error" : "warn",
-      impact: round45(cyclePenalty * 0.55)
-    });
-  }
-  if (centralityConcentration >= 0.5) {
-    const hottest = [...input.structural.files].map((file) => ({
-      path: file.relativePath,
-      pressure: file.fanIn + file.fanOut
-    })).sort((a, b) => b.pressure - a.pressure || a.path.localeCompare(b.path))[0];
-    pushIssue(issues, {
-      id: "quality.modularity.centrality_concentration",
-      ruleId: "graph.centrality_concentration",
-      dimension: "modularity",
-      target: hottest?.path ?? input.structural.targetPath,
-      message: "Fan-in/fan-out pressure is concentrated in a small set of files.",
-      impact: round45(centralityConcentration * 0.45)
-    });
+  const fanConcentration = average([fanInConcentration, fanOutConcentration]);
+  const centralityPressure = input.structural.files.map((file) => file.fanIn + file.fanOut);
+  const centralityConcentration = concentration(centralityPressure);
+  let structuralHotspotOverlap = 0;
+  if (input.evolution.available) {
+    const evolutionSourceFiles = input.evolution.files.filter(
+      (file) => sourceFileSet.has(file.filePath)
+    );
+    const topStructuralCount = Math.max(1, Math.ceil(sourceFileCount * 0.1));
+    const topChangeCount = Math.max(1, Math.ceil(Math.max(1, evolutionSourceFiles.length) * 0.1));
+    const topStructural = new Set(
+      [...input.structural.files].map((file) => ({
+        filePath: file.relativePath,
+        pressure: file.fanIn + file.fanOut
+      })).sort((a, b) => b.pressure - a.pressure || a.filePath.localeCompare(b.filePath)).slice(0, topStructuralCount).map((item) => item.filePath)
+    );
+    const topChange = new Set(
+      [...evolutionSourceFiles].sort((a, b) => b.churnTotal - a.churnTotal || a.filePath.localeCompare(b.filePath)).slice(0, topChangeCount).map((item) => item.filePath)
+    );
+    const overlapCount = [...topStructural].filter((filePath) => topChange.has(filePath)).length;
+    structuralHotspotOverlap = topStructural.size === 0 || topChange.size === 0 ? 0 : clamp01(overlapCount / Math.min(topStructural.size, topChange.size));
   }
   const modularityFactors = [
     {
-      factorId: "quality.modularity.structural_cycles",
-      penalty: cyclePenalty,
+      factorId: "health.modularity.cycle_density",
+      penalty: cycleDensityPenalty,
       rawMetrics: {
-        cycleCount,
-        averageCycleSize: round45(cycleSizeAverage)
+        cycleCount: input.structural.metrics.cycleCount,
+        cycleEdgeRatio: round45(cycleEdgeRatio),
+        cycleNodeRatio: round45(cycleNodeRatio)
       },
       normalizedMetrics: {
-        cyclePenalty: round45(cyclePenalty)
+        cycleDensityPenalty: round45(cycleDensityPenalty)
       },
-      weight: 0.55,
-      evidence: [{ kind: "repository_metric", metric: "structural.cycles" }]
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "structural.cycleEdgeRatio" }]
     },
     {
-      factorId: "quality.modularity.centrality_concentration",
-      penalty: centralityConcentration,
+      factorId: "health.modularity.fan_concentration",
+      penalty: fanConcentration,
       rawMetrics: {
         fanInConcentration: round45(fanInConcentration),
         fanOutConcentration: round45(fanOutConcentration)
       },
       normalizedMetrics: {
-        centralityConcentration: round45(centralityConcentration)
+        fanConcentration: round45(fanConcentration)
       },
-      weight: 0.45,
+      weight: 0.25,
       evidence: [{ kind: "repository_metric", metric: "structural.files.fanIn/fanOut" }]
+    },
+    {
+      factorId: "health.modularity.centrality_concentration",
+      penalty: centralityConcentration,
+      rawMetrics: {
+        centralityConcentration: round45(centralityConcentration)
+      },
+      normalizedMetrics: {
+        centralityConcentration: round45(centralityConcentration)
+      },
+      weight: 0.2,
+      evidence: [{ kind: "repository_metric", metric: "structural.centralityPressure" }]
+    },
+    {
+      factorId: "health.modularity.hotspot_overlap",
+      penalty: structuralHotspotOverlap,
+      rawMetrics: {
+        structuralHotspotOverlap: round45(structuralHotspotOverlap)
+      },
+      normalizedMetrics: {
+        structuralHotspotOverlap: round45(structuralHotspotOverlap)
+      },
+      weight: 0.15,
+      evidence: [{ kind: "repository_metric", metric: "structural.evolution.hotspotOverlap" }]
     }
   ];
-  const modularityPenalty = clamp01(
-    modularityFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
+  const modularityPenalty = dampenForSmallSamples(
+    weightedPenalty(modularityFactors),
+    sourceFileCount,
+    8,
+    0.45
   );
-  let churnConcentration = 0;
-  let volatilityConcentration = 0;
-  let couplingDensity = 0;
-  let couplingIntensity = 0;
+  if (cycleDensityPenalty >= 0.35) {
+    const firstCycle = input.structural.cycles[0];
+    pushIssue(issues, {
+      id: "health.modularity.cycle_density",
+      ruleId: "graph.cycle_density",
+      signal: "structural.cycleEdgeRatio",
+      dimension: "modularity",
+      target: firstCycle?.nodes.slice().sort((a, b) => a.localeCompare(b)).join(" -> ") ?? input.structural.targetPath,
+      message: "Dependencies inside cycles consume a high share of graph edges, reducing refactor flexibility.",
+      severity: cycleDensityPenalty >= 0.7 ? "error" : "warn",
+      evidenceMetrics: {
+        cycleCount: input.structural.metrics.cycleCount,
+        cycleEdgeRatio: round45(cycleEdgeRatio),
+        cycleNodeRatio: round45(cycleNodeRatio)
+      },
+      impact: round45(modularityPenalty * 0.35)
+    });
+  }
+  if (centralityConcentration >= 0.5) {
+    const hottest = [...input.structural.files].map((file) => ({
+      path: file.relativePath,
+      pressure: file.fanIn + file.fanOut
+    })).sort((a, b) => b.pressure - a.pressure || a.path.localeCompare(b.path))[0];
+    pushIssue(issues, {
+      id: "health.modularity.centrality_concentration",
+      ruleId: "graph.centrality_concentration",
+      signal: "structural.centralityPressure",
+      dimension: "modularity",
+      target: hottest?.path ?? input.structural.targetPath,
+      message: "Dependency flow is concentrated in a narrow set of files, creating architectural bottlenecks.",
+      evidenceMetrics: {
+        fanConcentration: round45(fanConcentration),
+        centralityConcentration: round45(centralityConcentration)
+      },
+      impact: round45(modularityPenalty * 0.25)
+    });
+  }
+  if (structuralHotspotOverlap >= 0.5) {
+    pushIssue(issues, {
+      id: "health.modularity.hotspot_overlap",
+      ruleId: "graph.hotspot_overlap",
+      signal: "structural.evolution.hotspotOverlap",
+      dimension: "modularity",
+      target: input.structural.targetPath,
+      message: "Structural hubs overlap with top churn hotspots, making change pressure harder to isolate.",
+      evidenceMetrics: {
+        structuralHotspotOverlap: round45(structuralHotspotOverlap)
+      },
+      impact: round45(modularityPenalty * 0.2)
+    });
+  }
+  let churnConcentrationPenalty = 0;
+  let volatilityConcentrationPenalty = 0;
+  let coChangeClusterPenalty = 0;
+  let top10PercentFilesChurnShare = 0;
+  let top10PercentFilesVolatilityShare = 0;
+  let denseCoChangePairRatio = 0;
   if (input.evolution.available) {
     const evolutionSourceFiles = input.evolution.files.filter(
       (file) => sourceFileSet.has(file.filePath)
     );
-    churnConcentration = concentration(evolutionSourceFiles.map((file) => file.churnTotal));
-    volatilityConcentration = concentration(
-      evolutionSourceFiles.map((file) => file.recentVolatility)
+    const evolutionFileCount = evolutionSourceFiles.length;
+    top10PercentFilesChurnShare = topPercentShare(
+      evolutionSourceFiles.map((file) => file.churnTotal),
+      0.1
+    );
+    top10PercentFilesVolatilityShare = topPercentShare(
+      evolutionSourceFiles.map((file) => file.recentVolatility),
+      0.1
     );
-    const fileCount = Math.max(1, evolutionSourceFiles.length);
-    const maxPairs = fileCount * (fileCount - 1) / 2;
     const sourcePairs = input.evolution.coupling.pairs.filter(
       (pair) => sourceFileSet.has(pair.fileA) && sourceFileSet.has(pair.fileB)
     );
-    couplingDensity = maxPairs <= 0 ? 0 : clamp01(sourcePairs.length / maxPairs);
-    couplingIntensity = average(sourcePairs.map((pair) => pair.couplingScore));
-    if (churnConcentration >= 0.45) {
+    const maxPairs = evolutionFileCount * (evolutionFileCount - 1) / 2;
+    const densePairs = sourcePairs.filter((pair) => pair.couplingScore >= 0.55);
+    denseCoChangePairRatio = maxPairs <= 0 ? 0 : clamp01(densePairs.length / maxPairs);
+    const couplingScoreConcentration = concentration(sourcePairs.map((pair) => pair.couplingScore));
+    churnConcentrationPenalty = dampenForSmallSamples(
+      clamp01((top10PercentFilesChurnShare - 0.35) / 0.55),
+      evolutionFileCount,
+      12,
+      0.3
+    );
+    volatilityConcentrationPenalty = dampenForSmallSamples(
+      clamp01((top10PercentFilesVolatilityShare - 0.35) / 0.55),
+      evolutionFileCount,
+      12,
+      0.3
+    );
+    const coChangeRaw = average([
+      clamp01(denseCoChangePairRatio / 0.2),
+      couplingScoreConcentration
+    ]);
+    coChangeClusterPenalty = dampenForSmallSamples(coChangeRaw, sourcePairs.length, 20, 0.35);
+    if (churnConcentrationPenalty >= 0.35) {
       const mostChurn = [...evolutionSourceFiles].sort(
         (a, b) => b.churnTotal - a.churnTotal || a.filePath.localeCompare(b.filePath)
       )[0];
       pushIssue(issues, {
-        id: "quality.change_hygiene.churn_concentration",
-        ruleId: "git.churn_concentration",
+        id: "health.change_hygiene.churn_concentration",
+        ruleId: "git.churn_distribution",
+        signal: "evolution.top10PercentFilesChurnShare",
         dimension: "changeHygiene",
         target: mostChurn?.filePath ?? input.structural.targetPath,
-        message: "Churn is concentrated in a narrow part of the codebase.",
-        impact: round45(churnConcentration * 0.4)
+        message: "A small slice of files carries most churn, reducing change predictability.",
+        evidenceMetrics: {
+          top10PercentFilesChurnShare: round45(top10PercentFilesChurnShare)
+        },
+        impact: round45(churnConcentrationPenalty * 0.4)
       });
     }
-    if (volatilityConcentration >= 0.45) {
+    if (volatilityConcentrationPenalty >= 0.35) {
       const volatileFile = [...evolutionSourceFiles].sort(
         (a, b) => b.recentVolatility - a.recentVolatility || a.filePath.localeCompare(b.filePath)
       )[0];
       pushIssue(issues, {
-        id: "quality.change_hygiene.volatility_concentration",
-        ruleId: "git.volatility_concentration",
+        id: "health.change_hygiene.volatility_concentration",
+        ruleId: "git.volatility_distribution",
+        signal: "evolution.top10PercentFilesVolatilityShare",
         dimension: "changeHygiene",
         target: volatileFile?.filePath ?? input.structural.targetPath,
-        message: "Recent volatility is concentrated in files that change frequently.",
-        impact: round45(volatilityConcentration * 0.3)
+        message: "Recent volatility is concentrated, increasing review and release uncertainty.",
+        evidenceMetrics: {
+          top10PercentFilesVolatilityShare: round45(top10PercentFilesVolatilityShare)
+        },
+        impact: round45(volatilityConcentrationPenalty * 0.3)
       });
     }
-    if (couplingDensity >= 0.35 || couplingIntensity >= 0.45) {
+    if (coChangeClusterPenalty >= 0.35) {
       const strongestPair = [...sourcePairs].sort(
         (a, b) => b.couplingScore - a.couplingScore || `${a.fileA}|${a.fileB}`.localeCompare(`${b.fileA}|${b.fileB}`)
       )[0];
       pushIssue(issues, {
-        id: "quality.change_hygiene.coupling_density",
-        ruleId: "git.coupling_density",
+        id: "health.change_hygiene.dense_co_change_clusters",
+        ruleId: "git.co_change_clusters",
+        signal: "evolution.denseCoChangePairRatio",
         dimension: "changeHygiene",
         target: strongestPair === void 0 ? input.structural.targetPath : `${strongestPair.fileA}<->${strongestPair.fileB}`,
-        message: "Co-change relationships are dense, increasing coordination overhead.",
-        impact: round45(average([couplingDensity, couplingIntensity]) * 0.3)
+        message: "Dense co-change clusters suggest wider coordination scope per change.",
+        evidenceMetrics: {
+          denseCoChangePairRatio: round45(denseCoChangePairRatio)
+        },
+        impact: round45(coChangeClusterPenalty * 0.3)
       });
     }
   }
-  const todoFixmeCommentCount = Math.max(0, signals?.todoFixmeCommentCount ?? 0);
-  const todoFixmePenalty = logScaled(todoFixmeCommentCount, 80) * 0.08;
-  if (todoFixmeCommentCount > 0) {
-    pushIssue(issues, {
-      id: "quality.change_hygiene.todo_fixme_load",
-      ruleId: "comments.todo_fixme",
-      dimension: "changeHygiene",
-      target: input.structural.targetPath,
-      message: `Found ${todoFixmeCommentCount} TODO/FIXME comment marker(s); cleanup debt is accumulating.`,
-      impact: round45(todoFixmePenalty * 0.4)
-    });
-  }
   const changeHygieneFactors = [
     {
-      factorId: "quality.change_hygiene.churn_concentration",
-      penalty: churnConcentration,
+      factorId: "health.change_hygiene.churn_concentration",
+      penalty: churnConcentrationPenalty,
       rawMetrics: {
-        churnConcentration: round45(churnConcentration)
+        top10PercentFilesChurnShare: round45(top10PercentFilesChurnShare)
       },
       normalizedMetrics: {
-        churnConcentration: round45(churnConcentration)
-      },
-      weight: 0.35,
-      evidence: [{ kind: "repository_metric", metric: "evolution.churn" }]
-    },
-    {
-      factorId: "quality.change_hygiene.volatility_concentration",
-      penalty: volatilityConcentration,
-      rawMetrics: {
-        volatilityConcentration: round45(volatilityConcentration)
+        churnConcentrationPenalty: round45(churnConcentrationPenalty)
       },
-      normalizedMetrics: {
-        volatilityConcentration: round45(volatilityConcentration)
-      },
-      weight: 0.25,
-      evidence: [{ kind: "repository_metric", metric: "evolution.recentVolatility" }]
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "evolution.top10PercentFilesChurnShare" }]
     },
     {
-      factorId: "quality.change_hygiene.coupling_density",
-      penalty: average([couplingDensity, couplingIntensity]),
+      factorId: "health.change_hygiene.volatility_concentration",
+      penalty: volatilityConcentrationPenalty,
       rawMetrics: {
-        couplingDensity: round45(couplingDensity),
-        couplingIntensity: round45(couplingIntensity)
+        top10PercentFilesVolatilityShare: round45(top10PercentFilesVolatilityShare)
       },
       normalizedMetrics: {
-        couplingPressure: round45(average([couplingDensity, couplingIntensity]))
+        volatilityConcentrationPenalty: round45(volatilityConcentrationPenalty)
       },
       weight: 0.3,
-      evidence: [{ kind: "repository_metric", metric: "evolution.coupling" }]
+      evidence: [
+        {
+          kind: "repository_metric",
+          metric: "evolution.top10PercentFilesVolatilityShare"
+        }
+      ]
     },
     {
-      factorId: "quality.change_hygiene.todo_fixme_load",
-      penalty: todoFixmePenalty,
+      factorId: "health.change_hygiene.dense_co_change_clusters",
+      penalty: coChangeClusterPenalty,
       rawMetrics: {
-        todoFixmeCommentCount
+        denseCoChangePairRatio: round45(denseCoChangePairRatio)
       },
       normalizedMetrics: {
-        todoFixmePenalty: round45(todoFixmePenalty)
+        coChangeClusterPenalty: round45(coChangeClusterPenalty)
       },
-      weight: 0.1,
-      evidence: [{ kind: "repository_metric", metric: "comments.todo_fixme" }]
+      weight: 0.3,
+      evidence: [{ kind: "repository_metric", metric: "evolution.denseCoChangePairRatio" }]
     }
   ];
-  const changeHygienePenalty = input.evolution.available ? clamp01(changeHygieneFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)) : 0.2;
-  const eslint = signals?.eslint;
-  const tsc = signals?.typescript;
-  const sourceCount = Math.max(1, input.structural.files.length);
-  const eslintErrorRate = (eslint?.errorCount ?? 0) / sourceCount;
-  const eslintWarnRate = (eslint?.warningCount ?? 0) / sourceCount;
-  const tsErrorRate = (tsc?.errorCount ?? 0) / sourceCount;
-  const tsWarnRate = (tsc?.warningCount ?? 0) / sourceCount;
-  const staticAnalysisFactors = [
-    {
-      factorId: "quality.static_analysis.eslint_errors",
-      penalty: clamp01(eslintErrorRate / 0.5),
-      rawMetrics: {
-        eslintErrorCount: eslint?.errorCount ?? 0,
-        eslintFilesWithIssues: eslint?.filesWithIssues ?? 0
-      },
-      normalizedMetrics: {
-        eslintErrorRate: round45(eslintErrorRate)
-      },
-      weight: 0.5,
-      evidence: [{ kind: "repository_metric", metric: "eslint.errorCount" }]
-    },
+  const changeHygienePenalty = input.evolution.available ? weightedPenalty(changeHygieneFactors) : 0.12;
+  const paths = filePaths(input.structural);
+  const testFiles = paths.filter((path) => isTestPath(path)).length;
+  const sourceFiles = paths.filter((path) => isSourcePath(path)).length;
+  const testRatio = sourceFiles <= 0 ? 1 : testFiles / sourceFiles;
+  const testingDirectoryPresent = hasTestDirectory(paths);
+  const testPresencePenalty = sourceFiles <= 0 ? 0 : testFiles === 0 ? 1 : 0;
+  const testRatioPenalty = sourceFiles <= 0 ? 0 : 1 - clamp01(testRatio / 0.25);
+  const testingDirectoryPenalty = sourceFiles <= 0 ? 0 : testingDirectoryPresent ? 0 : 0.35;
+  const testHealthFactors = [
     {
-      factorId: "quality.static_analysis.eslint_warnings",
-      penalty: clamp01(eslintWarnRate / 1.2),
+      factorId: "health.test_health.test_file_presence",
+      penalty: testPresencePenalty,
       rawMetrics: {
-        eslintWarningCount: eslint?.warningCount ?? 0
+        sourceFiles,
+        testFiles
       },
       normalizedMetrics: {
-        eslintWarningRate: round45(eslintWarnRate)
+        testPresencePenalty: round45(testPresencePenalty)
       },
-      weight: 0.2,
-      evidence: [{ kind: "repository_metric", metric: "eslint.warningCount" }]
+      weight: 0.4,
+      evidence: [{ kind: "repository_metric", metric: "tests.filePresence" }]
     },
     {
-      factorId: "quality.static_analysis.typescript_errors",
-      penalty: clamp01(tsErrorRate / 0.35),
+      factorId: "health.test_health.test_to_source_ratio",
+      penalty: testRatioPenalty,
       rawMetrics: {
-        typeScriptErrorCount: tsc?.errorCount ?? 0,
-        typeScriptFilesWithDiagnostics: tsc?.filesWithDiagnostics ?? 0
+        testToSourceRatio: round45(testRatio)
       },
       normalizedMetrics: {
-        typeScriptErrorRate: round45(tsErrorRate)
+        testRatioPenalty: round45(testRatioPenalty)
       },
-      weight: 0.2,
-      evidence: [{ kind: "repository_metric", metric: "typescript.errorCount" }]
+      weight: 0.45,
+      evidence: [{ kind: "repository_metric", metric: "tests.testToSourceRatio" }]
     },
     {
-      factorId: "quality.static_analysis.typescript_warnings",
-      penalty: clamp01(tsWarnRate / 0.9),
+      factorId: "health.test_health.testing_directory_presence",
+      penalty: testingDirectoryPenalty,
       rawMetrics: {
-        typeScriptWarningCount: tsc?.warningCount ?? 0
+        testingDirectoryPresent: testingDirectoryPresent ? 1 : 0
       },
       normalizedMetrics: {
-        typeScriptWarningRate: round45(tsWarnRate)
+        testingDirectoryPenalty: round45(testingDirectoryPenalty)
       },
-      weight: 0.1,
-      evidence: [{ kind: "repository_metric", metric: "typescript.warningCount" }]
+      weight: 0.15,
+      evidence: [{ kind: "repository_metric", metric: "tests.directoryPresence" }]
     }
   ];
-  const staticAnalysisPenalty = clamp01(
-    staticAnalysisFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
+  const testHealthPenalty = dampenForSmallSamples(
+    weightedPenalty(testHealthFactors),
+    sourceFiles,
+    10,
+    0.3
   );
-  if ((eslint?.errorCount ?? 0) > 0) {
-    const topRule = [...eslint?.ruleCounts ?? []].sort(
-      (a, b) => b.count - a.count || a.ruleId.localeCompare(b.ruleId)
-    )[0];
+  if (sourceFiles > 0 && testFiles === 0) {
     pushIssue(issues, {
-      id: "quality.static_analysis.eslint_errors",
-      ruleId: topRule?.ruleId ?? "eslint",
-      dimension: "staticAnalysis",
+      id: "health.test_health.low_test_presence",
+      ruleId: "tests.file_presence",
+      signal: "tests.filePresence",
+      dimension: "testHealth",
       target: input.structural.targetPath,
-      message: topRule === void 0 ? `ESLint reported ${eslint?.errorCount ?? 0} error(s).` : `ESLint reported ${eslint?.errorCount ?? 0} error(s); top rule ${topRule.ruleId} (${topRule.count}).`,
-      severity: "error",
-      impact: round45(staticAnalysisPenalty * 0.5)
+      message: `No test files detected for ${sourceFiles} source file(s).`,
+      severity: sourceFiles >= 12 ? "error" : "warn",
+      evidenceMetrics: {
+        sourceFiles,
+        testFiles,
+        testToSourceRatio: round45(testRatio)
+      },
+      impact: round45(testHealthPenalty * 0.45)
     });
   }
-  if ((tsc?.errorCount ?? 0) > 0) {
+  if (sourceFiles > 0 && testRatio < 0.12) {
     pushIssue(issues, {
-      id: "quality.static_analysis.typescript_errors",
-      ruleId: "typescript",
-      dimension: "staticAnalysis",
+      id: "health.test_health.low_test_ratio",
+      ruleId: "tests.ratio",
+      signal: "tests.testToSourceRatio",
+      dimension: "testHealth",
       target: input.structural.targetPath,
-      message: `TypeScript reported ${tsc?.errorCount ?? 0} error diagnostic(s).`,
-      severity: "error",
-      impact: round45(staticAnalysisPenalty * 0.4)
+      message: "Test-to-source ratio is low; long-term change confidence may degrade.",
+      evidenceMetrics: {
+        sourceFiles,
+        testFiles,
+        testToSourceRatio: round45(testRatio)
+      },
+      impact: round45(testHealthPenalty * 0.35)
     });
   }
-  const complexity = signals?.complexity;
-  const avgComplexity = complexity?.averageCyclomatic ?? 0;
-  const maxComplexity = complexity?.maxCyclomatic ?? 0;
-  const highComplexityRatio = (complexity?.analyzedFileCount ?? 0) === 0 ? 0 : (complexity?.highComplexityFileCount ?? 0) / Math.max(1, complexity?.analyzedFileCount ?? 1);
-  const complexityFactors = [
-    {
-      factorId: "quality.complexity.average_cyclomatic",
-      penalty: clamp01(avgComplexity / 16),
-      rawMetrics: {
-        averageCyclomatic: round45(avgComplexity)
+  if (input.evolution.available) {
+    const evolutionSourceFiles = input.evolution.files.filter(
+      (file) => sourceFileSet.has(file.filePath)
+    );
+    const authorTotals = /* @__PURE__ */ new Map();
+    const moduleTotals = /* @__PURE__ */ new Map();
+    const moduleAuthors = /* @__PURE__ */ new Map();
+    let singleContributorFiles = 0;
+    let trackedFiles = 0;
+    for (const file of evolutionSourceFiles) {
+      if (file.commitCount <= 0 || file.authorDistribution.length === 0) {
+        continue;
+      }
+      trackedFiles += 1;
+      const dominantShare = clamp01(file.authorDistribution[0]?.share ?? 0);
+      if (file.authorDistribution.length === 1 || dominantShare >= 0.9) {
+        singleContributorFiles += 1;
+      }
+      for (const author of file.authorDistribution) {
+        const commits = Math.max(0, author.commits);
+        if (commits <= 0) {
+          continue;
+        }
+        const moduleName = moduleNameFromPath(file.filePath);
+        const moduleAuthorTotals = moduleAuthors.get(moduleName) ?? /* @__PURE__ */ new Map();
+        if (moduleAuthors.has(moduleName) === false) {
+          moduleAuthors.set(moduleName, moduleAuthorTotals);
+        }
+        authorTotals.set(author.authorId, (authorTotals.get(author.authorId) ?? 0) + commits);
+        moduleTotals.set(moduleName, (moduleTotals.get(moduleName) ?? 0) + commits);
+        moduleAuthorTotals.set(
+          author.authorId,
+          (moduleAuthorTotals.get(author.authorId) ?? 0) + commits
+        );
+      }
+    }
+    const totalAuthorCommits = [...authorTotals.values()].reduce((sum, value) => sum + value, 0);
+    const highestAuthorCommits = [...authorTotals.values()].sort((a, b) => b - a)[0] ?? 0;
+    const topAuthorCommitShare = totalAuthorCommits <= 0 ? 0 : clamp01(highestAuthorCommits / totalAuthorCommits);
+    const filesWithSingleContributorRatio = trackedFiles === 0 ? 0 : clamp01(singleContributorFiles / trackedFiles);
+    const authorEntropy = normalizedEntropy([...authorTotals.values()]);
+    let dominatedModules = 0;
+    let trackedModules = 0;
+    for (const [moduleName, moduleCommitTotal] of moduleTotals.entries()) {
+      if (moduleCommitTotal < 5) {
+        continue;
+      }
+      const perModuleAuthors = moduleAuthors.get(moduleName);
+      if (perModuleAuthors === void 0) {
+        continue;
+      }
+      trackedModules += 1;
+      const topAuthorModuleCommits = [...perModuleAuthors.values()].sort((a, b) => b - a)[0] ?? 0;
+      const moduleTopShare = moduleCommitTotal <= 0 ? 0 : topAuthorModuleCommits / moduleCommitTotal;
+      if (moduleTopShare >= 0.8) {
+        dominatedModules += 1;
+      }
+    }
+    const modulesDominatedBySingleContributorRatio = trackedModules === 0 ? 0 : clamp01(dominatedModules / trackedModules);
+    const ownershipSampleSize = trackedFiles;
+    const ownershipCommitVolume = totalAuthorCommits;
+    const ownershipReliability = average([
+      clamp01(ownershipSampleSize / 12),
+      clamp01(ownershipCommitVolume / 180)
+    ]);
+    const topAuthorPenalty = clamp01((topAuthorCommitShare - 0.55) / 0.4);
+    const singleContributorPenalty = clamp01((filesWithSingleContributorRatio - 0.35) / 0.6);
+    const entropyPenalty = clamp01((0.75 - authorEntropy) / 0.75);
+    const moduleDominancePenalty = clamp01((modulesDominatedBySingleContributorRatio - 0.4) / 0.6);
+    const ownershipBasePenalty = weightedPenalty([
+      {
+        factorId: "health.ownership.top_author_commit_share",
+        penalty: topAuthorPenalty,
+        rawMetrics: {
+          topAuthorCommitShare: round45(topAuthorCommitShare)
+        },
+        normalizedMetrics: {
+          topAuthorPenalty: round45(topAuthorPenalty)
+        },
+        weight: 0.35,
+        evidence: [{ kind: "repository_metric", metric: "ownership.topAuthorCommitShare" }]
       },
-      normalizedMetrics: {
-        averageCyclomaticPenalty: round45(clamp01(avgComplexity / 16))
+      {
+        factorId: "health.ownership.files_with_single_contributor_ratio",
+        penalty: singleContributorPenalty,
+        rawMetrics: {
+          filesWithSingleContributorRatio: round45(filesWithSingleContributorRatio)
+        },
+        normalizedMetrics: {
+          singleContributorPenalty: round45(singleContributorPenalty)
+        },
+        weight: 0.25,
+        evidence: [
+          {
+            kind: "repository_metric",
+            metric: "ownership.filesWithSingleContributorRatio"
+          }
+        ]
       },
-      weight: 0.4,
-      evidence: [{ kind: "repository_metric", metric: "complexity.averageCyclomatic" }]
-    },
-    {
-      factorId: "quality.complexity.max_cyclomatic",
-      penalty: clamp01(maxComplexity / 35),
-      rawMetrics: {
-        maxCyclomatic: round45(maxComplexity)
+      {
+        factorId: "health.ownership.author_entropy",
+        penalty: entropyPenalty,
+        rawMetrics: {
+          authorEntropy: round45(authorEntropy)
+        },
+        normalizedMetrics: {
+          authorEntropyPenalty: round45(entropyPenalty)
+        },
+        weight: 0.25,
+        evidence: [{ kind: "repository_metric", metric: "ownership.authorEntropy" }]
       },
-      normalizedMetrics: {
-        maxCyclomaticPenalty: round45(clamp01(maxComplexity / 35))
+      {
+        factorId: "health.ownership.module_single_author_dominance",
+        penalty: moduleDominancePenalty,
+        rawMetrics: {
+          modulesDominatedBySingleContributorRatio: round45(
+            modulesDominatedBySingleContributorRatio
+          )
+        },
+        normalizedMetrics: {
+          moduleDominancePenalty: round45(moduleDominancePenalty)
+        },
+        weight: 0.15,
+        evidence: [{ kind: "repository_metric", metric: "ownership.moduleDominance" }]
+      }
+    ]);
+    const ownershipDistributionPenalty2 = clamp01(
+      ownershipBasePenalty * (0.3 + 0.7 * ownershipReliability) * ownershipPenaltyMultiplier
+    );
+    const ownershipDistributionFactors2 = [
+      {
+        factorId: "health.ownership.top_author_commit_share",
+        penalty: topAuthorPenalty,
+        rawMetrics: {
+          topAuthorCommitShare: round45(topAuthorCommitShare)
+        },
+        normalizedMetrics: {
+          topAuthorPenalty: round45(topAuthorPenalty),
+          ownershipPenaltyMultiplier: round45(ownershipPenaltyMultiplier),
+          ownershipReliability: round45(ownershipReliability)
+        },
+        weight: 0.35,
+        evidence: [{ kind: "repository_metric", metric: "ownership.topAuthorCommitShare" }]
       },
-      weight: 0.35,
-      evidence: [{ kind: "repository_metric", metric: "complexity.maxCyclomatic" }]
-    },
-    {
-      factorId: "quality.complexity.high_complexity_ratio",
-      penalty: clamp01(highComplexityRatio / 0.35),
-      rawMetrics: {
-        highComplexityFileCount: complexity?.highComplexityFileCount ?? 0,
-        analyzedFileCount: complexity?.analyzedFileCount ?? 0
+      {
+        factorId: "health.ownership.files_with_single_contributor_ratio",
+        penalty: singleContributorPenalty,
+        rawMetrics: {
+          filesWithSingleContributorRatio: round45(filesWithSingleContributorRatio)
+        },
+        normalizedMetrics: {
+          singleContributorPenalty: round45(singleContributorPenalty)
+        },
+        weight: 0.25,
+        evidence: [
+          {
+            kind: "repository_metric",
+            metric: "ownership.filesWithSingleContributorRatio"
+          }
+        ]
       },
-      normalizedMetrics: {
-        highComplexityRatio: round45(highComplexityRatio)
+      {
+        factorId: "health.ownership.author_entropy",
+        penalty: entropyPenalty,
+        rawMetrics: {
+          authorEntropy: round45(authorEntropy)
+        },
+        normalizedMetrics: {
+          authorEntropyPenalty: round45(entropyPenalty)
+        },
+        weight: 0.25,
+        evidence: [{ kind: "repository_metric", metric: "ownership.authorEntropy" }]
       },
-      weight: 0.25,
-      evidence: [{ kind: "repository_metric", metric: "complexity.highComplexityFileCount" }]
+      {
+        factorId: "health.ownership.module_single_author_dominance",
+        penalty: moduleDominancePenalty,
+        rawMetrics: {
+          modulesDominatedBySingleContributorRatio: round45(
+            modulesDominatedBySingleContributorRatio
+          )
+        },
+        normalizedMetrics: {
+          moduleDominancePenalty: round45(moduleDominancePenalty)
+        },
+        weight: 0.15,
+        evidence: [{ kind: "repository_metric", metric: "ownership.moduleDominance" }]
+      }
+    ];
+    if (topAuthorPenalty >= 0.35) {
+      pushIssue(issues, {
+        id: "health.ownership.top_author_commit_share",
+        ruleId: "ownership.top_author_share",
+        signal: "ownership.topAuthorCommitShare",
+        dimension: "ownershipDistribution",
+        target: input.structural.targetPath,
+        message: "A single contributor owns most commits, concentrating repository knowledge.",
+        severity: topAuthorPenalty >= 0.75 ? "error" : "warn",
+        evidenceMetrics: {
+          topAuthorCommitShare: round45(topAuthorCommitShare),
+          authorEntropy: round45(authorEntropy)
+        },
+        impact: round45(ownershipDistributionPenalty2 * 0.4)
+      });
     }
-  ];
-  const complexityPenalty = clamp01(
-    complexityFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
-  );
-  if (maxComplexity >= 20 || highComplexityRatio >= 0.2) {
-    pushIssue(issues, {
-      id: "quality.complexity.high_cyclomatic",
-      ruleId: "complexity.cyclomatic",
-      dimension: "complexity",
-      target: input.structural.targetPath,
-      message: `Complexity is elevated (avg=${round45(avgComplexity)}, max=${round45(maxComplexity)}).`,
-      impact: round45(complexityPenalty * 0.6)
-    });
-  }
-  const duplication = signals?.duplication;
-  const duplicatedLineRatio = duplication?.duplicatedLineRatio ?? 0;
-  const duplicatedBlockCount = duplication?.duplicatedBlockCount ?? 0;
-  const duplicationFactors = [
-    {
-      factorId: "quality.duplication.line_ratio",
-      penalty: clamp01(duplicatedLineRatio / 0.25),
-      rawMetrics: {
-        duplicatedLineRatio: round45(duplicatedLineRatio)
-      },
-      normalizedMetrics: {
-        duplicatedLineRatioPenalty: round45(clamp01(duplicatedLineRatio / 0.25))
-      },
-      weight: 0.7,
-      evidence: [{ kind: "repository_metric", metric: "duplication.duplicatedLineRatio" }]
-    },
-    {
-      factorId: "quality.duplication.block_count",
-      penalty: logScaled(duplicatedBlockCount, 120),
-      rawMetrics: {
-        duplicatedBlockCount,
-        filesWithDuplication: duplication?.filesWithDuplication ?? 0
-      },
-      normalizedMetrics: {
-        duplicatedBlockPenalty: round45(logScaled(duplicatedBlockCount, 120))
-      },
-      weight: 0.3,
-      evidence: [{ kind: "repository_metric", metric: "duplication.duplicatedBlockCount" }]
+    if (singleContributorPenalty >= 0.35) {
+      pushIssue(issues, {
+        id: "health.ownership.single_author_dominance",
+        ruleId: "ownership.file_dominance",
+        signal: "ownership.filesWithSingleContributorRatio",
+        dimension: "ownershipDistribution",
+        target: input.structural.targetPath,
+        message: "Many files are dominated by a single contributor, reducing change resilience.",
+        evidenceMetrics: {
+          filesWithSingleContributorRatio: round45(filesWithSingleContributorRatio),
+          modulesDominatedBySingleContributorRatio: round45(
+            modulesDominatedBySingleContributorRatio
+          )
+        },
+        impact: round45(ownershipDistributionPenalty2 * 0.35)
+      });
     }
-  ];
-  const duplicationPenalty = clamp01(
-    duplicationFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
-  );
-  if (duplicatedLineRatio >= 0.08) {
-    pushIssue(issues, {
-      id: "quality.duplication.high_duplication",
-      ruleId: "duplication.line_ratio",
-      dimension: "duplication",
-      target: input.structural.targetPath,
-      message: `Duplication ratio is high (${toPercentage(duplicatedLineRatio)}%).`,
-      impact: round45(duplicationPenalty * 0.6)
-    });
-  }
-  const paths = filePaths(input.structural);
-  const testFiles = paths.filter((path) => isTestPath2(path)).length;
-  const sourceFiles = paths.filter((path) => isSourcePath(path)).length;
-  const testRatio = sourceFiles <= 0 ? 1 : testFiles / sourceFiles;
-  const testPresencePenalty = sourceFiles <= 0 ? 0 : 1 - clamp01(testRatio / 0.35);
-  const coverageSignals = signals?.coverage;
-  const coverageValues = [
-    coverageSignals?.lineCoverage,
-    coverageSignals?.branchCoverage,
-    coverageSignals?.functionCoverage,
-    coverageSignals?.statementCoverage
-  ].filter((value) => value !== null && value !== void 0);
-  const coverageRatio = coverageValues.length === 0 ? null : average(coverageValues);
-  const coveragePenalty = coverageRatio === null ? 0.2 : 1 - clamp01(coverageRatio / 0.8);
-  const testHealthFactors = [
-    {
-      factorId: "quality.test_health.test_presence",
-      penalty: testPresencePenalty,
-      rawMetrics: {
-        sourceFiles,
-        testFiles,
-        testRatio: round45(testRatio)
-      },
-      normalizedMetrics: {
-        testPresencePenalty: round45(testPresencePenalty)
+    if (entropyPenalty >= 0.35) {
+      pushIssue(issues, {
+        id: "health.ownership.low_author_entropy",
+        ruleId: "ownership.author_entropy",
+        signal: "ownership.authorEntropy",
+        dimension: "ownershipDistribution",
+        target: input.structural.targetPath,
+        message: "Contributor distribution is narrow across the repository.",
+        evidenceMetrics: {
+          authorEntropy: round45(authorEntropy),
+          topAuthorCommitShare: round45(topAuthorCommitShare)
+        },
+        impact: round45(ownershipDistributionPenalty2 * 0.25)
+      });
+    }
+    const modularityHealth2 = clamp01(1 - modularityPenalty);
+    const changeHygieneHealth2 = clamp01(1 - changeHygienePenalty);
+    const testHealthScore2 = clamp01(1 - testHealthPenalty);
+    const ownershipDistributionHealth2 = clamp01(1 - ownershipDistributionPenalty2);
+    const normalizedScore2 = clamp01(
+      modularityHealth2 * DIMENSION_WEIGHTS.modularity + changeHygieneHealth2 * DIMENSION_WEIGHTS.changeHygiene + testHealthScore2 * DIMENSION_WEIGHTS.testHealth + ownershipDistributionHealth2 * DIMENSION_WEIGHTS.ownershipDistribution
+    );
+    const topIssues2 = [...issues].sort(
+      (a, b) => b.impact - a.impact || a.id.localeCompare(b.id) || a.target.localeCompare(b.target)
+    ).slice(0, 12).map(({ impact: _impact, ...issue }) => issue);
+    return {
+      healthScore: toPercentage(normalizedScore2),
+      normalizedScore: round45(normalizedScore2),
+      dimensions: {
+        modularity: toPercentage(modularityHealth2),
+        changeHygiene: toPercentage(changeHygieneHealth2),
+        testHealth: toPercentage(testHealthScore2),
+        ownershipDistribution: toPercentage(ownershipDistributionHealth2)
       },
-      weight: 0.55,
-      evidence: [{ kind: "repository_metric", metric: "tests.file_ratio" }]
-    },
+      topIssues: topIssues2,
+      trace: {
+        schemaVersion: HEALTH_TRACE_VERSION,
+        dimensions: [
+          createDimensionTrace("modularity", modularityHealth2, modularityFactors),
+          createDimensionTrace("changeHygiene", changeHygieneHealth2, changeHygieneFactors),
+          createDimensionTrace("testHealth", testHealthScore2, testHealthFactors),
+          createDimensionTrace(
+            "ownershipDistribution",
+            ownershipDistributionHealth2,
+            ownershipDistributionFactors2
+          )
+        ]
+      }
+    };
+  }
+  const ownershipDistributionPenalty = clamp01(0.12 * ownershipPenaltyMultiplier);
+  const ownershipDistributionFactors = [
     {
-      factorId: "quality.test_health.coverage",
-      penalty: coveragePenalty,
+      factorId: "health.ownership.missing_git_history",
+      penalty: ownershipDistributionPenalty,
       rawMetrics: {
-        lineCoverage: coverageSignals?.lineCoverage ?? null,
-        branchCoverage: coverageSignals?.branchCoverage ?? null,
-        functionCoverage: coverageSignals?.functionCoverage ?? null,
-        statementCoverage: coverageSignals?.statementCoverage ?? null
+        gitHistoryAvailable: 0
       },
       normalizedMetrics: {
-        coverageRatio: coverageRatio === null ? null : round45(coverageRatio),
-        coveragePenalty: round45(coveragePenalty)
+        ownershipDistributionPenalty: round45(ownershipDistributionPenalty)
       },
-      weight: 0.45,
-      evidence: [{ kind: "repository_metric", metric: "coverage.summary" }]
+      weight: 1,
+      evidence: [{ kind: "repository_metric", metric: "evolution.available" }]
     }
   ];
-  const testHealthPenalty = clamp01(
-    testHealthFactors.reduce((sum, factor) => sum + factor.penalty * factor.weight, 0)
-  );
-  if (sourceFiles > 0 && testRatio < 0.2) {
-    pushIssue(issues, {
-      id: "quality.test_health.low_test_presence",
-      ruleId: "tests.file_ratio",
-      dimension: "testHealth",
-      target: input.structural.targetPath,
-      message: `Detected ${testFiles} test file(s) for ${sourceFiles} source file(s).`,
-      severity: testRatio === 0 ? "error" : "warn",
-      impact: round45(testHealthPenalty * 0.4)
-    });
-  }
-  if (coverageRatio !== null && coverageRatio < 0.6) {
-    pushIssue(issues, {
-      id: "quality.test_health.low_coverage",
-      ruleId: "coverage.threshold",
-      dimension: "testHealth",
-      target: input.structural.targetPath,
-      message: `Coverage is below threshold (${toPercentage(coverageRatio)}%).`,
-      impact: round45(testHealthPenalty * 0.35)
-    });
-  }
-  const modularityQuality = clamp01(1 - modularityPenalty);
-  const changeHygieneQuality = clamp01(1 - changeHygienePenalty);
-  const staticAnalysisQuality = clamp01(1 - staticAnalysisPenalty);
-  const complexityQuality = clamp01(1 - complexityPenalty);
-  const duplicationQuality = clamp01(1 - duplicationPenalty);
-  const testHealthQuality = clamp01(1 - testHealthPenalty);
+  const modularityHealth = clamp01(1 - modularityPenalty);
+  const changeHygieneHealth = clamp01(1 - changeHygienePenalty);
+  const testHealthScore = clamp01(1 - testHealthPenalty);
+  const ownershipDistributionHealth = clamp01(1 - ownershipDistributionPenalty);
   const normalizedScore = clamp01(
-    modularityQuality * DIMENSION_WEIGHTS.modularity + changeHygieneQuality * DIMENSION_WEIGHTS.changeHygiene + staticAnalysisQuality * DIMENSION_WEIGHTS.staticAnalysis + complexityQuality * DIMENSION_WEIGHTS.complexity + duplicationQuality * DIMENSION_WEIGHTS.duplication + testHealthQuality * DIMENSION_WEIGHTS.testHealth
+    modularityHealth * DIMENSION_WEIGHTS.modularity + changeHygieneHealth * DIMENSION_WEIGHTS.changeHygiene + testHealthScore * DIMENSION_WEIGHTS.testHealth + ownershipDistributionHealth * DIMENSION_WEIGHTS.ownershipDistribution
   );
   const topIssues = [...issues].sort(
     (a, b) => b.impact - a.impact || a.id.localeCompare(b.id) || a.target.localeCompare(b.target)
   ).slice(0, 12).map(({ impact: _impact, ...issue }) => issue);
   return {
-    qualityScore: toPercentage(normalizedScore),
+    healthScore: toPercentage(normalizedScore),
     normalizedScore: round45(normalizedScore),
     dimensions: {
-      modularity: toPercentage(modularityQuality),
-      changeHygiene: toPercentage(changeHygieneQuality),
-      staticAnalysis: toPercentage(staticAnalysisQuality),
-      complexity: toPercentage(complexityQuality),
-      duplication: toPercentage(duplicationQuality),
-      testHealth: toPercentage(testHealthQuality)
+      modularity: toPercentage(modularityHealth),
+      changeHygiene: toPercentage(changeHygieneHealth),
+      testHealth: toPercentage(testHealthScore),
+      ownershipDistribution: toPercentage(ownershipDistributionHealth)
     },
     topIssues,
     trace: {
-      schemaVersion: QUALITY_TRACE_VERSION,
+      schemaVersion: HEALTH_TRACE_VERSION,
       dimensions: [
-        createDimensionTrace("modularity", modularityQuality, modularityFactors),
-        createDimensionTrace("changeHygiene", changeHygieneQuality, changeHygieneFactors),
-        createDimensionTrace("staticAnalysis", staticAnalysisQuality, staticAnalysisFactors),
-        createDimensionTrace("complexity", complexityQuality, complexityFactors),
-        createDimensionTrace("duplication", duplicationQuality, duplicationFactors),
-        createDimensionTrace("testHealth", testHealthQuality, testHealthFactors)
+        createDimensionTrace("modularity", modularityHealth, modularityFactors),
+        createDimensionTrace("changeHygiene", changeHygieneHealth, changeHygieneFactors),
+        createDimensionTrace("testHealth", testHealthScore, testHealthFactors),
+        createDimensionTrace(
+          "ownershipDistribution",
+          ownershipDistributionHealth,
+          ownershipDistributionFactors
+        )
       ]
     }
   };
@@ -6653,8 +6655,8 @@ var evaluateRepositoryRisk = (input, options = {}) => {
 };
 
 // src/application/run-analyze-command.ts
-var resolveTargetPath = (inputPath, cwd) => resolve4(cwd, inputPath ?? ".");
-var riskProfileConfig = {
+var resolveTargetPath = (inputPath, cwd) => resolve3(cwd, inputPath ?? ".");
+var scoringProfileConfig = {
   default: void 0,
   personal: {
     evolutionFactorWeights: {
@@ -6666,8 +6668,17 @@ var riskProfileConfig = {
     }
   }
 };
-var resolveRiskConfigForProfile = (riskProfile) => {
-  return riskProfileConfig[riskProfile ?? "default"];
+var healthProfileConfig = {
+  default: void 0,
+  personal: {
+    ownershipPenaltyMultiplier: 0.25
+  }
+};
+var resolveRiskConfigForProfile = (scoringProfile) => {
+  return scoringProfileConfig[scoringProfile ?? "default"];
+};
+var resolveHealthConfigForProfile = (scoringProfile) => {
+  return healthProfileConfig[scoringProfile ?? "default"];
 };
 var createExternalProgressReporter = (logger) => {
   let lastLoggedProgress = 0;
@@ -6822,16 +6833,10 @@ var collectAnalysisInputs = async (inputPath, authorIdentityMode, options = {},
   } else {
     logger.warn(`external analysis unavailable: ${external.reason}`);
   }
-  logger.info("collecting quality signals");
-  const qualitySignals = await collectQualitySignals(targetPath, structural, logger);
-  logger.debug(
-    `quality signals: todoFixmeCommentCount=${qualitySignals.todoFixmeCommentCount ?? 0}, eslintErrors=${qualitySignals.eslint?.errorCount ?? 0}, tscErrors=${qualitySignals.typescript?.errorCount ?? 0}`
-  );
   return {
     structural,
     evolution,
-    external,
-    qualitySignals
+    external
   };
 };
 var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logger = createSilentLogger()) => {
@@ -6842,32 +6847,33 @@ var runAnalyzeCommand = async (inputPath, authorIdentityMode, options = {}, logg
     logger
   );
   logger.info("computing risk summary");
-  const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
+  const riskConfig = resolveRiskConfigForProfile(options.scoringProfile);
+  const healthConfig = resolveHealthConfigForProfile(options.scoringProfile);
   const risk = computeRepositoryRiskSummary({
     structural: analysisInputs.structural,
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     ...riskConfig === void 0 ? {} : { config: riskConfig }
   });
-  const quality = computeRepositoryQualitySummary({
+  const health = computeRepositoryHealthSummary({
     structural: analysisInputs.structural,
     evolution: analysisInputs.evolution,
-    signals: analysisInputs.qualitySignals
+    ...healthConfig === void 0 ? {} : { config: healthConfig }
   });
   logger.info(
-    `analysis completed (riskScore=${risk.riskScore}, qualityScore=${quality.qualityScore})`
+    `analysis completed (riskScore=${risk.riskScore}, healthScore=${health.healthScore})`
   );
   return {
     structural: analysisInputs.structural,
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     risk,
-    quality
+    health
   };
 };
 
 // src/application/run-check-command.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 
 // src/application/build-analysis-snapshot.ts
 var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logger) => {
@@ -6879,7 +6885,8 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
     },
     logger
   );
-  const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
+  const riskConfig = resolveRiskConfigForProfile(options.scoringProfile);
+  const healthConfig = resolveHealthConfigForProfile(options.scoringProfile);
   const evaluation = evaluateRepositoryRisk(
     {
       structural: analysisInputs.structural,
@@ -6894,10 +6901,10 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     risk: evaluation.summary,
-    quality: computeRepositoryQualitySummary({
+    health: computeRepositoryHealthSummary({
       structural: analysisInputs.structural,
       evolution: analysisInputs.evolution,
-      signals: analysisInputs.qualitySignals
+      ...healthConfig === void 0 ? {} : { config: healthConfig }
     })
   };
   return createSnapshot({
@@ -6906,7 +6913,7 @@ var buildAnalysisSnapshot = async (inputPath, authorIdentityMode, options, logge
     analysisConfig: {
       authorIdentityMode,
       includeTrace: options.includeTrace,
-      riskProfile: options.riskProfile ?? "default",
+      scoringProfile: options.scoringProfile ?? "default",
       recentWindowDays: analysisInputs.evolution.available ? analysisInputs.evolution.metrics.recentWindowDays : options.recentWindowDays ?? null
     }
   });
@@ -6941,7 +6948,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
     authorIdentityMode,
     {
       includeTrace: options.includeTrace,
-      ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+      ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
       ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
     },
     logger
@@ -6976,7 +6983,7 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
     options.outputFormat
   );
   if (options.outputPath !== void 0) {
-    await writeFile2(options.outputPath, rendered, "utf8");
+    await writeFile3(options.outputPath, rendered, "utf8");
     logger.info(`check output written: ${options.outputPath}`);
   }
   return {
@@ -6989,8 +6996,8 @@ var runCheckCommand = async (inputPath, authorIdentityMode, options, logger = cr
 };
 
 // src/application/run-ci-command.ts
-import { readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import { relative as relative3, resolve as resolve5 } from "path";
+import { readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
+import { relative as relative2, resolve as resolve4 } from "path";
 var isPathOutsideBase = (value) => {
   return value === ".." || value.startsWith("../") || value.startsWith("..\\");
 };
@@ -7003,20 +7010,20 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
   if (options.baselineSha !== void 0 && options.baselineRef !== "auto") {
     throw new GovernanceConfigurationError("baseline-sha requires --baseline-ref auto");
   }
-  const resolvedTargetPath = resolve5(inputPath ?? process.cwd());
+  const resolvedTargetPath = resolve4(inputPath ?? process.cwd());
   logger.info("building current snapshot");
   const current = await buildAnalysisSnapshot(
     inputPath,
     authorIdentityMode,
     {
       includeTrace: options.includeTrace,
-      ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+      ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
       ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
     },
     logger
   );
   if (options.snapshotPath !== void 0) {
-    await writeFile3(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
+    await writeFile4(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
     logger.info(`snapshot written: ${options.snapshotPath}`);
   }
   let baseline;
@@ -7057,19 +7064,19 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
         repositoryPath: resolvedTargetPath,
         baselineRef,
         analyzeWorktree: async (worktreePath, repositoryRoot) => {
-          const relativeTargetPath = relative3(repositoryRoot, resolvedTargetPath);
+          const relativeTargetPath = relative2(repositoryRoot, resolvedTargetPath);
           if (isPathOutsideBase(relativeTargetPath)) {
             throw new GovernanceConfigurationError(
               `target path is outside git repository root: ${resolvedTargetPath}`
             );
           }
-          const baselineTargetPath = relativeTargetPath.length === 0 || relativeTargetPath === "." ? worktreePath : resolve5(worktreePath, relativeTargetPath);
+          const baselineTargetPath = relativeTargetPath.length === 0 || relativeTargetPath === "." ? worktreePath : resolve4(worktreePath, relativeTargetPath);
           return buildAnalysisSnapshot(
             baselineTargetPath,
             authorIdentityMode,
             {
               includeTrace: options.includeTrace,
-              ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+              ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
               ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
             },
             logger
@@ -7111,7 +7118,7 @@ var runCiCommand = async (inputPath, authorIdentityMode, options, logger = creat
 
 ${ciMarkdown}`;
   if (options.reportPath !== void 0) {
-    await writeFile3(options.reportPath, markdownSummary, "utf8");
+    await writeFile4(options.reportPath, markdownSummary, "utf8");
     logger.info(`report written: ${options.reportPath}`);
   }
   const machineReadable = {
@@ -7123,7 +7130,7 @@ ${ciMarkdown}`;
     exitCode: gateResult.exitCode
   };
   if (options.jsonOutputPath !== void 0) {
-    await writeFile3(options.jsonOutputPath, JSON.stringify(machineReadable, null, 2), "utf8");
+    await writeFile4(options.jsonOutputPath, JSON.stringify(machineReadable, null, 2), "utf8");
     logger.info(`ci machine output written: ${options.jsonOutputPath}`);
   }
   return {
@@ -7137,7 +7144,7 @@ ${ciMarkdown}`;
 };
 
 // src/application/run-report-command.ts
-import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
 var runReportCommand = async (inputPath, authorIdentityMode, options, logger = createSilentLogger()) => {
   logger.info("building analysis snapshot");
   const current = await buildAnalysisSnapshot(
@@ -7145,13 +7152,13 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
     authorIdentityMode,
     {
       includeTrace: options.includeTrace,
-      ...options.riskProfile === void 0 ? {} : { riskProfile: options.riskProfile },
+      ...options.scoringProfile === void 0 ? {} : { scoringProfile: options.scoringProfile },
       ...options.recentWindowDays === void 0 ? {} : { recentWindowDays: options.recentWindowDays }
     },
     logger
   );
   if (options.snapshotPath !== void 0) {
-    await writeFile4(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
+    await writeFile5(options.snapshotPath, JSON.stringify(current, null, 2), "utf8");
     logger.info(`snapshot written: ${options.snapshotPath}`);
   }
   let report;
@@ -7166,7 +7173,7 @@ var runReportCommand = async (inputPath, authorIdentityMode, options, logger = c
   }
   const rendered = formatReport(report, options.format);
   if (options.outputPath !== void 0) {
-    await writeFile4(options.outputPath, rendered, "utf8");
+    await writeFile5(options.outputPath, rendered, "utf8");
     logger.info(`report written: ${options.outputPath}`);
   }
   return { report, rendered };
@@ -7202,7 +7209,8 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
     logger
   );
   logger.info("computing explainable risk summary");
-  const riskConfig = resolveRiskConfigForProfile(options.riskProfile);
+  const riskConfig = resolveRiskConfigForProfile(options.scoringProfile);
+  const healthConfig = resolveHealthConfigForProfile(options.scoringProfile);
   const evaluation = evaluateRepositoryRisk(
     {
       structural: analysisInputs.structural,
@@ -7220,14 +7228,14 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
     evolution: analysisInputs.evolution,
     external: analysisInputs.external,
     risk: evaluation.summary,
-    quality: computeRepositoryQualitySummary({
+    health: computeRepositoryHealthSummary({
       structural: analysisInputs.structural,
       evolution: analysisInputs.evolution,
-      signals: analysisInputs.qualitySignals
+      ...healthConfig === void 0 ? {} : { config: healthConfig }
     })
   };
   logger.info(
-    `explanation completed (riskScore=${summary.risk.riskScore}, qualityScore=${summary.quality.qualityScore})`
+    `explanation completed (riskScore=${summary.risk.riskScore}, healthScore=${summary.health.healthScore})`
   );
   return {
     summary,
@@ -7238,7 +7246,7 @@ var runExplainCommand = async (inputPath, authorIdentityMode, options, logger =
 
 // src/index.ts
 var program = new Command();
-var packageJsonPath = resolve6(dirname2(fileURLToPath(import.meta.url)), "../package.json");
+var packageJsonPath = resolve5(dirname2(fileURLToPath(import.meta.url)), "../package.json");
 var { version } = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
 var parseRecentWindowDays = (value) => {
   const parsed = Number.parseInt(value, 10);
@@ -7284,7 +7292,7 @@ var renderReportHighlightsText = (report) => {
   lines.push("Repository Summary");
   lines.push(`  target: ${report.repository.targetPath}`);
   lines.push(`  riskScore: ${report.repository.riskScore}`);
-  lines.push(`  qualityScore: ${report.quality.qualityScore}`);
+  lines.push(`  healthScore: ${report.health.healthScore}`);
   lines.push(`  normalizedScore: ${report.repository.normalizedScore}`);
   lines.push(`  riskTier: ${report.repository.riskTier}`);
   lines.push("");
@@ -7300,7 +7308,7 @@ var renderReportHighlightsMarkdown = (report) => {
   lines.push("## Repository Summary");
   lines.push(`- target: \`${report.repository.targetPath}\``);
   lines.push(`- riskScore: \`${report.repository.riskScore}\``);
-  lines.push(`- qualityScore: \`${report.quality.qualityScore}\``);
+  lines.push(`- healthScore: \`${report.health.healthScore}\``);
   lines.push(`- normalizedScore: \`${report.repository.normalizedScore}\``);
   lines.push(`- riskTier: \`${report.repository.riskTier}\``);
   lines.push("");
@@ -7318,7 +7326,7 @@ var renderCompactText = (report, explainSummary) => {
   lines.push("Repository");
   lines.push(`  target: ${report.repository.targetPath}`);
   lines.push(`  riskScore: ${report.repository.riskScore}`);
-  lines.push(`  qualityScore: ${report.quality.qualityScore}`);
+  lines.push(`  healthScore: ${report.health.healthScore}`);
   lines.push(`  riskTier: ${report.repository.riskTier}`);
   lines.push(
     `  dimensions: structural=${report.repository.dimensionScores.structural ?? "n/a"}, evolution=${report.repository.dimensionScores.evolution ?? "n/a"}, external=${report.repository.dimensionScores.external ?? "n/a"}, interactions=${report.repository.dimensionScores.interactions ?? "n/a"}`
@@ -7344,7 +7352,7 @@ var renderCompactMarkdown = (report, explainSummary) => {
   lines.push("## Repository");
   lines.push(`- target: \`${report.repository.targetPath}\``);
   lines.push(`- riskScore: \`${report.repository.riskScore}\``);
-  lines.push(`- qualityScore: \`${report.quality.qualityScore}\``);
+  lines.push(`- healthScore: \`${report.health.healthScore}\``);
   lines.push(`- riskTier: \`${report.repository.riskTier}\``);
   lines.push(
     `- dimensions: structural=\`${report.repository.dimensionScores.structural ?? "n/a"}\`, evolution=\`${report.repository.dimensionScores.evolution ?? "n/a"}\`, external=\`${report.repository.dimensionScores.external ?? "n/a"}\`, interactions=\`${report.repository.dimensionScores.interactions ?? "n/a"}\``
@@ -7363,12 +7371,12 @@ var renderCompactMarkdown = (report, explainSummary) => {
   }
   return lines.join("\n");
 };
-var riskProfileOption = () => new Option(
-  "--risk-profile <profile>",
-  "risk profile: default (balanced) or personal (down-weights single-maintainer ownership penalties)"
+var scoringProfileOption = () => new Option(
+  "--scoring-profile <profile>",
+  "scoring profile: default (balanced) or personal (down-weights single-maintainer ownership penalties for risk and health ownership)"
 ).choices(["default", "personal"]).default("default");
 program.name("codesentinel").description("Structural and evolutionary risk analysis for TypeScript/JavaScript codebases").version(version);
-program.command("analyze").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("analyze").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -7391,7 +7399,7 @@ program.command("analyze").argument("[path]", "path to the project to analyze").
     const summary = await runAnalyzeCommand(
       path,
       options.authorIdentity,
-      { recentWindowDays: options.recentWindowDays, riskProfile: options.riskProfile },
+      { recentWindowDays: options.recentWindowDays, scoringProfile: options.scoringProfile },
       logger
     );
     const outputMode = options.json === true ? "json" : options.output;
@@ -7399,7 +7407,7 @@ program.command("analyze").argument("[path]", "path to the project to analyze").
 `);
   }
 );
-program.command("explain").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("explain").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -7425,7 +7433,7 @@ program.command("explain").argument("[path]", "path to the project to analyze").
       ...options.module === void 0 ? {} : { module: options.module },
       top: Number.isFinite(top) ? top : 5,
       recentWindowDays: options.recentWindowDays,
-      riskProfile: options.riskProfile,
+      scoringProfile: options.scoringProfile,
       format: options.format
     };
     const result = await runExplainCommand(path, options.authorIdentity, explainOptions, logger);
@@ -7463,7 +7471,7 @@ program.command("dependency-risk").argument("<dependency>", "dependency spec to
 `);
   }
 );
-program.command("report").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("report").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -7492,7 +7500,7 @@ program.command("report").argument("[path]", "path to the project to analyze").a
         ...options.compare === void 0 ? {} : { comparePath: options.compare },
         ...options.snapshot === void 0 ? {} : { snapshotPath: options.snapshot },
         includeTrace: options.trace,
-        riskProfile: options.riskProfile,
+        scoringProfile: options.scoringProfile,
         recentWindowDays: options.recentWindowDays
       },
       logger
@@ -7503,7 +7511,7 @@ program.command("report").argument("[path]", "path to the project to analyze").a
     }
   }
 );
-program.command("run").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("run").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -7535,7 +7543,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
         top: Number.isFinite(top) ? top : 5,
         format: options.format,
         recentWindowDays: options.recentWindowDays,
-        riskProfile: options.riskProfile
+        scoringProfile: options.scoringProfile
       },
       logger
     );
@@ -7544,7 +7552,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
       ...options.trace === true ? { trace: explain.trace } : {}
     });
     if (options.snapshot !== void 0) {
-      await writeFile5(options.snapshot, JSON.stringify(snapshot, null, 2), "utf8");
+      await writeFile6(options.snapshot, JSON.stringify(snapshot, null, 2), "utf8");
       logger.info(`snapshot written: ${options.snapshot}`);
     }
     const report = options.compare === void 0 ? createReport(snapshot) : createReport(
@@ -7593,7 +7601,7 @@ program.command("run").argument("[path]", "path to the project to analyze").addO
               },
               report: {
                 repository: report.repository,
-                quality: report.quality,
+                health: report.health,
                 hotspots: report.hotspots.slice(0, 5),
                 structural: report.structural,
                 external: report.external
@@ -7742,27 +7750,27 @@ var parseMainBranches = (options) => {
 };
 var buildGateConfigFromOptions = (options) => {
   const maxRiskDelta = parseGateNumber(options.maxRiskDelta, "--max-risk-delta");
-  const maxQualityDelta = parseGateNumber(options.maxQualityDelta, "--max-quality-delta");
+  const maxHealthDelta = parseGateNumber(options.maxHealthDelta, "--max-health-delta");
   const maxNewHotspots = parseGateNumber(options.maxNewHotspots, "--max-new-hotspots");
   const maxRiskScore = parseGateNumber(options.maxRiskScore, "--max-risk-score");
-  const minQualityScore = parseGateNumber(options.minQualityScore, "--min-quality-score");
+  const minHealthScore = parseGateNumber(options.minHealthScore, "--min-health-score");
   const newHotspotScoreThreshold = parseGateNumber(
     options.newHotspotScoreThreshold,
     "--new-hotspot-score-threshold"
   );
   return {
     ...maxRiskDelta === void 0 ? {} : { maxRiskDelta },
-    ...maxQualityDelta === void 0 ? {} : { maxQualityDelta },
+    ...maxHealthDelta === void 0 ? {} : { maxHealthDelta },
     ...options.noNewCycles === true ? { noNewCycles: true } : {},
     ...options.noNewHighRiskDeps === true ? { noNewHighRiskDeps: true } : {},
     ...maxNewHotspots === void 0 ? {} : { maxNewHotspots },
     ...maxRiskScore === void 0 ? {} : { maxRiskScore },
-    ...minQualityScore === void 0 ? {} : { minQualityScore },
+    ...minHealthScore === void 0 ? {} : { minHealthScore },
     ...newHotspotScoreThreshold === void 0 ? {} : { newHotspotScoreThreshold },
     failOn: options.failOn
   };
 };
-program.command("check").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("check").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -7773,9 +7781,9 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
     "log verbosity: silent, error, warn, info, debug (logs are written to stderr)"
   ).choices(["silent", "error", "warn", "info", "debug"]).default(parseLogLevel(process.env["CODESENTINEL_LOG_LEVEL"]))
 ).option("--compare <baseline>", "baseline snapshot path").option("--max-risk-delta <value>", "maximum allowed normalized risk score increase").option(
-  "--max-quality-delta <value>",
-  "maximum allowed normalized quality score regression versus baseline (requires --compare)"
-).option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-risk-score <score>", "absolute risk score limit (0..100)").option("--min-quality-score <score>", "minimum quality score threshold (0..100)").addOption(
+  "--max-health-delta <value>",
+  "maximum allowed normalized health score regression versus baseline (requires --compare)"
+).option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-risk-score <score>", "absolute risk score limit (0..100)").option("--min-health-score <score>", "minimum health score threshold (0..100)").addOption(
   new Option("--fail-on <level>", "failing severity threshold").choices(["error", "warn"]).default("error")
 ).addOption(
   new Option("--format <mode>", "output format: text, json, md").choices(["text", "json", "md"]).default("text")
@@ -7795,7 +7803,7 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
         {
           ...options.compare === void 0 ? {} : { baselinePath: options.compare },
           includeTrace: options.trace,
-          riskProfile: options.riskProfile,
+          scoringProfile: options.scoringProfile,
           recentWindowDays: options.recentWindowDays,
           gateConfig,
           outputFormat: options.format,
@@ -7819,7 +7827,7 @@ program.command("check").argument("[path]", "path to the project to analyze").ad
     }
   }
 );
-program.command("ci").argument("[path]", "path to the project to analyze").addOption(riskProfileOption()).addOption(
+program.command("ci").argument("[path]", "path to the project to analyze").addOption(scoringProfileOption()).addOption(
   new Option(
     "--author-identity <mode>",
     "author identity mode: likely_merge (heuristic) or strict_email (deterministic)"
@@ -7844,9 +7852,9 @@ program.command("ci").argument("[path]", "path to the project to analyze").addOp
   "--main-branches <names>",
   "comma-separated default branch candidates for auto baseline resolution (for example: main,master)"
 ).option("--snapshot <path>", "write current snapshot JSON to path").option("--report <path>", "write markdown CI summary report").option("--json-output <path>", "write machine-readable CI JSON output").option("--max-risk-delta <value>", "maximum allowed normalized risk score increase").option(
-  "--max-quality-delta <value>",
-  "maximum allowed normalized quality score regression versus baseline"
-).option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-risk-score <score>", "absolute risk score limit (0..100)").option("--min-quality-score <score>", "minimum quality score threshold (0..100)").addOption(
+  "--max-health-delta <value>",
+  "maximum allowed normalized health score regression versus baseline"
+).option("--no-new-cycles", "fail if new structural cycles are introduced").option("--no-new-high-risk-deps", "fail if new high-risk direct dependencies are introduced").option("--max-new-hotspots <count>", "maximum allowed number of new hotspots").option("--new-hotspot-score-threshold <score>", "minimum hotspot score to count as new hotspot").option("--max-risk-score <score>", "absolute risk score limit (0..100)").option("--min-health-score <score>", "minimum health score threshold (0..100)").addOption(
   new Option("--fail-on <level>", "failing severity threshold").choices(["error", "warn"]).default("error")
 ).option("--no-trace", "disable trace embedding in generated snapshot").addOption(
   new Option(
@@ -7871,7 +7879,7 @@ program.command("ci").argument("[path]", "path to the project to analyze").addOp
           ...options.report === void 0 ? {} : { reportPath: options.report },
           ...options.jsonOutput === void 0 ? {} : { jsonOutputPath: options.jsonOutput },
           includeTrace: options.trace,
-          riskProfile: options.riskProfile,
+          scoringProfile: options.scoringProfile,
           recentWindowDays: options.recentWindowDays,
           gateConfig
         },