@vibgrate/cli 2026.825.2 → 2026.829.1

package/dist/{chunk-5UG4UHKU.js → chunk-HUJZO4K5.js}

@@ -6,12 +6,12 @@ import chalk3 from 'chalk';
 import * as os3 from 'os';
 import * as semver26 from 'semver';
 import { minVersion, validRange, SemVer, gt } from 'semver';
-import { parse } from 'yaml';
+import { parse as parse$1 } from 'yaml';
 import { execFile, spawn } from 'child_process';
 import * as fs from 'fs/promises';
 import { readFile, mkdir, writeFile, mkdtemp, rm } from 'fs/promises';
 import { XMLParser } from 'fast-xml-parser';
-import { parse as parse$1 } from 'smol-toml';
+import { parse } from 'smol-toml';
 import * as crypto from 'crypto';
 import * as fs7 from 'fs';
 import { mkdirSync, writeFileSync } from 'fs';
@@ -105,7 +105,7 @@ async function loadNpmLockIndex(dir, io) {
   const lockPath = path31.join(dir, "package-lock.json");
   if (await io.exists(pnpmPath).catch(() => false)) {
     try {
-      const map = parsePnpmLock(parse(await io.readText(pnpmPath)));
+      const map = parsePnpmLock(parse$1(await io.readText(pnpmPath)));
       if (map.size) return { source: "pnpm", size: map.size, resolve: (name) => map.get(name) ?? null };
     } catch {
     }
@@ -2044,7 +2044,7 @@ async function scanOneDotnetProjectFile(csprojPath, rootDir, nugetCache, cache,
 function parseToml(text) {
   if (!text) return null;
   try {
-    const doc = parse$1(text);
+    const doc = parse(text);
     return doc && typeof doc === "object" ? doc : null;
   } catch {
     return null;
@@ -12533,6 +12533,7 @@ function cloneClassification(c) {
     signals: [...c.signals]
   };
   if (c.role) next.role = c.role;
+  if (c.source) next.source = c.source;
   return next;
 }
 function applyFolderInheritance(input) {
@@ -12622,7 +12623,8 @@ function applyFolderInheritance(input) {
         filePath: file,
         layer: folder.layer,
         confidence: folder.confidence,
-        signals: [folderInheritSignal(folder.layer)]
+        signals: [folderInheritSignal(folder.layer)],
+        source: "folder-inherit"
       });
     } else {
       stillUnclassified.push(file);
@@ -12707,24 +12709,156 @@ function mergeUnclassifiedFiles(groups) {
   return capUnclassifiedFiles([...files]);
 }
 
-// src/core-open/scanners/architecture/workspace-edges.ts
+// src/core-open/scanners/architecture/coverage.ts
+var UNCLASSIFIED_FOLDERS_CAP = 40;
+var UNCLASSIFIED_FOLDER_SAMPLE_CAP = 5;
+var COVERAGE_SOURCES = Object.freeze([
+  "path",
+  "suffix",
+  "pascal",
+  "folder-inherit",
+  "graph",
+  "ast",
+  "declared"
+]);
+function emptyBySource() {
+  const out = {};
+  for (const s of COVERAGE_SOURCES) out[s] = 0;
+  return out;
+}
+function coverageRatio(classified, unclassified) {
+  const total = classified + unclassified;
+  if (total <= 0) return 0;
+  return Math.round(classified / total * 1e4) / 1e4;
+}
 function normalizeRelPath2(p) {
+  return (p || ".").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/^\/+/, "");
+}
+function parentDirOf(filePath) {
+  const n = normalizeRelPath2(filePath);
+  const i = n.lastIndexOf("/");
+  return i < 0 ? "." : n.slice(0, i);
+}
+function compareRelPath2(a, b) {
+  return a.localeCompare(b);
+}
+function coverageSourceOf(c) {
+  if (c.source) return c.source;
+  const signals = c.signals ?? [];
+  if (signals.some((s) => s === "graph-neighborhood" || s === "graph-override")) return "graph";
+  if (signals.some((s) => s.startsWith("ast-role:"))) return "ast";
+  if (signals.some((s) => s.startsWith("folder-inherit:"))) return "folder-inherit";
+  return "path";
+}
+function buildCoverage(classifications, unclassified) {
+  const bySource = emptyBySource();
+  for (const c of classifications) bySource[coverageSourceOf(c)] += 1;
+  const classified = classifications.length;
+  return { classified, unclassified, ratio: coverageRatio(classified, unclassified), bySource };
+}
+function creditCoverage(result, source) {
+  const coverage = result.coverage;
+  if (!coverage) return;
+  coverage.bySource[source] += 1;
+  coverage.classified += 1;
+  if (coverage.unclassified > 0) coverage.unclassified -= 1;
+  coverage.ratio = coverageRatio(coverage.classified, coverage.unclassified);
+}
+function reattributeCoverage(result, from, to) {
+  const coverage = result.coverage;
+  if (!coverage || from === to) return;
+  if (coverage.bySource[from] > 0) coverage.bySource[from] -= 1;
+  coverage.bySource[to] += 1;
+}
+function buildUnclassifiedFolders(unclassifiedSource) {
+  if (unclassifiedSource.length === 0) return { folders: [], capped: false };
+  const byDir = /* @__PURE__ */ new Map();
+  for (const raw of unclassifiedSource) {
+    const file = normalizeRelPath2(raw);
+    const dir = parentDirOf(file);
+    const list = byDir.get(dir);
+    if (list) list.push(file);
+    else byDir.set(dir, [file]);
+  }
+  const all = [...byDir.entries()].map(([path37, files]) => ({
+    path: path37,
+    count: files.length,
+    sampleFiles: [...files].sort(compareRelPath2).slice(0, UNCLASSIFIED_FOLDER_SAMPLE_CAP)
+  })).sort((a, b) => b.count - a.count || compareRelPath2(a.path, b.path));
+  return {
+    folders: all.slice(0, UNCLASSIFIED_FOLDERS_CAP),
+    capped: all.length > UNCLASSIFIED_FOLDERS_CAP
+  };
+}
+function debitUnclassifiedFolder(result, filePath) {
+  const rows = result.unclassifiedFolders;
+  if (!rows || rows.length === 0) return;
+  const file = normalizeRelPath2(filePath);
+  const dir = parentDirOf(file);
+  const row = rows.find((r) => r.path === dir);
+  if (!row) return;
+  row.count -= 1;
+  row.sampleFiles = row.sampleFiles.filter((f) => normalizeRelPath2(f) !== file);
+  const remaining = rows.filter((r) => r.count > 0);
+  if (remaining.length === 0) {
+    delete result.unclassifiedFolders;
+    delete result.unclassifiedFoldersCapped;
+    return;
+  }
+  remaining.sort((a, b) => b.count - a.count || compareRelPath2(a.path, b.path));
+  result.unclassifiedFolders = remaining;
+}
+function mergeCoverage(parts) {
+  const present = parts.filter((p) => !!p);
+  if (present.length === 0) return void 0;
+  const bySource = emptyBySource();
+  let classified = 0;
+  let unclassified = 0;
+  for (const p of present) {
+    classified += p.classified;
+    unclassified += p.unclassified;
+    for (const s of COVERAGE_SOURCES) bySource[s] += p.bySource[s] ?? 0;
+  }
+  return { classified, unclassified, ratio: coverageRatio(classified, unclassified), bySource };
+}
+function mergeUnclassifiedFolders(parts) {
+  const byDir = /* @__PURE__ */ new Map();
+  for (const part of parts) {
+    for (const row of part ?? []) {
+      const existing = byDir.get(row.path);
+      if (!existing) {
+        byDir.set(row.path, { path: row.path, count: row.count, sampleFiles: [...row.sampleFiles] });
+        continue;
+      }
+      existing.count += row.count;
+      existing.sampleFiles = [.../* @__PURE__ */ new Set([...existing.sampleFiles, ...row.sampleFiles])].sort(compareRelPath2).slice(0, UNCLASSIFIED_FOLDER_SAMPLE_CAP);
+    }
+  }
+  const all = [...byDir.values()].sort((a, b) => b.count - a.count || compareRelPath2(a.path, b.path));
+  return {
+    folders: all.slice(0, UNCLASSIFIED_FOLDERS_CAP),
+    capped: all.length > UNCLASSIFIED_FOLDERS_CAP
+  };
+}
+
+// src/core-open/scanners/architecture/workspace-edges.ts
+function normalizeRelPath3(p) {
   return (p || ".").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "") || ".";
 }
 function parentDir2(projectPath) {
-  const n = normalizeRelPath2(projectPath);
+  const n = normalizeRelPath3(projectPath);
   if (n === ".") return ".";
   const i = n.lastIndexOf("/");
   return i < 0 ? "." : n.slice(0, i);
 }
 function isContractish(result, path37) {
   if (result.projectKind === "contract" || result.artifactKind === "contract") return true;
-  const n = normalizeRelPath2(path37);
+  const n = normalizeRelPath3(path37);
   return /(^|\/)(proto|contracts|api-specs?)(\/|$)/.test(n);
 }
 function isIacish(result, path37) {
   if (result.projectKind === "iac" || result.artifactKind === "infrastructure-definition") return true;
-  return /(^|\/)(infra|infrastructure|terraform|iac)(\/|$)/.test(normalizeRelPath2(path37));
+  return /(^|\/)(infra|infrastructure|terraform|iac)(\/|$)/.test(normalizeRelPath3(path37));
 }
 function isAppish(result) {
   const kind = result.projectKind;
@@ -12749,21 +12883,21 @@ function detectWorkspaceEdges(projects, results) {
       const to = projects[j];
       const toResult = results[j];
       const sameParent = parentDir2(to.path) === fromParent;
-      const contractAtRoot = isContractish(toResult, to.path) && /^(proto|contracts|api-specs?)(\/|$)/.test(normalizeRelPath2(to.path));
-      const iacAtRoot = isIacish(fromResult, from.path) && /^(infra|infrastructure|terraform|iac)(\/|$)/.test(normalizeRelPath2(from.path));
+      const contractAtRoot = isContractish(toResult, to.path) && /^(proto|contracts|api-specs?)(\/|$)/.test(normalizeRelPath3(to.path));
+      const iacAtRoot = isIacish(fromResult, from.path) && /^(infra|infrastructure|terraform|iac)(\/|$)/.test(normalizeRelPath3(from.path));
       if (isAppish(fromResult) && isContractish(toResult, to.path) && (sameParent || contractAtRoot)) {
         push({
           kind: "implements-contract",
-          fromProject: normalizeRelPath2(from.path),
-          toProject: normalizeRelPath2(to.path),
+          fromProject: normalizeRelPath3(from.path),
+          toProject: normalizeRelPath3(to.path),
           confidence: sameParent ? 0.72 : 0.64
         });
       }
       if (isIacish(fromResult, from.path) && isAppish(toResult) && (sameParent || iacAtRoot)) {
         push({
           kind: "provisions",
-          fromProject: normalizeRelPath2(from.path),
-          toProject: normalizeRelPath2(to.path),
+          fromProject: normalizeRelPath3(from.path),
+          toProject: normalizeRelPath3(to.path),
           confidence: sameParent ? 0.68 : 0.6
         });
       }
@@ -12774,7 +12908,7 @@ function detectWorkspaceEdges(projects, results) {
 function detectLocalContractEdges(projectPath, files, projectKind) {
   if (projectKind === "contract" || projectKind === "iac") return [];
   const edges = [];
-  const prefix = normalizeRelPath2(projectPath);
+  const prefix = normalizeRelPath3(projectPath);
   for (const f of files) {
     const base = f.replace(/\\/g, "/").split("/").pop() ?? f;
     const ext = (() => {
@@ -13129,9 +13263,9 @@ function isDomainRepositoryPort(baseName, loweredPath) {
   if (!/^I[A-Z]\w*(Repository|Repo)$/.test(baseName)) return false;
   return /\/(domain|interfaces)\//.test(loweredPath);
 }
-function considerRule(bestMatch, layer, confidence, signal) {
+function considerRule(bestMatch, layer, confidence, signal, source) {
   if (!bestMatch || confidence > bestMatch.confidence) {
-    return { layer, confidence, signal };
+    return { layer, confidence, signal, source };
   }
   return bestMatch;
 }
@@ -13148,7 +13282,7 @@ function classifyOne(filePath, archetype, opts) {
     if (rule.pattern.test(lowered)) {
       const boost = rule.archetypes ? 0.05 : 0;
       const adjustedConfidence = Math.min(rule.confidence + boost, 1);
-      bestMatch = considerRule(bestMatch, rule.layer, adjustedConfidence, rule.signal);
+      bestMatch = considerRule(bestMatch, rule.layer, adjustedConfidence, rule.signal, "path");
     }
   }
   for (const rule of opts?.extraPathRules ?? []) {
@@ -13156,19 +13290,19 @@ function classifyOne(filePath, archetype, opts) {
       continue;
     }
     if (rule.pattern.test(lowered)) {
-      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal);
+      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal, "path");
     }
   }
   const baseName = path31.basename(filePath, path31.extname(filePath));
   const cleanBase = baseName.replace(/\.(test|spec)$/, "");
   for (const rule of SUFFIX_RULES) {
     if (cleanBase.endsWith(rule.suffix)) {
-      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal);
+      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal, "suffix");
     }
   }
   for (const rule of opts?.extraSuffixRules ?? []) {
     if (cleanBase.endsWith(rule.suffix)) {
-      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal);
+      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal, "suffix");
     }
   }
   const fileExt = path31.extname(filePath).toLowerCase();
@@ -13176,28 +13310,33 @@ function classifyOne(filePath, archetype, opts) {
     if (spa && SPA_SKIP_PASCAL.has(rule.suffix)) continue;
     if (rule.extensions && !rule.extensions.includes(fileExt)) continue;
     if (cleanBase.endsWith(rule.suffix)) {
-      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal);
+      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal, "pascal");
     }
   }
   for (const rule of opts?.extraPascalSuffixRules ?? []) {
     if (spa && SPA_SKIP_PASCAL.has(rule.suffix)) continue;
     if (cleanBase.endsWith(rule.suffix)) {
-      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal);
+      bestMatch = considerRule(bestMatch, rule.layer, rule.confidence, rule.signal, "pascal");
     }
   }
   if (isDomainRepositoryPort(cleanBase, lowered)) {
-    const port = { layer: "domain", confidence: 0.93, signal: "domain repository port" };
+    const port = {
+      layer: "domain",
+      confidence: 0.93,
+      signal: "domain repository port",
+      source: "pascal"
+    };
     if (!bestMatch || port.confidence >= bestMatch.confidence || bestMatch.layer === "data-access") {
       bestMatch = port;
     }
   }
   if (bestMatch && (bestMatch.layer === "routing" || bestMatch.layer === "services") && /\/(model|entity|entities)\//.test(lowered) && /(Controller|Request|Response|Dto|DTO)$/.test(cleanBase)) {
-    bestMatch = { layer: "domain", confidence: 0.88, signal: "entity folder beats type suffix" };
+    bestMatch = { layer: "domain", confidence: 0.88, signal: "entity folder beats type suffix", source: "path" };
   }
   if (!bestMatch) {
     const ext = path31.extname(filePath).toLowerCase();
     if (UI_SOURCE_EXTENSIONS.has(ext)) {
-      bestMatch = { layer: "presentation", confidence: 0.62, signal: "ui source extension" };
+      bestMatch = { layer: "presentation", confidence: 0.62, signal: "ui source extension", source: "suffix" };
     }
   }
   return bestMatch;
@@ -13226,7 +13365,8 @@ function classifyFile(filePath, archetype, opts) {
       filePath,
       layer: "testing",
       confidence: 0.9,
-      signals: ["test project prefix"]
+      signals: ["test project prefix"],
+      source: "path"
     };
   }
   const local = classifyOne(filePath, archetype, opts);
@@ -13243,7 +13383,8 @@ function classifyFile(filePath, archetype, opts) {
     filePath,
     layer: best.layer,
     confidence: best.confidence,
-    signals: usedHint ? [best.signal, "project-path-hint"] : [best.signal]
+    signals: usedHint ? [best.signal, "project-path-hint"] : [best.signal],
+    source: best.source
   };
 }
 
@@ -13285,14 +13426,14 @@ var CLEAN_PROFILES = /* @__PURE__ */ new Set(["clean", "hexagonal", "onion"]);
 var GRAPH_OVERRIDE_SIGNAL = "graph-override";
 var GRAPH_NEIGHBORHOOD_SIGNAL = "graph-neighborhood";
 var GRAPH_CONFIRM_SIGNAL = "graph-confirm";
-function normalizeRelPath3(p) {
+function normalizeRelPath4(p) {
   return (p || ".").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "") || ".";
 }
-function compareRelPath2(a, b) {
-  return normalizeRelPath3(a).localeCompare(normalizeRelPath3(b));
+function compareRelPath3(a, b) {
+  return normalizeRelPath4(a).localeCompare(normalizeRelPath4(b));
 }
 function parentDir3(filePath) {
-  const n = normalizeRelPath3(filePath);
+  const n = normalizeRelPath4(filePath);
   if (n === ".") return ".";
   const i = n.lastIndexOf("/");
   return i <= 0 ? "." : n.slice(0, i);
@@ -13307,8 +13448,8 @@ function ancestorDirs2(filePath) {
   return dirs;
 }
 function pathOwnsFile(projectPath, file) {
-  const prefix = normalizeRelPath3(projectPath);
-  const f = normalizeRelPath3(file);
+  const prefix = normalizeRelPath4(projectPath);
+  const f = normalizeRelPath4(file);
   if (prefix === ".") return true;
   return f === prefix || f.startsWith(`${prefix}/`);
 }
@@ -13316,7 +13457,7 @@ function owningProjectPath(file, projectPaths) {
   let best = ".";
   let bestLen = -1;
   for (const raw of projectPaths) {
-    const p = normalizeRelPath3(raw);
+    const p = normalizeRelPath4(raw);
     if (!pathOwnsFile(p, file)) continue;
     const len = p === "." ? 0 : p.length;
     if (len > bestLen) {
@@ -13334,32 +13475,39 @@ function isLayerSkipped(result) {
 }
 function nearestFolder(filePath, folders) {
   for (const ancestor of ancestorDirs2(filePath)) {
-    const folder = folders.find((f) => normalizeRelPath3(f.path) === ancestor);
+    const folder = folders.find((f) => normalizeRelPath4(f.path) === ancestor);
     if (folder) return folder;
   }
   return void 0;
 }
 function fileInLayerSample(result, filePath) {
-  const n = normalizeRelPath3(filePath);
+  const n = normalizeRelPath4(filePath);
   for (const layer of result.layers) {
-    if (layer.files.some((f) => normalizeRelPath3(f) === n)) return layer.layer;
+    if (layer.files.some((f) => normalizeRelPath4(f) === n)) return layer.layer;
   }
   return void 0;
 }
+function decidingSource(result, filePath) {
+  const hit = (result.classified ?? []).find((c) => normalizeRelPath4(c.filePath) === filePath);
+  if (hit?.source) return hit.source;
+  const reclassified = classifyFile(filePath, result.archetype, { projectKind: result.projectKind });
+  return reclassified?.source ?? "path";
+}
 function buildFileState(filePath, result) {
-  const n = normalizeRelPath3(filePath);
+  const n = normalizeRelPath4(filePath);
   const sampleLayer = fileInLayerSample(result, n);
   const folder = nearestFolder(n, result.folders ?? []);
   if (sampleLayer) {
     const confidence = folder && folder.layer === sampleLayer ? folder.confidence : folder && folder.layer !== sampleLayer ? Math.max(DEFAULT_PATH_CONFIDENCE, 0.85) : DEFAULT_PATH_CONFIDENCE;
-    return { filePath: n, layer: sampleLayer, confidence, signals: [] };
+    return { filePath: n, layer: sampleLayer, confidence, signals: [], source: decidingSource(result, n) };
   }
   if (folder && folder.confidence >= FOLDER_INHERIT_MIN_CONFIDENCE) {
     return {
       filePath: n,
       layer: folder.layer,
       confidence: folder.confidence,
-      signals: [folderInheritSignal(folder.layer)]
+      signals: [folderInheritSignal(folder.layer)],
+      source: "folder-inherit"
     };
   }
   return { filePath: n, layer: void 0, confidence: 0, signals: [] };
@@ -13367,9 +13515,9 @@ function buildFileState(filePath, result) {
 function collectKnownFiles(result) {
   const files = /* @__PURE__ */ new Set();
   for (const layer of result.layers) {
-    for (const f of layer.files) files.add(normalizeRelPath3(f));
+    for (const f of layer.files) files.add(normalizeRelPath4(f));
   }
-  for (const f of result.unclassifiedFiles ?? []) files.add(normalizeRelPath3(f));
+  for (const f of result.unclassifiedFiles ?? []) files.add(normalizeRelPath4(f));
   return [...files];
 }
 function pushEdge(map, key, edge) {
@@ -13382,7 +13530,7 @@ function indexGraph(graph) {
   const fileNodes = /* @__PURE__ */ new Map();
   for (const node of graph.nodes) {
     if (!node.file) continue;
-    const file = normalizeRelPath3(node.file);
+    const file = normalizeRelPath4(node.file);
     nodeFile.set(node.id, file);
     const list = fileNodes.get(file);
     if (list) list.push(node.id);
@@ -13469,18 +13617,18 @@ function ensureLayer(result, layer) {
   return summary;
 }
 function removeFileFromLayer(summary, filePath) {
-  const n = normalizeRelPath3(filePath);
-  const next = summary.files.filter((f) => normalizeRelPath3(f) !== n);
+  const n = normalizeRelPath4(filePath);
+  const next = summary.files.filter((f) => normalizeRelPath4(f) !== n);
   if (next.length === summary.files.length) return;
   summary.files = next;
   if (summary.fileCount > 0) summary.fileCount -= 1;
 }
 function addFileToLayer(summary, filePath) {
-  const n = normalizeRelPath3(filePath);
-  if (summary.files.some((f) => normalizeRelPath3(f) === n)) return;
+  const n = normalizeRelPath4(filePath);
+  if (summary.files.some((f) => normalizeRelPath4(f) === n)) return;
   if (summary.files.length < LAYER_FILES_CAP) {
     summary.files.push(n);
-    summary.files.sort(compareRelPath2);
+    summary.files.sort(compareRelPath3);
   }
   summary.fileCount += 1;
 }
@@ -13556,13 +13704,16 @@ function selectBoundaryProfile(structure, result) {
   return void 0;
 }
 function sliceOf(filePath) {
-  const m = normalizeRelPath3(filePath).match(/(?:^|\/)(?:features|modules|slices)\/([^/]+)/i);
+  const m = normalizeRelPath4(filePath).match(/(?:^|\/)(?:features|modules|slices)\/([^/]+)/i);
   return m?.[1]?.toLowerCase();
 }
 function isSliceInternal(filePath) {
-  const base = normalizeRelPath3(filePath).split("/").pop() ?? "";
+  const base = normalizeRelPath4(filePath).split("/").pop() ?? "";
   return !/^(index|public|api|mod)\.[^./]+$/i.test(base);
 }
+function evaluateLayerBoundary(profile, from, to, fromFile, toFile, projectKind) {
+  return isIllegalEdge(profile, from, to, fromFile, toFile, projectKind);
+}
 function isIllegalEdge(profile, from, to, fromFile, toFile, projectKind) {
   if (profile === "vertical-slice") {
     const fromSlice = sliceOf(fromFile);
@@ -13637,14 +13788,14 @@ function fileInScope(filePath, projectPath) {
 }
 function applyConfirmation(result, graph, projectPath, index) {
   if (isLayerSkipped(result)) return { conflicts: [], states: /* @__PURE__ */ new Map() };
-  const unclassified = new Set((result.unclassifiedFiles ?? []).map(normalizeRelPath3));
+  const unclassified = new Set((result.unclassifiedFiles ?? []).map(normalizeRelPath4));
   const known = new Set(collectKnownFiles(result));
   for (const file of index.fileNodes.keys()) {
     if (fileInScope(file, projectPath)) known.add(file);
   }
   const states = /* @__PURE__ */ new Map();
   const stateOf = (file) => {
-    const n = normalizeRelPath3(file);
+    const n = normalizeRelPath4(file);
     const existing = states.get(n);
     if (existing) return existing;
     const built = buildFileState(n, result);
@@ -13653,7 +13804,7 @@ function applyConfirmation(result, graph, projectPath, index) {
   };
   for (const file of known) stateOf(file);
   const conflicts = [];
-  const scopedFiles = [...known].filter((f) => fileInScope(f, projectPath)).sort(compareRelPath2);
+  const scopedFiles = [...known].filter((f) => fileInScope(f, projectPath)).sort(compareRelPath3);
   for (const file of scopedFiles) {
     const state = stateOf(file);
     const votes = neighbourhoodVotes(file, index, stateOf);
@@ -13667,9 +13818,12 @@ function applyConfirmation(result, graph, projectPath, index) {
       state.signals = sortedSignals2([GRAPH_NEIGHBORHOOD_SIGNAL, ...extra]);
       const target = ensureLayer(result, majority.layer);
       addFileToLayer(target, file);
+      state.source = "graph";
       result.totalClassified += 1;
       unclassified.delete(file);
       if (result.unclassified > 0) result.unclassified -= 1;
+      creditCoverage(result, "graph");
+      debitUnclassifiedFolder(result, file);
       addFolderSignal(result, file, GRAPH_NEIGHBORHOOD_SIGNAL);
       continue;
     }
@@ -13688,6 +13842,8 @@ function applyConfirmation(result, graph, projectPath, index) {
       state.layer = majority.layer;
       state.confidence = GRAPH_ASSIGN_CONFIDENCE;
       state.signals = sortedSignals2([...state.signals, GRAPH_OVERRIDE_SIGNAL, ...extra]);
+      reattributeCoverage(result, state.source ?? "path", "graph");
+      state.source = "graph";
       addFileToLayer(ensureLayer(result, majority.layer), file);
       addFolderSignal(result, file, GRAPH_OVERRIDE_SIGNAL);
       continue;
@@ -13805,13 +13961,13 @@ function refineArchitectureResult(result, graph, opts = {}) {
 }
 function refineArchitectureWithGraph(artifact, graph) {
   const projects = artifact.projects.map((p) => ({
-    path: normalizeRelPath3(p.path),
+    path: normalizeRelPath4(p.path),
     name: p.name
   }));
   for (const project of artifact.projects) {
     if (!project.architecture) continue;
     refineArchitectureResult(project.architecture, graph, {
-      projectPath: normalizeRelPath3(project.path),
+      projectPath: normalizeRelPath4(project.path),
       projects
     });
     project.architectureMermaid = mermaidFromArchitecture(project.architecture);
@@ -13859,17 +14015,17 @@ var FILE_ROLES = /* @__PURE__ */ new Set([
   "handler",
   "router"
 ]);
-function normalizeRelPath4(p) {
+function normalizeRelPath5(p) {
   return (p || ".").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "") || ".";
 }
-function compareRelPath3(a, b) {
-  return normalizeRelPath4(a).localeCompare(normalizeRelPath4(b));
+function compareRelPath4(a, b) {
+  return normalizeRelPath5(a).localeCompare(normalizeRelPath5(b));
 }
 function sortedSignals3(signals) {
   return [...new Set(signals)].sort((a, b) => a.localeCompare(b));
 }
 function parentDir4(filePath) {
-  const n = normalizeRelPath4(filePath);
+  const n = normalizeRelPath5(filePath);
   if (n === ".") return ".";
   const i = n.lastIndexOf("/");
   return i <= 0 ? "." : n.slice(0, i);
@@ -13884,8 +14040,8 @@ function ancestorDirs3(filePath) {
   return dirs;
 }
 function pathOwnsFile2(projectPath, file) {
-  const prefix = normalizeRelPath4(projectPath);
-  const f = normalizeRelPath4(file);
+  const prefix = normalizeRelPath5(projectPath);
+  const f = normalizeRelPath5(file);
   if (prefix === ".") return true;
   return f === prefix || f.startsWith(`${prefix}/`);
 }
@@ -13899,32 +14055,32 @@ function pickBestHits(hits) {
   const byFile = /* @__PURE__ */ new Map();
   for (const hit of hits) {
     if (!FILE_ROLES.has(hit.role)) continue;
-    const key = normalizeRelPath4(hit.filePath);
+    const key = normalizeRelPath5(hit.filePath);
     const normalized = { ...hit, filePath: key };
     const existing = byFile.get(key);
     if (!existing || compareHits(normalized, existing) < 0) {
       byFile.set(key, normalized);
     }
   }
-  return [...byFile.values()].sort((a, b) => compareRelPath3(a.filePath, b.filePath));
+  return [...byFile.values()].sort((a, b) => compareRelPath4(a.filePath, b.filePath));
 }
 function nearestFolder2(filePath, folders) {
   for (const ancestor of ancestorDirs3(filePath)) {
-    const folder = folders.find((f) => normalizeRelPath4(f.path) === ancestor);
+    const folder = folders.find((f) => normalizeRelPath5(f.path) === ancestor);
     if (folder) return folder;
   }
   return void 0;
 }
 function fileInLayerSample2(result, filePath) {
-  const n = normalizeRelPath4(filePath);
+  const n = normalizeRelPath5(filePath);
   for (const layer of result.layers) {
-    if (layer.files.some((f) => normalizeRelPath4(f) === n)) return layer.layer;
+    if (layer.files.some((f) => normalizeRelPath5(f) === n)) return layer.layer;
   }
   return void 0;
 }
 function existingRole(result, filePath) {
-  const n = normalizeRelPath4(filePath);
-  return result.classified?.find((c) => normalizeRelPath4(c.filePath) === n)?.role;
+  const n = normalizeRelPath5(filePath);
+  return result.classified?.find((c) => normalizeRelPath5(c.filePath) === n)?.role;
 }
 function pathPriorConfidence(folder, pathLayer, fallback) {
   if (folder && folder.layer === pathLayer) return folder.confidence;
@@ -13932,7 +14088,7 @@ function pathPriorConfidence(folder, pathLayer, fallback) {
   return fallback;
 }
 function buildFileState2(filePath, result) {
-  const n = normalizeRelPath4(filePath);
+  const n = normalizeRelPath5(filePath);
   const sampleLayer = fileInLayerSample2(result, n);
   const folder = nearestFolder2(n, result.folders ?? []);
   const role = existingRole(result, n);
@@ -13984,11 +14140,11 @@ function ensureLayer2(result, layer) {
   return summary;
 }
 function addFileToLayer2(summary, filePath) {
-  const n = normalizeRelPath4(filePath);
-  if (summary.files.some((f) => normalizeRelPath4(f) === n)) return;
+  const n = normalizeRelPath5(filePath);
+  if (summary.files.some((f) => normalizeRelPath5(f) === n)) return;
   if (summary.files.length < LAYER_FILES_CAP2) {
     summary.files.push(n);
-    summary.files.sort(compareRelPath3);
+    summary.files.sort(compareRelPath4);
   }
   summary.fileCount += 1;
 }
@@ -14002,7 +14158,7 @@ function raiseSupportLevel(result) {
 }
 function persistClassified(result, classified) {
   const sorted = [...classified].sort(
-    (a, b) => compareRelPath3(a.filePath, b.filePath) || a.role.localeCompare(b.role)
+    (a, b) => compareRelPath4(a.filePath, b.filePath) || a.role.localeCompare(b.role)
   );
   if (sorted.length <= CLASSIFIED_ROLE_CAP) {
     if (sorted.length > 0) result.classified = sorted;
@@ -14010,9 +14166,9 @@ function persistClassified(result, classified) {
     return;
   }
   const ranked = [...sorted].sort(
-    (a, b) => b.confidence - a.confidence || compareRelPath3(a.filePath, b.filePath) || (a.role ?? "").localeCompare(b.role ?? "")
+    (a, b) => b.confidence - a.confidence || compareRelPath4(a.filePath, b.filePath) || (a.role ?? "").localeCompare(b.role ?? "")
   );
-  result.classified = ranked.slice(0, CLASSIFIED_ROLE_CAP).sort((a, b) => compareRelPath3(a.filePath, b.filePath));
+  result.classified = ranked.slice(0, CLASSIFIED_ROLE_CAP).sort((a, b) => compareRelPath4(a.filePath, b.filePath));
 }
 function applyAstRoles(result, hits, opts = {}) {
   if (isLayerSkipped2(result)) return;
@@ -14024,10 +14180,10 @@ function applyAstRoles(result, hits, opts = {}) {
     return true;
   });
   if (best.length === 0) return;
-  const unclassified = new Set((result.unclassifiedFiles ?? []).map(normalizeRelPath4));
+  const unclassified = new Set((result.unclassifiedFiles ?? []).map(normalizeRelPath5));
   const classified = /* @__PURE__ */ new Map();
   for (const existing of result.classified ?? []) {
-    classified.set(normalizeRelPath4(existing.filePath), {
+    classified.set(normalizeRelPath5(existing.filePath), {
       ...existing,
       signals: [...existing.signals]
     });
@@ -14046,14 +14202,16 @@ function applyAstRoles(result, hits, opts = {}) {
         layer: hit.layer,
         confidence: hit.confidence,
         signals: signals2,
-        role: hit.role
+        role: hit.role,
+        source: "ast"
       };
       classified.set(hit.filePath, entry);
       addFileToLayer2(ensureLayer2(result, hit.layer), hit.filePath);
       result.totalClassified += 1;
-      if (unclassified.delete(hit.filePath) && result.unclassified > 0) {
-        result.unclassified -= 1;
-      }
+      unclassified.delete(hit.filePath);
+      if (result.unclassified > 0) result.unclassified -= 1;
+      creditCoverage(result, "ast");
+      debitUnclassifiedFolder(result, hit.filePath);
       addFolderSignal2(result, hit.filePath, `${AST_ROLE_SIGNAL_PREFIX}${hit.role}`);
       applied = true;
       continue;
@@ -14082,8 +14240,8 @@ function applyAstRoles(result, hits, opts = {}) {
       const previous = state.layer;
       const fromSummary = result.layers.find((l) => l.layer === previous);
       if (fromSummary) {
-        const n = normalizeRelPath4(hit.filePath);
-        const next = fromSummary.files.filter((f) => normalizeRelPath4(f) !== n);
+        const n = normalizeRelPath5(hit.filePath);
+        const next = fromSummary.files.filter((f) => normalizeRelPath5(f) !== n);
         if (next.length !== fromSummary.files.length && fromSummary.fileCount > 0) {
           fromSummary.fileCount -= 1;
         }
@@ -14098,12 +14256,14 @@ function applyAstRoles(result, hits, opts = {}) {
         "ast-overrides-suffix",
         hit.signal
       ]);
+      reattributeCoverage(result, already?.source ?? "suffix", "ast");
       classified.set(hit.filePath, {
         filePath: hit.filePath,
         layer: hit.layer,
         confidence: hit.confidence,
         signals: signals2,
-        role: hit.role
+        role: hit.role,
+        source: "ast"
       });
       addFileToLayer2(ensureLayer2(result, hit.layer), hit.filePath);
       addFolderSignal2(result, hit.filePath, `${AST_ROLE_SIGNAL_PREFIX}${hit.role}`);
@@ -14138,7 +14298,7 @@ function refineArchitectureWithAstRoles(artifact, hits) {
   if (hits.length === 0) return;
   for (const project of artifact.projects) {
     if (!project.architecture) continue;
-    applyAstRoles(project.architecture, hits, { projectPath: normalizeRelPath4(project.path) });
+    applyAstRoles(project.architecture, hits, { projectPath: normalizeRelPath5(project.path) });
     project.architectureMermaid = mermaidFromArchitecture(project.architecture);
   }
   if (artifact.extended?.architecture) {
@@ -14356,20 +14516,20 @@ function residualProject(seed) {
     dependencyAgeBuckets: { current: 0, oneBehind: 0, twoPlusBehind: 0, unknown: 0 }
   };
 }
-function compareRelPath4(a, b) {
+function compareRelPath5(a, b) {
   return a.replace(/\\/g, "/").localeCompare(b.replace(/\\/g, "/"));
 }
-function normalizeRelPath5(p) {
+function normalizeRelPath6(p) {
   return (p || ".").replace(/\\/g, "/").replace(/^\.\/+/, "").replace(/\/+$/, "") || ".";
 }
 function toRepoRelative(projectPath, filePath) {
   const normalised = filePath.replace(/\\/g, "/");
-  const prefix = normalizeRelPath5(projectPath);
+  const prefix = normalizeRelPath6(projectPath);
   if (prefix === ".") return normalised;
   return `${prefix}/${normalised}`;
 }
 function pathOwnsFile3(projectPath, file) {
-  const prefix = normalizeRelPath5(projectPath);
+  const prefix = normalizeRelPath6(projectPath);
   const f = file.replace(/\\/g, "/");
   if (prefix === ".") return true;
   return f === prefix || f.startsWith(`${prefix}/`);
@@ -14378,7 +14538,7 @@ function owningProjectPath2(file, projectPaths) {
   let best = ".";
   let bestLen = -1;
   for (const raw of projectPaths) {
-    const p = normalizeRelPath5(raw);
+    const p = normalizeRelPath6(raw);
     if (!pathOwnsFile3(p, file)) continue;
     const len = p === "." ? 0 : p.length;
     if (len > bestLen) {
@@ -14755,7 +14915,7 @@ function uniqueResultsForAggregate(projectResults, projects) {
     const byPath = /* @__PURE__ */ new Map();
     const ownerOverlay = /* @__PURE__ */ new Map();
     for (let i = 0; i < projects.length; i++) {
-      const key = normalizeRelPath5(projects[i].path);
+      const key = normalizeRelPath6(projects[i].path);
       const overlay = isOverlayProject(projects[i]);
       const existing = byPath.get(key);
       if (!existing) {
@@ -14796,7 +14956,7 @@ function aggregateSolutionArchitecture(projectResults, projects) {
     for (const ls of r.layers) {
       const existing = layerMap.get(ls.layer);
       if (!existing) {
-        const files = [...ls.files].sort(compareRelPath4).slice(0, 40);
+        const files = [...ls.files].sort(compareRelPath5).slice(0, 40);
         layerMap.set(ls.layer, { ...ls, packages: [...ls.packages], techStack: [...ls.techStack], services: [...ls.services], files });
       } else {
         existing.fileCount += ls.fileCount;
@@ -14828,7 +14988,7 @@ function aggregateSolutionArchitecture(projectResults, projects) {
             seenFiles.add(f);
           }
         }
-        existing.files.sort(compareRelPath4);
+        existing.files.sort(compareRelPath5);
         if (existing.files.length > 40) existing.files.length = 40;
         const { score, riskLevel } = computeLayerDrift(existing.packages);
         existing.driftScore = score;
@@ -14887,6 +15047,15 @@ function applyAggregatedPackFields(target, unique) {
   const unclassifiedFiles = mergeUnclassifiedFiles(unique.map((r) => r.unclassifiedFiles));
   if (unclassifiedFiles) target.unclassifiedFiles = unclassifiedFiles;
   else delete target.unclassifiedFiles;
+  const coverage = mergeCoverage(unique.map((r) => r.coverage));
+  if (coverage) target.coverage = coverage;
+  else delete target.coverage;
+  const groupedFolders = mergeUnclassifiedFolders(unique.map((r) => r.unclassifiedFolders));
+  if (groupedFolders.folders.length > 0) target.unclassifiedFolders = groupedFolders.folders;
+  else delete target.unclassifiedFolders;
+  if (groupedFolders.capped || unique.some((r) => r.unclassifiedFoldersCapped)) {
+    target.unclassifiedFoldersCapped = true;
+  } else delete target.unclassifiedFoldersCapped;
   const payload = capEvidence(allEvidence);
   if (payload.evidence) target.evidence = payload.evidence;
   if (payload.evidenceCapped || unique.some((r) => r.evidenceCapped)) target.evidenceCapped = true;
@@ -14990,10 +15159,10 @@ async function scanArchitectureBundle(rootDir, projects, tooling, services, cach
     workspace2.workspaceShape = "single";
     return { workspace: workspace2, projectResults: [] };
   }
-  const sorted = [...projects].sort((a, b) => compareRelPath4(a.path, b.path) || a.name.localeCompare(b.name));
+  const sorted = [...projects].sort((a, b) => compareRelPath5(a.path, b.path) || a.name.localeCompare(b.name));
   const ownerByPath = /* @__PURE__ */ new Map();
   for (const p of sorted) {
-    const key = normalizeRelPath5(p.path);
+    const key = normalizeRelPath6(p.path);
     const existing = ownerByPath.get(key);
     if (!existing || isOverlayProject(existing) && !isOverlayProject(p)) {
       ownerByPath.set(key, p);
@@ -15003,11 +15172,11 @@ async function scanArchitectureBundle(rootDir, projects, tooling, services, cach
   const resultByPath = /* @__PURE__ */ new Map();
   await Promise.all(owners.map(async (owner) => {
     const result = await scanProjectArchitecture(rootDir, owner, cache, owners);
-    resultByPath.set(normalizeRelPath5(owner.path), result);
+    resultByPath.set(normalizeRelPath6(owner.path), result);
   }));
-  const projectResults = projects.map((p) => resultByPath.get(normalizeRelPath5(p.path)));
+  const projectResults = projects.map((p) => resultByPath.get(normalizeRelPath6(p.path)));
   const uniqueResults = [...resultByPath.values()];
-  const ownerPaths = owners.map((o) => normalizeRelPath5(o.path));
+  const ownerPaths = owners.map((o) => normalizeRelPath6(o.path));
   if (!ownerPaths.includes(".")) {
     const residual = await classifyTree(rootDir, [residualProject(owners[0])], tooling, services, cache, {
       projectPath: ".",
@@ -15035,8 +15204,8 @@ async function classifyTree(rootDir, projects, tooling, services, cache, scope)
   const detected = detectArchetype(projects);
   let sourceFiles = await walkSourceFiles(rootDir, cache);
   if (scope) {
-    const owner = normalizeRelPath5(scope.projectPath);
-    const uniquePaths = [...new Set(scope.workspacePaths.map(normalizeRelPath5))];
+    const owner = normalizeRelPath6(scope.projectPath);
+    const uniquePaths = [...new Set(scope.workspacePaths.map(normalizeRelPath6))];
     sourceFiles = sourceFiles.filter((f) => {
       const repoRel = toRepoRelative(scope.projectPath, f);
       return owningProjectPath2(repoRel, uniquePaths) === owner;
@@ -15058,7 +15227,7 @@ async function classifyTree(rootDir, projects, tooling, services, cache, scope)
   const artifactKind = fusion.winners.get("artifactKind")?.value;
   const skipAllLayers = projectKind === "iac" || projectKind === "contract";
   const packRules = collectPackLayerRules(matching);
-  sourceFiles.sort(compareRelPath4);
+  sourceFiles.sort(compareRelPath5);
   const seedClassified = [];
   const seedUnclassified = [];
   for (const file of sourceFiles) {
@@ -15168,6 +15337,12 @@ async function classifyTree(rootDir, projects, tooling, services, cache, scope)
   if (!skipAllLayers && inherited.folders.length > 0) result.folders = inherited.folders;
   const unclassifiedSample = capUnclassifiedFiles(inherited.unclassifiedSource);
   if (unclassifiedSample) result.unclassifiedFiles = unclassifiedSample;
+  if (!skipAllLayers && (classifications.length > 0 || unclassified > 0)) {
+    result.coverage = buildCoverage(classifications, unclassified);
+    const grouped = buildUnclassifiedFolders(inherited.unclassifiedSource);
+    if (grouped.folders.length > 0) result.unclassifiedFolders = grouped.folders;
+    if (grouped.capped) result.unclassifiedFoldersCapped = true;
+  }
   const supportLevel = computeSupportLevel(fusion, classifications.length, primary.type);
   result.supportLevel = supportLevel;
   if (fusion.packIds.length > 0) result.packIds = fusion.packIds;
@@ -15953,6 +16128,6 @@ async function computeTreeMetadataHash(rootDir, options) {
   return digest.digest("hex");
 }
 
-export { PROJECT_TYPE_TO_OSV_ECOSYSTEM, aggregateSolutionArchitecture, boundaryProfileRules, brandProgressBar, buildVersionTimelines, compactUiPurpose, computeDriftScore, computeRepoFingerprint, computeUpgradeImpact, detectVcs, driftBar, fetchRiskySymbols, fetchScanPreflight, findPackageAnyEcosystem, findPackageTimeline, findVersionCrossings, getChangelogSignals, gitHistoryAvailable, loadConfig, mermaidFromArchitecture, normalizeConstraint, parseDsn, perDependencyDrift, prepareCompressedUpload, projectTypeToVulnEcosystem, refineArchitectureWithAstRoles, refineArchitectureWithGraph, resolveHead, resolveRepositoryName, runCoreScan, scanArchitectureBundle, severityRank, titleBox, versionSatisfies, workingTreeDirty, writeDefaultConfig };
-//# sourceMappingURL=chunk-5UG4UHKU.js.map
-//# sourceMappingURL=chunk-5UG4UHKU.js.map
+export { PROJECT_TYPE_TO_OSV_ECOSYSTEM, aggregateSolutionArchitecture, boundaryProfileRules, brandProgressBar, buildVersionTimelines, classifyFile, compactUiPurpose, computeDriftScore, computeRepoFingerprint, computeUpgradeImpact, detectVcs, driftBar, evaluateLayerBoundary, fetchRiskySymbols, fetchScanPreflight, findPackageAnyEcosystem, findPackageTimeline, findVersionCrossings, getChangelogSignals, gitHistoryAvailable, loadConfig, mermaidFromArchitecture, normalizeConstraint, parseDsn, parseToml, perDependencyDrift, prepareCompressedUpload, projectTypeToVulnEcosystem, refineArchitectureWithAstRoles, refineArchitectureWithGraph, resolveHead, resolveRepositoryName, runCoreScan, scanArchitectureBundle, severityRank, titleBox, versionSatisfies, workingTreeDirty, writeDefaultConfig };
+//# sourceMappingURL=chunk-HUJZO4K5.js.map
+//# sourceMappingURL=chunk-HUJZO4K5.js.map