@vibgrate/cli 1.0.14 → 1.0.16

package/dist/{chunk-4N4BALQQ.js → chunk-N37F5EZQ.js}

@@ -23,7 +23,7 @@ var Semaphore = class {
       this.available--;
       return Promise.resolve();
     }
-    return new Promise((resolve6) => this.queue.push(resolve6));
+    return new Promise((resolve7) => this.queue.push(resolve7));
   }
   release() {
     const next = this.queue.shift();
@@ -50,6 +50,140 @@ var SKIP_DIRS = /* @__PURE__ */ new Set([
   "packages",
   "TestResults"
 ]);
+var TEXT_CACHE_MAX_BYTES = 1048576;
+var FileCache = class _FileCache {
+  /** Directory walk results keyed by rootDir */
+  walkCache = /* @__PURE__ */ new Map();
+  /** File content keyed by absolute path (only files ≤ TEXT_CACHE_MAX_BYTES) */
+  textCache = /* @__PURE__ */ new Map();
+  /** Parsed JSON keyed by absolute path */
+  jsonCache = /* @__PURE__ */ new Map();
+  /** pathExists keyed by absolute path */
+  existsCache = /* @__PURE__ */ new Map();
+  // ── Directory walking ──
+  /**
+   * Walk the directory tree from `rootDir` once, skipping SKIP_DIRS plus
+   * common framework output dirs (.nuxt, .output, .svelte-kit).
+   *
+   * The result is memoised so every scanner filters the same array.
+   * Consumers that need additional filtering (e.g. SOURCE_EXTENSIONS,
+   * SKIP_EXTENSIONS) do so on the returned entries — no separate walk.
+   */
+  walkDir(rootDir) {
+    const cached = this.walkCache.get(rootDir);
+    if (cached) return cached;
+    const promise = this._doWalk(rootDir);
+    this.walkCache.set(rootDir, promise);
+    return promise;
+  }
+  /** Additional dirs skipped only by the cached walk (framework outputs) */
+  static EXTRA_SKIP = /* @__PURE__ */ new Set([".nuxt", ".output", ".svelte-kit"]);
+  async _doWalk(rootDir) {
+    const results = [];
+    const maxConcurrentReads = Math.max(8, Math.min(64, os.availableParallelism() * 4));
+    const sem = new Semaphore(maxConcurrentReads);
+    const extraSkip = _FileCache.EXTRA_SKIP;
+    async function walk(dir) {
+      let entries;
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      const subWalks = [];
+      for (const e of entries) {
+        const absPath = path.join(dir, e.name);
+        const relPath = path.relative(rootDir, absPath);
+        if (e.isDirectory()) {
+          if (SKIP_DIRS.has(e.name) || extraSkip.has(e.name)) continue;
+          results.push({ absPath, relPath, name: e.name, isFile: false, isDirectory: true });
+          subWalks.push(sem.run(() => walk(absPath)));
+        } else if (e.isFile()) {
+          results.push({ absPath, relPath, name: e.name, isFile: true, isDirectory: false });
+        }
+      }
+      await Promise.all(subWalks);
+    }
+    await sem.run(() => walk(rootDir));
+    return results;
+  }
+  /**
+   * Find files matching a predicate from the cached walk.
+   * Returns absolute paths (same contract as the standalone `findFiles`).
+   */
+  async findFiles(rootDir, predicate) {
+    const entries = await this.walkDir(rootDir);
+    return entries.filter((e) => e.isFile && predicate(e.name)).map((e) => e.absPath);
+  }
+  async findPackageJsonFiles(rootDir) {
+    return this.findFiles(rootDir, (name) => name === "package.json");
+  }
+  async findCsprojFiles(rootDir) {
+    return this.findFiles(rootDir, (name) => name.endsWith(".csproj"));
+  }
+  async findSolutionFiles(rootDir) {
+    return this.findFiles(rootDir, (name) => name.endsWith(".sln"));
+  }
+  // ── File content reading ──
+  /**
+   * Read a text file. Files ≤ 1 MB are cached so subsequent calls from
+   * different scanners return the same string. Files > 1 MB (lockfiles,
+   * large generated files) are read directly and never retained.
+   */
+  readTextFile(filePath) {
+    const abs = path.resolve(filePath);
+    const cached = this.textCache.get(abs);
+    if (cached) return cached;
+    const promise = fs.readFile(abs, "utf8").then((content) => {
+      if (content.length > TEXT_CACHE_MAX_BYTES) {
+        this.textCache.delete(abs);
+      }
+      return content;
+    });
+    this.textCache.set(abs, promise);
+    return promise;
+  }
+  /**
+   * Read and parse a JSON file. The parsed object is cached; the raw
+   * text is evicted immediately so we never hold both representations.
+   */
+  readJsonFile(filePath) {
+    const abs = path.resolve(filePath);
+    const cached = this.jsonCache.get(abs);
+    if (cached) return cached;
+    const promise = this.readTextFile(abs).then((txt) => {
+      this.textCache.delete(abs);
+      return JSON.parse(txt);
+    });
+    this.jsonCache.set(abs, promise);
+    return promise;
+  }
+  // ── Existence checks ──
+  pathExists(p) {
+    const abs = path.resolve(p);
+    const cached = this.existsCache.get(abs);
+    if (cached) return cached;
+    const promise = fs.access(abs).then(() => true, () => false);
+    this.existsCache.set(abs, promise);
+    return promise;
+  }
+  // ── Lifecycle ──
+  /** Release all cached data. Call after the scan completes. */
+  clear() {
+    this.walkCache.clear();
+    this.textCache.clear();
+    this.jsonCache.clear();
+    this.existsCache.clear();
+  }
+  /** Number of file content entries currently held */
+  get textCacheSize() {
+    return this.textCache.size;
+  }
+  /** Number of parsed JSON entries currently held */
+  get jsonCacheSize() {
+    return this.jsonCache.size;
+  }
+};
 async function findFiles(rootDir, predicate) {
   const results = [];
   const maxConcurrentReads = Math.max(8, Math.min(64, os.availableParallelism() * 4));
@@ -187,12 +321,12 @@ function eolScore(projects) {
 }
 function computeDriftScore(projects) {
   const rs = runtimeScore(projects);
-  const fs5 = frameworkScore(projects);
+  const fs6 = frameworkScore(projects);
   const ds = dependencyScore(projects);
   const es = eolScore(projects);
   const components = [
     { score: rs, weight: 0.25 },
-    { score: fs5, weight: 0.25 },
+    { score: fs6, weight: 0.25 },
     { score: ds, weight: 0.3 },
     { score: es, weight: 0.2 }
   ];
@@ -203,7 +337,7 @@ function computeDriftScore(projects) {
       riskLevel: "low",
       components: {
         runtimeScore: Math.round(rs ?? 100),
-        frameworkScore: Math.round(fs5 ?? 100),
+        frameworkScore: Math.round(fs6 ?? 100),
         dependencyScore: Math.round(ds ?? 100),
         eolScore: Math.round(es ?? 100)
       }
@@ -221,7 +355,7 @@ function computeDriftScore(projects) {
   else riskLevel = "high";
   const measured = [];
   if (rs !== null) measured.push("runtime");
-  if (fs5 !== null) measured.push("framework");
+  if (fs6 !== null) measured.push("framework");
   if (ds !== null) measured.push("dependency");
   if (es !== null) measured.push("eol");
   return {
@@ -229,7 +363,7 @@ function computeDriftScore(projects) {
     riskLevel,
     components: {
       runtimeScore: Math.round(rs ?? 100),
-      frameworkScore: Math.round(fs5 ?? 100),
+      frameworkScore: Math.round(fs6 ?? 100),
       dependencyScore: Math.round(ds ?? 100),
       eolScore: Math.round(es ?? 100)
     },
@@ -585,6 +719,122 @@ function formatExtended(ext) {
       lines.push("");
     }
   }
+  if (ext.architecture) {
+    lines.push(...formatArchitectureDiagram(ext.architecture));
+  }
+  return lines;
+}
+var LAYER_LABELS = {
+  "presentation": "Presentation",
+  "routing": "Routing",
+  "middleware": "Middleware",
+  "services": "Services",
+  "domain": "Domain",
+  "data-access": "Data Access",
+  "infrastructure": "Infrastructure",
+  "config": "Config",
+  "shared": "Shared",
+  "testing": "Testing"
+};
+var LAYER_ICONS = {
+  "presentation": "\u{1F5A5}",
+  "routing": "\u{1F500}",
+  "middleware": "\u{1F517}",
+  "services": "\u2699",
+  "domain": "\u{1F48E}",
+  "data-access": "\u{1F5C4}",
+  "infrastructure": "\u{1F3D7}",
+  "config": "\u2699",
+  "shared": "\u{1F4E6}",
+  "testing": "\u{1F9EA}"
+};
+function formatArchitectureDiagram(arch) {
+  const lines = [];
+  lines.push(chalk.bold.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  lines.push(chalk.bold.cyan("\u2551        Architecture Layers               \u2551"));
+  lines.push(chalk.bold.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  lines.push("");
+  const archetypeDisplay = arch.archetype === "unknown" ? "Unknown" : arch.archetype;
+  const confPct = Math.round(arch.archetypeConfidence * 100);
+  lines.push(chalk.bold("  Archetype: ") + chalk.cyan.bold(archetypeDisplay) + chalk.dim(` (${confPct}% confidence)`));
+  lines.push(chalk.dim(`  ${arch.totalClassified} files classified \xB7 ${arch.unclassified} unclassified`));
+  lines.push("");
+  const boxWidth = 44;
+  const visibleLayers = arch.layers.filter((l) => l.fileCount > 0 || l.techStack.length > 0 || l.services.length > 0);
+  if (visibleLayers.length === 0) {
+    lines.push(chalk.dim("  No layers detected"));
+    lines.push("");
+    return lines;
+  }
+  for (let i = 0; i < visibleLayers.length; i++) {
+    const layer = visibleLayers[i];
+    const icon = LAYER_ICONS[layer.layer] ?? "\xB7";
+    const label = LAYER_LABELS[layer.layer] ?? layer.layer;
+    const scoreColor = layer.driftScore >= 70 ? chalk.green : layer.driftScore >= 40 ? chalk.yellow : chalk.red;
+    const riskBadgeStr = layer.riskLevel === "low" ? chalk.bgGreen.black(" LOW ") : layer.riskLevel === "moderate" ? chalk.bgYellow.black(" MOD ") : chalk.bgRed.white(" HIGH ");
+    if (i === 0) {
+      lines.push(chalk.cyan(`  \u250C${"\u2500".repeat(boxWidth)}\u2510`));
+    }
+    const nameStr = `${icon}  ${label}`;
+    const scoreStr = `${layer.driftScore}/100`;
+    const fileSuffix = `${layer.fileCount} file${layer.fileCount !== 1 ? "s" : ""}`;
+    const leftContent = `  ${nameStr}`;
+    const rightContent = `${fileSuffix}  ${scoreStr}  `;
+    const leftLen = nameStr.length + 2;
+    const rightLen = rightContent.length;
+    const padLen = Math.max(1, boxWidth - leftLen - rightLen);
+    lines.push(
+      chalk.cyan("  \u2502") + `  ${icon}  ${chalk.bold(label)}` + " ".repeat(padLen) + chalk.dim(fileSuffix) + "  " + scoreColor.bold(scoreStr) + "  " + chalk.cyan("\u2502")
+    );
+    const barWidth = boxWidth - 8;
+    const filled = Math.round(layer.driftScore / 100 * barWidth);
+    const empty = barWidth - filled;
+    lines.push(
+      chalk.cyan("  \u2502") + "    " + scoreColor("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(empty)) + "    " + chalk.cyan("\u2502")
+    );
+    if (layer.techStack.length > 0) {
+      const techNames = layer.techStack.slice(0, 6).map((t) => t.name);
+      const moreCount = layer.techStack.length > 6 ? ` +${layer.techStack.length - 6}` : "";
+      const techLine = `Tech: ${techNames.join(", ")}${moreCount}`;
+      const truncated = techLine.length > boxWidth - 6 ? techLine.slice(0, boxWidth - 9) + "..." : techLine;
+      const techPad = Math.max(0, boxWidth - truncated.length - 4);
+      lines.push(
+        chalk.cyan("  \u2502") + "    " + chalk.dim(truncated) + " ".repeat(techPad) + chalk.cyan("\u2502")
+      );
+    }
+    if (layer.services.length > 0) {
+      const svcNames = layer.services.slice(0, 5).map((s) => s.name);
+      const moreCount = layer.services.length > 5 ? ` +${layer.services.length - 5}` : "";
+      const svcLine = `Services: ${svcNames.join(", ")}${moreCount}`;
+      const truncated = svcLine.length > boxWidth - 6 ? svcLine.slice(0, boxWidth - 9) + "..." : svcLine;
+      const svcPad = Math.max(0, boxWidth - truncated.length - 4);
+      lines.push(
+        chalk.cyan("  \u2502") + "    " + chalk.dim(truncated) + " ".repeat(svcPad) + chalk.cyan("\u2502")
+      );
+    }
+    const driftPkgs = layer.packages.filter((p) => p.majorsBehind !== null && p.majorsBehind > 0);
+    if (driftPkgs.length > 0) {
+      const worst = driftPkgs.sort((a, b) => (b.majorsBehind ?? 0) - (a.majorsBehind ?? 0));
+      const shown = worst.slice(0, 3);
+      const pkgStrs = shown.map((p) => {
+        const color = (p.majorsBehind ?? 0) >= 2 ? chalk.red : chalk.yellow;
+        return color(`${p.name} -${p.majorsBehind}`);
+      });
+      const moreCount = worst.length > 3 ? chalk.dim(` +${worst.length - 3}`) : "";
+      const pkgLine = pkgStrs.join(chalk.dim(", ")) + moreCount;
+      const roughLen = shown.map((p) => `${p.name} -${p.majorsBehind}`).join(", ").length + (worst.length > 3 ? ` +${worst.length - 3}`.length : 0);
+      const pkgPad = Math.max(0, boxWidth - roughLen - 4);
+      lines.push(
+        chalk.cyan("  \u2502") + "    " + pkgLine + " ".repeat(pkgPad) + chalk.cyan("\u2502")
+      );
+    }
+    if (i < visibleLayers.length - 1) {
+      lines.push(chalk.cyan(`  \u251C${"\u2500".repeat(boxWidth)}\u2524`));
+    } else {
+      lines.push(chalk.cyan(`  \u2514${"\u2500".repeat(boxWidth)}\u2518`));
+    }
+  }
+  lines.push("");
   return lines;
 }
 function generatePriorityActions(artifact) {
@@ -1050,7 +1300,7 @@ var pushCommand = new Command2("push").description("Push scan results to Vibgrat
 });
 
 // src/commands/scan.ts
-import * as path14 from "path";
+import * as path15 from "path";
 import { Command as Command3 } from "commander";
 import chalk5 from "chalk";
 
@@ -1070,7 +1320,7 @@ function maxStable(versions) {
   return stable.sort(semver.rcompare)[0] ?? null;
 }
 async function npmViewJson(args, cwd) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve7, reject) => {
     const child = spawn("npm", ["view", ...args, "--json"], {
       cwd,
       stdio: ["ignore", "pipe", "pipe"]
@@ -1087,13 +1337,13 @@ async function npmViewJson(args, cwd) {
       }
       const trimmed = out.trim();
       if (!trimmed) {
-        resolve6(null);
+        resolve7(null);
         return;
       }
       try {
-        resolve6(JSON.parse(trimmed));
+        resolve7(JSON.parse(trimmed));
       } catch {
-        resolve6(trimmed.replace(/^"|"$/g, ""));
+        resolve7(trimmed.replace(/^"|"$/g, ""));
       }
     });
   });
@@ -1229,12 +1479,12 @@ var KNOWN_FRAMEWORKS = {
   "storybook": "Storybook",
   "@storybook/react": "Storybook"
 };
-async function scanNodeProjects(rootDir, npmCache) {
-  const packageJsonFiles = await findPackageJsonFiles(rootDir);
+async function scanNodeProjects(rootDir, npmCache, cache) {
+  const packageJsonFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   const results = [];
   for (const pjPath of packageJsonFiles) {
     try {
-      const scan = await scanOnePackageJson(pjPath, rootDir, npmCache);
+      const scan = await scanOnePackageJson(pjPath, rootDir, npmCache, cache);
       results.push(scan);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -1243,8 +1493,8 @@ async function scanNodeProjects(rootDir, npmCache) {
   }
   return results;
 }
-async function scanOnePackageJson(packageJsonPath, rootDir, npmCache) {
-  const pj = await readJsonFile(packageJsonPath);
+async function scanOnePackageJson(packageJsonPath, rootDir, npmCache, cache) {
+  const pj = cache ? await cache.readJsonFile(packageJsonPath) : await readJsonFile(packageJsonPath);
   const absProjectPath = path4.dirname(packageJsonPath);
   const projectPath = path4.relative(rootDir, absProjectPath) || ".";
   const nodeEngine = pj.engines?.node ?? void 0;
@@ -1571,13 +1821,13 @@ function parseCsproj(xml, filePath) {
     projectName: path5.basename(filePath, ".csproj")
   };
 }
-async function scanDotnetProjects(rootDir) {
-  const csprojFiles = await findCsprojFiles(rootDir);
-  const slnFiles = await findSolutionFiles(rootDir);
+async function scanDotnetProjects(rootDir, cache) {
+  const csprojFiles = cache ? await cache.findCsprojFiles(rootDir) : await findCsprojFiles(rootDir);
+  const slnFiles = cache ? await cache.findSolutionFiles(rootDir) : await findSolutionFiles(rootDir);
   const slnCsprojPaths = /* @__PURE__ */ new Set();
   for (const slnPath of slnFiles) {
     try {
-      const slnContent = await readTextFile(slnPath);
+      const slnContent = cache ? await cache.readTextFile(slnPath) : await readTextFile(slnPath);
       const slnDir = path5.dirname(slnPath);
       const projectRegex = /Project\("[^"]*"\)\s*=\s*"[^"]*",\s*"([^"]+\.csproj)"/g;
       let match;
@@ -1594,7 +1844,7 @@ async function scanDotnetProjects(rootDir) {
   const results = [];
   for (const csprojPath of allCsprojFiles) {
     try {
-      const scan = await scanOneCsproj(csprojPath, rootDir);
+      const scan = await scanOneCsproj(csprojPath, rootDir, cache);
       results.push(scan);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
@@ -1603,8 +1853,8 @@ async function scanDotnetProjects(rootDir) {
   }
   return results;
 }
-async function scanOneCsproj(csprojPath, rootDir) {
-  const xml = await readTextFile(csprojPath);
+async function scanOneCsproj(csprojPath, rootDir, cache) {
+  const xml = cache ? await cache.readTextFile(csprojPath) : await readTextFile(csprojPath);
   const data = parseCsproj(xml, csprojPath);
   const primaryTfm = data.targetFrameworks[0];
   let runtimeMajorsBehind;
@@ -2212,7 +2462,7 @@ var OS_PATTERNS = [
   { pattern: /\bbash\b|#!\/bin\/bash/i, label: "bash-scripts" },
   { pattern: /\\\\/g, label: "backslash-paths" }
 ];
-async function scanPlatformMatrix(rootDir) {
+async function scanPlatformMatrix(rootDir, cache) {
   const result = {
     dotnetTargetFrameworks: [],
     nativeModules: [],
@@ -2220,12 +2470,12 @@ async function scanPlatformMatrix(rootDir) {
     dockerBaseImages: [],
     nodeVersionFiles: []
   };
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   const allDeps = /* @__PURE__ */ new Set();
   const osAssumptions = /* @__PURE__ */ new Set();
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       if (pj.engines?.node && !result.nodeEngines) result.nodeEngines = pj.engines.node;
       if (pj.engines?.npm && !result.npmEngines) result.npmEngines = pj.engines.npm;
       if (pj.engines?.pnpm && !result.pnpmEngines) {
@@ -2261,11 +2511,11 @@ async function scanPlatformMatrix(rootDir) {
   }
   result.nativeModules.sort();
   result.osAssumptions = [...osAssumptions].sort();
-  const csprojFiles = await findFiles(rootDir, (name) => name.endsWith(".csproj"));
+  const csprojFiles = cache ? await cache.findCsprojFiles(rootDir) : await findFiles(rootDir, (name) => name.endsWith(".csproj"));
   const tfms = /* @__PURE__ */ new Set();
   for (const csprojPath of csprojFiles) {
     try {
-      const xml = await readTextFile(csprojPath);
+      const xml = cache ? await cache.readTextFile(csprojPath) : await readTextFile(csprojPath);
       const tfMatch = xml.match(/<TargetFramework>(.*?)<\/TargetFramework>/);
       if (tfMatch?.[1]) tfms.add(tfMatch[1]);
       const tfsMatch = xml.match(/<TargetFrameworks>(.*?)<\/TargetFrameworks>/);
@@ -2278,14 +2528,17 @@ async function scanPlatformMatrix(rootDir) {
     }
   }
   result.dotnetTargetFrameworks = [...tfms].sort();
-  const dockerfiles = await findFiles(
+  const dockerfiles = cache ? await cache.findFiles(
+    rootDir,
+    (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
+  ) : await findFiles(
     rootDir,
     (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
   );
   const baseImages = /* @__PURE__ */ new Set();
   for (const df of dockerfiles) {
     try {
-      const content = await readTextFile(df);
+      const content = cache ? await cache.readTextFile(df) : await readTextFile(df);
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (/^FROM\s+/i.test(trimmed)) {
@@ -2303,7 +2556,8 @@ async function scanPlatformMatrix(rootDir) {
   }
   result.dockerBaseImages = [...baseImages].sort();
   for (const file of [".nvmrc", ".node-version", ".tool-versions"]) {
-    if (await pathExists(path8.join(rootDir, file))) {
+    const exists = cache ? await cache.pathExists(path8.join(rootDir, file)) : await pathExists(path8.join(rootDir, file));
+    if (exists) {
       result.nodeVersionFiles.push(file);
     }
   }
@@ -2429,7 +2683,7 @@ function parseYarnLock(content) {
   }
   return entries;
 }
-async function scanDependencyGraph(rootDir) {
+async function scanDependencyGraph(rootDir, cache) {
   const result = {
     lockfileType: null,
     totalUnique: 0,
@@ -2441,17 +2695,19 @@ async function scanDependencyGraph(rootDir) {
   const pnpmLock = path9.join(rootDir, "pnpm-lock.yaml");
   const npmLock = path9.join(rootDir, "package-lock.json");
   const yarnLock = path9.join(rootDir, "yarn.lock");
-  if (await pathExists(pnpmLock)) {
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
+  if (await _pathExists(pnpmLock)) {
     result.lockfileType = "pnpm";
-    const content = await readTextFile(pnpmLock);
+    const content = await _readTextFile(pnpmLock);
     entries = parsePnpmLock(content);
-  } else if (await pathExists(npmLock)) {
+  } else if (await _pathExists(npmLock)) {
     result.lockfileType = "npm";
-    const content = await readTextFile(npmLock);
+    const content = await _readTextFile(npmLock);
     entries = parseNpmLock(content);
-  } else if (await pathExists(yarnLock)) {
+  } else if (await _pathExists(yarnLock)) {
     result.lockfileType = "yarn";
-    const content = await readTextFile(yarnLock);
+    const content = await _readTextFile(yarnLock);
     entries = parseYarnLock(content);
   }
   if (entries.length === 0) return result;
@@ -2479,12 +2735,12 @@ async function scanDependencyGraph(rootDir) {
   duplicated.sort((a, b) => b.versions.length - a.versions.length || a.name.localeCompare(b.name));
   result.duplicatedPackages = duplicated;
   const lockedNames = new Set(versionMap.keys());
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   const phantoms = /* @__PURE__ */ new Set();
   const phantomDetails = [];
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       const relPath = path9.relative(rootDir, pjPath);
       for (const section of ["dependencies", "devDependencies"]) {
         const deps = pj[section];
@@ -2869,7 +3125,7 @@ var IAC_EXTENSIONS = {
   ".tf": "terraform",
   ".bicep": "bicep"
 };
-async function scanBuildDeploy(rootDir) {
+async function scanBuildDeploy(rootDir, cache) {
   const result = {
     ci: [],
     ciWorkflowCount: 0,
@@ -2879,26 +3135,37 @@ async function scanBuildDeploy(rootDir) {
     packageManagers: [],
     monorepoTools: []
   };
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _findFiles = cache ? (dir, pred) => cache.findFiles(dir, pred) : findFiles;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
   const ciSystems = /* @__PURE__ */ new Set();
   for (const [file, system] of Object.entries(CI_FILES)) {
     const fullPath = path10.join(rootDir, file);
-    if (await pathExists(fullPath)) {
+    if (await _pathExists(fullPath)) {
       ciSystems.add(system);
     }
   }
   const ghWorkflowDir = path10.join(rootDir, ".github", "workflows");
-  if (await pathExists(ghWorkflowDir)) {
+  if (await _pathExists(ghWorkflowDir)) {
     try {
-      const files = await findFiles(
-        ghWorkflowDir,
-        (name) => name.endsWith(".yml") || name.endsWith(".yaml")
-      );
-      result.ciWorkflowCount = files.length;
+      if (cache) {
+        const entries = await cache.walkDir(rootDir);
+        const ghPrefix = path10.relative(rootDir, ghWorkflowDir) + path10.sep;
+        result.ciWorkflowCount = entries.filter(
+          (e) => e.isFile && e.relPath.startsWith(ghPrefix) && (e.name.endsWith(".yml") || e.name.endsWith(".yaml"))
+        ).length;
+      } else {
+        const files = await _findFiles(
+          ghWorkflowDir,
+          (name) => name.endsWith(".yml") || name.endsWith(".yaml")
+        );
+        result.ciWorkflowCount = files.length;
+      }
     } catch {
     }
   }
   result.ci = [...ciSystems].sort();
-  const dockerfiles = await findFiles(
+  const dockerfiles = await _findFiles(
     rootDir,
     (name) => name === "Dockerfile" || name.startsWith("Dockerfile.")
   );
@@ -2906,7 +3173,7 @@ async function scanBuildDeploy(rootDir) {
   const baseImages = /* @__PURE__ */ new Set();
   for (const df of dockerfiles) {
     try {
-      const content = await readTextFile(df);
+      const content = await _readTextFile(df);
       for (const line of content.split("\n")) {
         const trimmed = line.trim();
         if (/^FROM\s+/i.test(trimmed)) {
@@ -2926,24 +3193,24 @@ async function scanBuildDeploy(rootDir) {
   result.docker.baseImages = [...baseImages].sort();
   const iacSystems = /* @__PURE__ */ new Set();
   for (const [ext, system] of Object.entries(IAC_EXTENSIONS)) {
-    const files = await findFiles(rootDir, (name) => name.endsWith(ext));
+    const files = await _findFiles(rootDir, (name) => name.endsWith(ext));
     if (files.length > 0) iacSystems.add(system);
   }
-  const cfnFiles = await findFiles(
+  const cfnFiles = await _findFiles(
     rootDir,
     (name) => name.endsWith(".cfn.json") || name.endsWith(".cfn.yaml")
   );
   if (cfnFiles.length > 0) iacSystems.add("cloudformation");
-  if (await pathExists(path10.join(rootDir, "Pulumi.yaml"))) iacSystems.add("pulumi");
+  if (await _pathExists(path10.join(rootDir, "Pulumi.yaml"))) iacSystems.add("pulumi");
   result.iac = [...iacSystems].sort();
   const releaseTools = /* @__PURE__ */ new Set();
   for (const [file, tool] of Object.entries(RELEASE_FILES)) {
-    if (await pathExists(path10.join(rootDir, file))) releaseTools.add(tool);
+    if (await _pathExists(path10.join(rootDir, file))) releaseTools.add(tool);
   }
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       for (const section of ["dependencies", "devDependencies"]) {
         const deps = pj[section];
         if (!deps) continue;
@@ -2963,12 +3230,12 @@ async function scanBuildDeploy(rootDir) {
   };
   const managers = /* @__PURE__ */ new Set();
   for (const [file, manager] of Object.entries(lockfileMap)) {
-    if (await pathExists(path10.join(rootDir, file))) managers.add(manager);
+    if (await _pathExists(path10.join(rootDir, file))) managers.add(manager);
   }
   result.packageManagers = [...managers].sort();
   const monoTools = /* @__PURE__ */ new Set();
   for (const [file, tool] of Object.entries(MONOREPO_FILES)) {
-    if (await pathExists(path10.join(rootDir, file))) monoTools.add(tool);
+    if (await _pathExists(path10.join(rootDir, file))) monoTools.add(tool);
   }
   result.monorepoTools = [...monoTools].sort();
   return result;
@@ -2976,7 +3243,7 @@ async function scanBuildDeploy(rootDir) {
 
 // src/scanners/ts-modernity.ts
 import * as path11 from "path";
-async function scanTsModernity(rootDir) {
+async function scanTsModernity(rootDir, cache) {
   const result = {
     typescriptVersion: null,
     strict: null,
@@ -2988,12 +3255,12 @@ async function scanTsModernity(rootDir) {
     moduleType: null,
     exportsField: false
   };
-  const pkgFiles = await findPackageJsonFiles(rootDir);
+  const pkgFiles = cache ? await cache.findPackageJsonFiles(rootDir) : await findPackageJsonFiles(rootDir);
   let hasEsm = false;
   let hasCjs = false;
   for (const pjPath of pkgFiles) {
     try {
-      const pj = await readJsonFile(pjPath);
+      const pj = cache ? await cache.readJsonFile(pjPath) : await readJsonFile(pjPath);
       if (!result.typescriptVersion) {
         const tsVer = pj.devDependencies?.["typescript"] ?? pj.dependencies?.["typescript"];
         if (tsVer) {
@@ -3014,8 +3281,9 @@ async function scanTsModernity(rootDir) {
   else if (hasEsm) result.moduleType = "esm";
   else if (hasCjs) result.moduleType = "cjs";
   let tsConfigPath = path11.join(rootDir, "tsconfig.json");
-  if (!await pathExists(tsConfigPath)) {
-    const tsConfigs = await findFiles(rootDir, (name) => name === "tsconfig.json");
+  const tsConfigExists = cache ? await cache.pathExists(tsConfigPath) : await pathExists(tsConfigPath);
+  if (!tsConfigExists) {
+    const tsConfigs = cache ? await cache.findFiles(rootDir, (name) => name === "tsconfig.json") : await findFiles(rootDir, (name) => name === "tsconfig.json");
     if (tsConfigs.length > 0) {
       tsConfigPath = tsConfigs[0];
     } else {
@@ -3023,7 +3291,7 @@ async function scanTsModernity(rootDir) {
     }
   }
   try {
-    const raw = await readTextFile(tsConfigPath);
+    const raw = cache ? await cache.readTextFile(tsConfigPath) : await readTextFile(tsConfigPath);
     const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,(\s*[}\]])/g, "$1");
     const tsConfig = JSON.parse(stripped);
     const co = tsConfig?.compilerOptions;
@@ -3394,43 +3662,63 @@ var SKIP_EXTENSIONS = /* @__PURE__ */ new Set([
   ".mp4",
   ".webm"
 ]);
-async function scanFileHotspots(rootDir) {
+async function scanFileHotspots(rootDir, cache) {
   const extensionCounts = {};
   const allFiles = [];
   let maxDepth = 0;
-  async function walk(dir, depth) {
-    if (depth > maxDepth) maxDepth = depth;
-    let entries;
-    try {
-      const dirents = await fs4.readdir(dir, { withFileTypes: true });
-      entries = dirents.map((d) => ({
-        name: d.name,
-        isDirectory: d.isDirectory(),
-        isFile: d.isFile()
-      }));
-    } catch {
-      return;
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    for (const entry of entries) {
+      if (!entry.isFile) continue;
+      const ext = path12.extname(entry.name).toLowerCase();
+      if (SKIP_EXTENSIONS.has(ext)) continue;
+      const depth = entry.relPath.split(path12.sep).length - 1;
+      if (depth > maxDepth) maxDepth = depth;
+      extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
+      try {
+        const stat3 = await fs4.stat(entry.absPath);
+        allFiles.push({
+          path: entry.relPath,
+          bytes: stat3.size
+        });
+      } catch {
+      }
     }
-    for (const e of entries) {
-      if (e.isDirectory) {
-        if (SKIP_DIRS2.has(e.name)) continue;
-        await walk(path12.join(dir, e.name), depth + 1);
-      } else if (e.isFile) {
-        const ext = path12.extname(e.name).toLowerCase();
-        if (SKIP_EXTENSIONS.has(ext)) continue;
-        extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
-        try {
-          const stat3 = await fs4.stat(path12.join(dir, e.name));
-          allFiles.push({
-            path: path12.relative(rootDir, path12.join(dir, e.name)),
-            bytes: stat3.size
-          });
-        } catch {
+  } else {
+    async function walk(dir, depth) {
+      if (depth > maxDepth) maxDepth = depth;
+      let entries;
+      try {
+        const dirents = await fs4.readdir(dir, { withFileTypes: true });
+        entries = dirents.map((d) => ({
+          name: d.name,
+          isDirectory: d.isDirectory(),
+          isFile: d.isFile()
+        }));
+      } catch {
+        return;
+      }
+      for (const e of entries) {
+        if (e.isDirectory) {
+          if (SKIP_DIRS2.has(e.name)) continue;
+          await walk(path12.join(dir, e.name), depth + 1);
+        } else if (e.isFile) {
+          const ext = path12.extname(e.name).toLowerCase();
+          if (SKIP_EXTENSIONS.has(ext)) continue;
+          extensionCounts[ext] = (extensionCounts[ext] ?? 0) + 1;
+          try {
+            const stat3 = await fs4.stat(path12.join(dir, e.name));
+            allFiles.push({
+              path: path12.relative(rootDir, path12.join(dir, e.name)),
+              bytes: stat3.size
+            });
+          } catch {
+          }
         }
       }
     }
+    await walk(rootDir, 0);
   }
-  await walk(rootDir, 0);
   allFiles.sort((a, b) => b.bytes - a.bytes);
   const largestFiles = allFiles.slice(0, 20);
   return {
@@ -3452,7 +3740,7 @@ var LOCKFILES = {
   "bun.lockb": "bun",
   "packages.lock.json": "nuget"
 };
-async function scanSecurityPosture(rootDir) {
+async function scanSecurityPosture(rootDir, cache) {
   const result = {
     lockfilePresent: false,
     multipleLockfileTypes: false,
@@ -3461,9 +3749,11 @@ async function scanSecurityPosture(rootDir) {
     envFilesTracked: false,
     lockfileTypes: []
   };
+  const _pathExists = cache ? (p) => cache.pathExists(p) : pathExists;
+  const _readTextFile = cache ? (p) => cache.readTextFile(p) : readTextFile;
   const foundLockfiles = [];
   for (const [file, type] of Object.entries(LOCKFILES)) {
-    if (await pathExists(path13.join(rootDir, file))) {
+    if (await _pathExists(path13.join(rootDir, file))) {
       foundLockfiles.push(type);
     }
   }
@@ -3471,9 +3761,9 @@ async function scanSecurityPosture(rootDir) {
   result.multipleLockfileTypes = foundLockfiles.length > 1;
   result.lockfileTypes = foundLockfiles.sort();
   const gitignorePath = path13.join(rootDir, ".gitignore");
-  if (await pathExists(gitignorePath)) {
+  if (await _pathExists(gitignorePath)) {
     try {
-      const content = await readTextFile(gitignorePath);
+      const content = await _readTextFile(gitignorePath);
       const lines = content.split("\n").map((l) => l.trim());
       result.gitignoreCoversEnv = lines.some(
         (line) => line === ".env" || line === ".env*" || line === ".env.*" || line === ".env.local" || line === "*.env"
@@ -3485,7 +3775,7 @@ async function scanSecurityPosture(rootDir) {
     }
   }
   for (const envFile of [".env", ".env.local", ".env.development", ".env.production"]) {
-    if (await pathExists(path13.join(rootDir, envFile))) {
+    if (await _pathExists(path13.join(rootDir, envFile))) {
       if (!result.gitignoreCoversEnv) {
         result.envFilesTracked = true;
         break;
@@ -3909,12 +4199,545 @@ function scanServiceDependencies(projects) {
   return result;
 }
 
+// src/scanners/architecture.ts
+import * as path14 from "path";
+import * as fs5 from "fs/promises";
+var ARCHETYPE_SIGNALS = [
+  // Meta-frameworks (highest priority — they imply routing patterns)
+  { packages: ["next", "@next/core"], archetype: "nextjs", weight: 10 },
+  { packages: ["@remix-run/react", "@remix-run/node", "@remix-run/dev"], archetype: "remix", weight: 10 },
+  { packages: ["@sveltejs/kit"], archetype: "sveltekit", weight: 10 },
+  { packages: ["nuxt"], archetype: "nuxt", weight: 10 },
+  // Backend frameworks
+  { packages: ["@nestjs/core", "@nestjs/common"], archetype: "nestjs", weight: 9 },
+  { packages: ["fastify"], archetype: "fastify", weight: 8 },
+  { packages: ["hono"], archetype: "hono", weight: 8 },
+  { packages: ["koa"], archetype: "koa", weight: 8 },
+  { packages: ["express"], archetype: "express", weight: 7 },
+  // Serverless
+  { packages: ["serverless", "aws-lambda", "@aws-sdk/client-lambda", "middy", "@cloudflare/workers-types"], archetype: "serverless", weight: 6 },
+  // CLI
+  { packages: ["commander", "yargs", "meow", "cac", "clipanion", "oclif"], archetype: "cli", weight: 5 }
+];
+function detectArchetype(projects) {
+  const allPackages = /* @__PURE__ */ new Set();
+  for (const p of projects) {
+    for (const d of p.dependencies) {
+      allPackages.add(d.package);
+    }
+  }
+  if (projects.length > 2) {
+    return { archetype: "monorepo", confidence: 0.8 };
+  }
+  let bestArchetype = "unknown";
+  let bestScore = 0;
+  for (const signal of ARCHETYPE_SIGNALS) {
+    const matched = signal.packages.filter((p) => allPackages.has(p)).length;
+    if (matched > 0) {
+      const score = matched * signal.weight;
+      if (score > bestScore) {
+        bestScore = score;
+        bestArchetype = signal.archetype;
+      }
+    }
+  }
+  if (bestArchetype === "unknown") {
+    bestArchetype = "library";
+    bestScore = 3;
+  }
+  const confidence = Math.min(bestScore / 15, 1);
+  return { archetype: bestArchetype, confidence: Math.round(confidence * 100) / 100 };
+}
+var PATH_RULES = [
+  // ── Testing (high precision) ──
+  { pattern: /\/__tests__\//, layer: "testing", confidence: 0.95, signal: "__tests__ directory" },
+  { pattern: /\.test\.[jt]sx?$/, layer: "testing", confidence: 0.95, signal: ".test.* file" },
+  { pattern: /\.spec\.[jt]sx?$/, layer: "testing", confidence: 0.95, signal: ".spec.* file" },
+  { pattern: /\/test\//, layer: "testing", confidence: 0.85, signal: "test/ directory" },
+  { pattern: /\/tests\//, layer: "testing", confidence: 0.85, signal: "tests/ directory" },
+  { pattern: /\/__mocks__\//, layer: "testing", confidence: 0.9, signal: "__mocks__ directory" },
+  { pattern: /\/fixtures\//, layer: "testing", confidence: 0.8, signal: "fixtures/ directory" },
+  // ── Config/Infrastructure (high precision) ──
+  { pattern: /\/config\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "config.* file" },
+  { pattern: /\/config\//, layer: "config", confidence: 0.8, signal: "config/ directory" },
+  { pattern: /\.config\.[jt]sx?$/, layer: "config", confidence: 0.9, signal: ".config.* file" },
+  { pattern: /\/env\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "env.* file" },
+  { pattern: /\/bootstrap\.[jt]sx?$/, layer: "config", confidence: 0.85, signal: "bootstrap file" },
+  { pattern: /\/setup\.[jt]sx?$/, layer: "config", confidence: 0.8, signal: "setup file" },
+  // ── Next.js (archetype-specific) ──
+  { pattern: /(^|\/)app\/.*\/route\.[jt]sx?$/, layer: "routing", confidence: 0.95, signal: "Next.js App Router route", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)pages\/api\//, layer: "routing", confidence: 0.95, signal: "Next.js Pages API route", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*page\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Next.js page component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*layout\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Next.js layout component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*loading\.[jt]sx?$/, layer: "presentation", confidence: 0.85, signal: "Next.js loading component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)app\/.*error\.[jt]sx?$/, layer: "presentation", confidence: 0.85, signal: "Next.js error component", archetypes: ["nextjs"] },
+  { pattern: /(^|\/)middleware\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "Next.js middleware", archetypes: ["nextjs"] },
+  // ── Remix (archetype-specific) ──
+  { pattern: /\/app\/routes\//, layer: "routing", confidence: 0.95, signal: "Remix route file", archetypes: ["remix"] },
+  { pattern: /\/app\/root\.[jt]sx?$/, layer: "presentation", confidence: 0.9, signal: "Remix root", archetypes: ["remix"] },
+  // ── SvelteKit (archetype-specific) ──
+  { pattern: /\/src\/routes\/.*\+server\.[jt]s$/, layer: "routing", confidence: 0.95, signal: "SvelteKit API route", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/routes\/.*\+page\.svelte$/, layer: "presentation", confidence: 0.9, signal: "SvelteKit page", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/routes\/.*\+layout\.svelte$/, layer: "presentation", confidence: 0.9, signal: "SvelteKit layout", archetypes: ["sveltekit"] },
+  { pattern: /\/src\/hooks\.server\.[jt]s$/, layer: "middleware", confidence: 0.9, signal: "SvelteKit server hooks", archetypes: ["sveltekit"] },
+  // ── Nuxt (archetype-specific) ──
+  { pattern: /\/server\/api\//, layer: "routing", confidence: 0.95, signal: "Nuxt server API", archetypes: ["nuxt"] },
+  { pattern: /\/server\/routes\//, layer: "routing", confidence: 0.95, signal: "Nuxt server route", archetypes: ["nuxt"] },
+  { pattern: /\/server\/middleware\//, layer: "middleware", confidence: 0.95, signal: "Nuxt server middleware", archetypes: ["nuxt"] },
+  { pattern: /\/pages\//, layer: "presentation", confidence: 0.85, signal: "Nuxt pages directory", archetypes: ["nuxt"] },
+  // ── NestJS (archetype-specific) ──
+  { pattern: /\.controller\.[jt]sx?$/, layer: "routing", confidence: 0.95, signal: "NestJS controller", archetypes: ["nestjs"] },
+  { pattern: /\.service\.[jt]sx?$/, layer: "services", confidence: 0.95, signal: "NestJS service", archetypes: ["nestjs"] },
+  { pattern: /\.module\.[jt]sx?$/, layer: "config", confidence: 0.9, signal: "NestJS module", archetypes: ["nestjs"] },
+  { pattern: /\.guard\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS guard", archetypes: ["nestjs"] },
+  { pattern: /\.interceptor\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS interceptor", archetypes: ["nestjs"] },
+  { pattern: /\.pipe\.[jt]sx?$/, layer: "middleware", confidence: 0.85, signal: "NestJS pipe", archetypes: ["nestjs"] },
+  { pattern: /\.middleware\.[jt]sx?$/, layer: "middleware", confidence: 0.9, signal: "NestJS middleware", archetypes: ["nestjs"] },
+  { pattern: /\.entity\.[jt]sx?$/, layer: "domain", confidence: 0.9, signal: "NestJS entity", archetypes: ["nestjs"] },
+  { pattern: /\.dto\.[jt]sx?$/, layer: "domain", confidence: 0.85, signal: "NestJS DTO", archetypes: ["nestjs"] },
+  { pattern: /\.repository\.[jt]sx?$/, layer: "data-access", confidence: 0.9, signal: "NestJS repository", archetypes: ["nestjs"] },
+  // ── Generic routing patterns ──
+  { pattern: /\/routes\//, layer: "routing", confidence: 0.8, signal: "routes/ directory" },
+  { pattern: /\/router\//, layer: "routing", confidence: 0.8, signal: "router/ directory" },
+  { pattern: /\/controllers\//, layer: "routing", confidence: 0.8, signal: "controllers/ directory" },
+  { pattern: /\/handlers\//, layer: "routing", confidence: 0.75, signal: "handlers/ directory" },
+  { pattern: /\/api\//, layer: "routing", confidence: 0.7, signal: "api/ directory" },
+  { pattern: /\/endpoints\//, layer: "routing", confidence: 0.8, signal: "endpoints/ directory" },
+  // ── Middleware ──
+  { pattern: /\/middleware\//, layer: "middleware", confidence: 0.85, signal: "middleware/ directory" },
+  { pattern: /\/middlewares\//, layer: "middleware", confidence: 0.85, signal: "middlewares/ directory" },
+  { pattern: /\/hooks\//, layer: "middleware", confidence: 0.6, signal: "hooks/ directory" },
+  { pattern: /\/plugins\//, layer: "middleware", confidence: 0.6, signal: "plugins/ directory" },
+  { pattern: /\/guards\//, layer: "middleware", confidence: 0.85, signal: "guards/ directory" },
+  { pattern: /\/interceptors\//, layer: "middleware", confidence: 0.85, signal: "interceptors/ directory" },
+  // ── Services / application layer ──
+  { pattern: /\/services\//, layer: "services", confidence: 0.85, signal: "services/ directory" },
+  { pattern: /\/service\//, layer: "services", confidence: 0.8, signal: "service/ directory" },
+  { pattern: /\/usecases\//, layer: "services", confidence: 0.85, signal: "usecases/ directory" },
+  { pattern: /\/use-cases\//, layer: "services", confidence: 0.85, signal: "use-cases/ directory" },
+  { pattern: /\/application\//, layer: "services", confidence: 0.7, signal: "application/ directory" },
+  { pattern: /\/actions\//, layer: "services", confidence: 0.65, signal: "actions/ directory" },
+  // ── Domain / models ──
+  { pattern: /\/domain\//, layer: "domain", confidence: 0.85, signal: "domain/ directory" },
+  { pattern: /\/models\//, layer: "domain", confidence: 0.8, signal: "models/ directory" },
+  { pattern: /\/entities\//, layer: "domain", confidence: 0.85, signal: "entities/ directory" },
+  { pattern: /\/types\//, layer: "domain", confidence: 0.7, signal: "types/ directory" },
+  { pattern: /\/schemas\//, layer: "domain", confidence: 0.7, signal: "schemas/ directory" },
+  { pattern: /\/validators\//, layer: "domain", confidence: 0.7, signal: "validators/ directory" },
+  // ── Data access ──
+  { pattern: /\/repositories\//, layer: "data-access", confidence: 0.9, signal: "repositories/ directory" },
+  { pattern: /\/repository\//, layer: "data-access", confidence: 0.85, signal: "repository/ directory" },
+  { pattern: /\/dao\//, layer: "data-access", confidence: 0.9, signal: "dao/ directory" },
+  { pattern: /\/db\//, layer: "data-access", confidence: 0.8, signal: "db/ directory" },
+  { pattern: /\/database\//, layer: "data-access", confidence: 0.8, signal: "database/ directory" },
+  { pattern: /\/persistence\//, layer: "data-access", confidence: 0.85, signal: "persistence/ directory" },
+  { pattern: /\/migrations\//, layer: "data-access", confidence: 0.9, signal: "migrations/ directory" },
+  { pattern: /\/seeds\//, layer: "data-access", confidence: 0.85, signal: "seeds/ directory" },
+  { pattern: /\/prisma\//, layer: "data-access", confidence: 0.85, signal: "prisma/ directory" },
+  { pattern: /\/drizzle\//, layer: "data-access", confidence: 0.85, signal: "drizzle/ directory" },
+  // ── Infrastructure ──
+  { pattern: /\/infra\//, layer: "infrastructure", confidence: 0.85, signal: "infra/ directory" },
+  { pattern: /\/infrastructure\//, layer: "infrastructure", confidence: 0.85, signal: "infrastructure/ directory" },
+  { pattern: /\/adapters\//, layer: "infrastructure", confidence: 0.8, signal: "adapters/ directory" },
+  { pattern: /\/clients\//, layer: "infrastructure", confidence: 0.75, signal: "clients/ directory" },
+  { pattern: /\/integrations\//, layer: "infrastructure", confidence: 0.8, signal: "integrations/ directory" },
+  { pattern: /\/external\//, layer: "infrastructure", confidence: 0.75, signal: "external/ directory" },
+  { pattern: /\/queue\//, layer: "infrastructure", confidence: 0.8, signal: "queue/ directory" },
+  { pattern: /\/jobs\//, layer: "infrastructure", confidence: 0.75, signal: "jobs/ directory" },
+  { pattern: /\/workers\//, layer: "infrastructure", confidence: 0.75, signal: "workers/ directory" },
+  { pattern: /\/cron\//, layer: "infrastructure", confidence: 0.8, signal: "cron/ directory" },
+  // ── Presentation (UI layer) ──
+  { pattern: /\/components\//, layer: "presentation", confidence: 0.85, signal: "components/ directory" },
+  { pattern: /\/views\//, layer: "presentation", confidence: 0.85, signal: "views/ directory" },
+  { pattern: /\/pages\//, layer: "presentation", confidence: 0.8, signal: "pages/ directory" },
+  { pattern: /\/layouts\//, layer: "presentation", confidence: 0.85, signal: "layouts/ directory" },
+  { pattern: /\/templates\//, layer: "presentation", confidence: 0.8, signal: "templates/ directory" },
+  { pattern: /\/widgets\//, layer: "presentation", confidence: 0.8, signal: "widgets/ directory" },
+  { pattern: /\/ui\//, layer: "presentation", confidence: 0.75, signal: "ui/ directory" },
+  // ── Shared / utils ──
+  { pattern: /\/utils\//, layer: "shared", confidence: 0.7, signal: "utils/ directory" },
+  { pattern: /\/helpers\//, layer: "shared", confidence: 0.7, signal: "helpers/ directory" },
+  { pattern: /\/lib\//, layer: "shared", confidence: 0.6, signal: "lib/ directory" },
+  { pattern: /\/common\//, layer: "shared", confidence: 0.65, signal: "common/ directory" },
+  { pattern: /\/shared\//, layer: "shared", confidence: 0.75, signal: "shared/ directory" },
+  { pattern: /\/constants\//, layer: "shared", confidence: 0.7, signal: "constants/ directory" },
+  // ── CLI-specific (command layer → routing) ──
+  { pattern: /\/commands\//, layer: "routing", confidence: 0.8, signal: "commands/ directory", archetypes: ["cli"] },
+  { pattern: /\/formatters\//, layer: "presentation", confidence: 0.8, signal: "formatters/ directory", archetypes: ["cli"] },
+  { pattern: /\/scanners\//, layer: "services", confidence: 0.8, signal: "scanners/ directory", archetypes: ["cli"] },
+  { pattern: /\/scoring\//, layer: "domain", confidence: 0.8, signal: "scoring/ directory", archetypes: ["cli"] },
+  // ── Serverless-specific ──
+  { pattern: /\/functions\//, layer: "routing", confidence: 0.8, signal: "functions/ directory", archetypes: ["serverless"] },
+  { pattern: /\/lambdas\//, layer: "routing", confidence: 0.85, signal: "lambdas/ directory", archetypes: ["serverless"] },
+  { pattern: /\/layers\//, layer: "shared", confidence: 0.7, signal: "Lambda layers/ directory", archetypes: ["serverless"] }
+];
+var SUFFIX_RULES = [
+  { suffix: ".controller", layer: "routing", confidence: 0.85, signal: "controller suffix" },
+  { suffix: ".route", layer: "routing", confidence: 0.85, signal: "route suffix" },
+  { suffix: ".router", layer: "routing", confidence: 0.85, signal: "router suffix" },
+  { suffix: ".handler", layer: "routing", confidence: 0.8, signal: "handler suffix" },
+  { suffix: ".middleware", layer: "middleware", confidence: 0.85, signal: "middleware suffix" },
+  { suffix: ".guard", layer: "middleware", confidence: 0.85, signal: "guard suffix" },
+  { suffix: ".interceptor", layer: "middleware", confidence: 0.85, signal: "interceptor suffix" },
+  { suffix: ".service", layer: "services", confidence: 0.85, signal: "service suffix" },
+  { suffix: ".usecase", layer: "services", confidence: 0.85, signal: "usecase suffix" },
+  { suffix: ".model", layer: "domain", confidence: 0.8, signal: "model suffix" },
+  { suffix: ".entity", layer: "domain", confidence: 0.85, signal: "entity suffix" },
+  { suffix: ".dto", layer: "domain", confidence: 0.8, signal: "DTO suffix" },
+  { suffix: ".schema", layer: "domain", confidence: 0.75, signal: "schema suffix" },
+  { suffix: ".validator", layer: "domain", confidence: 0.75, signal: "validator suffix" },
+  { suffix: ".repository", layer: "data-access", confidence: 0.9, signal: "repository suffix" },
+  { suffix: ".repo", layer: "data-access", confidence: 0.85, signal: "repo suffix" },
+  { suffix: ".dao", layer: "data-access", confidence: 0.9, signal: "dao suffix" },
+  { suffix: ".migration", layer: "data-access", confidence: 0.85, signal: "migration suffix" },
+  { suffix: ".adapter", layer: "infrastructure", confidence: 0.8, signal: "adapter suffix" },
+  { suffix: ".client", layer: "infrastructure", confidence: 0.75, signal: "client suffix" },
+  { suffix: ".provider", layer: "infrastructure", confidence: 0.7, signal: "provider suffix" },
+  { suffix: ".config", layer: "config", confidence: 0.8, signal: "config suffix" },
+  { suffix: ".component", layer: "presentation", confidence: 0.8, signal: "component suffix" },
+  { suffix: ".page", layer: "presentation", confidence: 0.85, signal: "page suffix" },
+  { suffix: ".view", layer: "presentation", confidence: 0.8, signal: "view suffix" },
+  { suffix: ".layout", layer: "presentation", confidence: 0.85, signal: "layout suffix" },
+  { suffix: ".util", layer: "shared", confidence: 0.7, signal: "util suffix" },
+  { suffix: ".helper", layer: "shared", confidence: 0.7, signal: "helper suffix" },
+  { suffix: ".constant", layer: "shared", confidence: 0.7, signal: "constant suffix" }
+];
+var PACKAGE_LAYER_MAP = {
+  // Routing/controllers
+  "express": "routing",
+  "fastify": "routing",
+  "@nestjs/core": "routing",
+  "hono": "routing",
+  "koa": "routing",
+  "koa-router": "routing",
+  "@hapi/hapi": "routing",
+  "h3": "routing",
+  // Middleware
+  "cors": "middleware",
+  "helmet": "middleware",
+  "passport": "middleware",
+  "express-rate-limit": "middleware",
+  "cookie-parser": "middleware",
+  "body-parser": "middleware",
+  "multer": "middleware",
+  "morgan": "middleware",
+  "compression": "middleware",
+  "express-session": "middleware",
+  // Services / application
+  "bullmq": "services",
+  "bull": "services",
+  "agenda": "services",
+  "pg-boss": "services",
+  "inngest": "services",
+  // Domain / validation
+  "zod": "domain",
+  "joi": "domain",
+  "yup": "domain",
+  "class-validator": "domain",
+  "class-transformer": "domain",
+  "superstruct": "domain",
+  "valibot": "domain",
+  // Data access / ORM
+  "prisma": "data-access",
+  "@prisma/client": "data-access",
+  "drizzle-orm": "data-access",
+  "typeorm": "data-access",
+  "sequelize": "data-access",
+  "knex": "data-access",
+  "pg": "data-access",
+  "mysql2": "data-access",
+  "mongodb": "data-access",
+  "mongoose": "data-access",
+  "ioredis": "data-access",
+  "redis": "data-access",
+  "better-sqlite3": "data-access",
+  "kysely": "data-access",
+  "@mikro-orm/core": "data-access",
+  // Infrastructure
+  "@aws-sdk/client-s3": "infrastructure",
+  "@aws-sdk/client-sqs": "infrastructure",
+  "@aws-sdk/client-sns": "infrastructure",
+  "@aws-sdk/client-ses": "infrastructure",
+  "@aws-sdk/client-lambda": "infrastructure",
+  "@google-cloud/storage": "infrastructure",
+  "@azure/storage-blob": "infrastructure",
+  "nodemailer": "infrastructure",
+  "@sendgrid/mail": "infrastructure",
+  "stripe": "infrastructure",
+  "kafkajs": "infrastructure",
+  "amqplib": "infrastructure",
+  // Presentation
+  "react": "presentation",
+  "react-dom": "presentation",
+  "vue": "presentation",
+  "@angular/core": "presentation",
+  "svelte": "presentation",
+  // Shared
+  "lodash": "shared",
+  "dayjs": "shared",
+  "date-fns": "shared",
+  "uuid": "shared",
+  "nanoid": "shared",
+  // Testing
+  "vitest": "testing",
+  "jest": "testing",
+  "mocha": "testing",
+  "@playwright/test": "testing",
+  "cypress": "testing",
+  "supertest": "testing",
+  // Observability → infrastructure
+  "@sentry/node": "infrastructure",
+  "@opentelemetry/api": "infrastructure",
+  "pino": "infrastructure",
+  "winston": "infrastructure",
+  "dd-trace": "infrastructure"
+};
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs", ".svelte", ".vue"]);
+var IGNORE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".nuxt", ".output", ".svelte-kit", "coverage", ".vibgrate"]);
+async function walkSourceFiles(rootDir, cache) {
+  if (cache) {
+    const entries = await cache.walkDir(rootDir);
+    return entries.filter((e) => {
+      if (!e.isFile) return false;
+      const name = path14.basename(e.absPath);
+      if (name.startsWith(".") && name !== ".") return false;
+      const ext = path14.extname(name);
+      return SOURCE_EXTENSIONS.has(ext);
+    }).map((e) => e.relPath);
+  }
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await fs5.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      const fullPath = path14.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!IGNORE_DIRS.has(entry.name)) {
+          await walk(fullPath);
+        }
+      } else if (entry.isFile()) {
+        const ext = path14.extname(entry.name);
+        if (SOURCE_EXTENSIONS.has(ext)) {
+          files.push(path14.relative(rootDir, fullPath));
+        }
+      }
+    }
+  }
+  await walk(rootDir);
+  return files;
+}
+function classifyFile(filePath, archetype) {
+  const normalised = filePath.replace(/\\/g, "/");
+  let bestMatch = null;
+  for (const rule of PATH_RULES) {
+    if (rule.archetypes && rule.archetypes.length > 0 && !rule.archetypes.includes(archetype)) {
+      continue;
+    }
+    if (rule.pattern.test(normalised)) {
+      const boost = rule.archetypes ? 0.05 : 0;
+      const adjustedConfidence = Math.min(rule.confidence + boost, 1);
+      if (!bestMatch || adjustedConfidence > bestMatch.confidence) {
+        bestMatch = { layer: rule.layer, confidence: adjustedConfidence, signal: rule.signal };
+      }
+    }
+  }
+  if (!bestMatch || bestMatch.confidence < 0.7) {
+    const baseName = path14.basename(filePath, path14.extname(filePath));
+    const cleanBase = baseName.replace(/\.(test|spec)$/, "");
+    for (const rule of SUFFIX_RULES) {
+      if (cleanBase.endsWith(rule.suffix)) {
+        if (!bestMatch || rule.confidence > bestMatch.confidence) {
+          bestMatch = { layer: rule.layer, confidence: rule.confidence, signal: rule.signal };
+        }
+      }
+    }
+  }
+  if (bestMatch) {
+    return {
+      filePath,
+      layer: bestMatch.layer,
+      confidence: bestMatch.confidence,
+      signals: [bestMatch.signal]
+    };
+  }
+  return null;
+}
+function computeLayerDrift(packages) {
+  if (packages.length === 0) {
+    return { score: 100, riskLevel: "low" };
+  }
+  let current = 0;
+  let oneBehind = 0;
+  let twoPlusBehind = 0;
+  let unknown = 0;
+  for (const pkg2 of packages) {
+    if (pkg2.majorsBehind === null) {
+      unknown++;
+    } else if (pkg2.majorsBehind === 0) {
+      current++;
+    } else if (pkg2.majorsBehind === 1) {
+      oneBehind++;
+    } else {
+      twoPlusBehind++;
+    }
+  }
+  const known = current + oneBehind + twoPlusBehind;
+  if (known === 0) return { score: 100, riskLevel: "low" };
+  const currentPct = current / known;
+  const onePct = oneBehind / known;
+  const twoPct = twoPlusBehind / known;
+  const score = Math.round(Math.max(0, Math.min(100, currentPct * 100 - onePct * 10 - twoPct * 40)));
+  const riskLevel = score >= 70 ? "low" : score >= 40 ? "moderate" : "high";
+  return { score, riskLevel };
+}
+function mapToolingToLayers(tooling, services, depsByLayer) {
+  const layerTooling = /* @__PURE__ */ new Map();
+  const layerServices = /* @__PURE__ */ new Map();
+  const pkgLayerLookup = /* @__PURE__ */ new Map();
+  for (const [layer, packages] of depsByLayer) {
+    for (const pkg2 of packages) {
+      pkgLayerLookup.set(pkg2, layer);
+    }
+  }
+  if (tooling) {
+    for (const [, items] of Object.entries(tooling)) {
+      for (const item of items) {
+        const layer = pkgLayerLookup.get(item.package) ?? PACKAGE_LAYER_MAP[item.package] ?? "shared";
+        if (!layerTooling.has(layer)) layerTooling.set(layer, []);
+        const existing = layerTooling.get(layer);
+        if (!existing.some((t) => t.package === item.package)) {
+          existing.push(item);
+        }
+      }
+    }
+  }
+  if (services) {
+    for (const [, items] of Object.entries(services)) {
+      for (const item of items) {
+        const layer = pkgLayerLookup.get(item.package) ?? PACKAGE_LAYER_MAP[item.package] ?? "infrastructure";
+        if (!layerServices.has(layer)) layerServices.set(layer, []);
+        const existing = layerServices.get(layer);
+        if (!existing.some((s) => s.package === item.package)) {
+          existing.push(item);
+        }
+      }
+    }
+  }
+  return { layerTooling, layerServices };
+}
+async function scanArchitecture(rootDir, projects, tooling, services, cache) {
+  const { archetype, confidence: archetypeConfidence } = detectArchetype(projects);
+  const sourceFiles = await walkSourceFiles(rootDir, cache);
+  const classifications = [];
+  let unclassified = 0;
+  for (const file of sourceFiles) {
+    const classification = classifyFile(file, archetype);
+    if (classification) {
+      classifications.push(classification);
+    } else {
+      unclassified++;
+    }
+  }
+  const allDeps = /* @__PURE__ */ new Map();
+  for (const p of projects) {
+    for (const d of p.dependencies) {
+      if (!allDeps.has(d.package)) {
+        allDeps.set(d.package, d);
+      }
+    }
+  }
+  const depsByLayer = /* @__PURE__ */ new Map();
+  for (const [pkg2] of allDeps) {
+    const layer = PACKAGE_LAYER_MAP[pkg2];
+    if (layer) {
+      if (!depsByLayer.has(layer)) depsByLayer.set(layer, /* @__PURE__ */ new Set());
+      depsByLayer.get(layer).add(pkg2);
+    }
+  }
+  const { layerTooling, layerServices } = mapToolingToLayers(tooling, services, depsByLayer);
+  const ALL_LAYERS = [
+    "routing",
+    "middleware",
+    "services",
+    "domain",
+    "data-access",
+    "infrastructure",
+    "presentation",
+    "config",
+    "testing",
+    "shared"
+  ];
+  const layerFileCounts = /* @__PURE__ */ new Map();
+  for (const c of classifications) {
+    layerFileCounts.set(c.layer, (layerFileCounts.get(c.layer) ?? 0) + 1);
+  }
+  const layers = [];
+  for (const layer of ALL_LAYERS) {
+    const fileCount = layerFileCounts.get(layer) ?? 0;
+    const layerPkgs = depsByLayer.get(layer) ?? /* @__PURE__ */ new Set();
+    const tech = layerTooling.get(layer) ?? [];
+    const svc = layerServices.get(layer) ?? [];
+    if (fileCount === 0 && layerPkgs.size === 0 && tech.length === 0 && svc.length === 0) {
+      continue;
+    }
+    const packages = [];
+    for (const pkg2 of layerPkgs) {
+      const dep = allDeps.get(pkg2);
+      if (dep) {
+        packages.push({
+          name: dep.package,
+          version: dep.resolvedVersion,
+          latestStable: dep.latestStable,
+          majorsBehind: dep.majorsBehind,
+          drift: dep.drift
+        });
+      }
+    }
+    const { score, riskLevel } = computeLayerDrift(packages);
+    layers.push({
+      layer,
+      fileCount,
+      driftScore: score,
+      riskLevel,
+      techStack: tech,
+      services: svc,
+      packages
+    });
+  }
+  const LAYER_ORDER = {
+    "presentation": 0,
+    "routing": 1,
+    "middleware": 2,
+    "services": 3,
+    "domain": 4,
+    "data-access": 5,
+    "infrastructure": 6,
+    "config": 7,
+    "shared": 8,
+    "testing": 9
+  };
+  layers.sort((a, b) => (LAYER_ORDER[a.layer] ?? 99) - (LAYER_ORDER[b.layer] ?? 99));
+  return {
+    archetype,
+    archetypeConfidence,
+    layers,
+    totalClassified: classifications.length,
+    unclassified
+  };
+}
+
 // src/commands/scan.ts
 async function runScan(rootDir, opts) {
   const scanStart = Date.now();
   const config = await loadConfig(rootDir);
   const sem = new Semaphore(opts.concurrency);
   const npmCache = new NpmCache(rootDir, sem);
+  const fileCache = new FileCache();
   const scanners = config.scanners;
   let filesScanned = 0;
   const progress = new ScanProgress(rootDir);
@@ -3933,7 +4756,8 @@ async function runScan(rootDir, opts) {
       ...scanners?.tsModernity?.enabled !== false ? [{ id: "ts", label: "TypeScript modernity" }] : [],
       ...scanners?.fileHotspots?.enabled !== false ? [{ id: "hotspots", label: "File hotspots" }] : [],
       ...scanners?.dependencyGraph?.enabled !== false ? [{ id: "depgraph", label: "Dependency graph" }] : [],
-      ...scanners?.dependencyRisk?.enabled !== false ? [{ id: "deprisk", label: "Dependency risk" }] : []
+      ...scanners?.dependencyRisk?.enabled !== false ? [{ id: "deprisk", label: "Dependency risk" }] : [],
+      ...scanners?.architecture?.enabled !== false ? [{ id: "architecture", label: "Architecture layers" }] : []
     ] : [],
     { id: "drift", label: "Computing drift score" },
     { id: "findings", label: "Generating findings" }
@@ -3945,7 +4769,7 @@ async function runScan(rootDir, opts) {
   const vcsDetail = vcs.type !== "unknown" ? `${vcs.type}${vcs.branch ? ` ${vcs.branch}` : ""}${vcs.shortSha ? ` @ ${vcs.shortSha}` : ""}` : "none detected";
   progress.completeStep("vcs", vcsDetail);
   progress.startStep("node");
-  const nodeProjects = await scanNodeProjects(rootDir, npmCache);
+  const nodeProjects = await scanNodeProjects(rootDir, npmCache, fileCache);
   for (const p of nodeProjects) {
     progress.addDependencies(p.dependencies.length);
     progress.addFrameworks(p.frameworks.length);
@@ -3954,7 +4778,7 @@ async function runScan(rootDir, opts) {
   progress.addProjects(nodeProjects.length);
   progress.completeStep("node", `${nodeProjects.length} project${nodeProjects.length !== 1 ? "s" : ""}`, nodeProjects.length);
   progress.startStep("dotnet");
-  const dotnetProjects = await scanDotnetProjects(rootDir);
+  const dotnetProjects = await scanDotnetProjects(rootDir, fileCache);
   for (const p of dotnetProjects) {
     progress.addDependencies(p.dependencies.length);
     progress.addFrameworks(p.frameworks.length);
@@ -3976,7 +4800,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.platformMatrix?.enabled !== false) {
       progress.startStep("platform");
       scannerTasks.push(
-        scanPlatformMatrix(rootDir).then((result) => {
+        scanPlatformMatrix(rootDir, fileCache).then((result) => {
           extended.platformMatrix = result;
           const nativeCount = result.nativeModules.length;
           const dockerCount = result.dockerBaseImages.length;
@@ -4025,7 +4849,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.securityPosture?.enabled !== false) {
       progress.startStep("security");
       scannerTasks.push(
-        scanSecurityPosture(rootDir).then((result) => {
+        scanSecurityPosture(rootDir, fileCache).then((result) => {
           extended.securityPosture = result;
           const secDetail = result.lockfilePresent ? `lockfile \u2714${result.gitignoreCoversEnv ? " \xB7 .env \u2714" : " \xB7 .env \u2716"}` : "no lockfile";
           progress.completeStep("security", secDetail);
@@ -4035,7 +4859,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.buildDeploy?.enabled !== false) {
       progress.startStep("build");
       scannerTasks.push(
-        scanBuildDeploy(rootDir).then((result) => {
+        scanBuildDeploy(rootDir, fileCache).then((result) => {
           extended.buildDeploy = result;
           const bdParts = [];
           if (result.ci.length > 0) bdParts.push(result.ci.join(", "));
@@ -4047,7 +4871,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.tsModernity?.enabled !== false) {
       progress.startStep("ts");
       scannerTasks.push(
-        scanTsModernity(rootDir).then((result) => {
+        scanTsModernity(rootDir, fileCache).then((result) => {
           extended.tsModernity = result;
           const tsParts = [];
           if (result.typescriptVersion) tsParts.push(`v${result.typescriptVersion}`);
@@ -4060,7 +4884,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.fileHotspots?.enabled !== false) {
       progress.startStep("hotspots");
       scannerTasks.push(
-        scanFileHotspots(rootDir).then((result) => {
+        scanFileHotspots(rootDir, fileCache).then((result) => {
           extended.fileHotspots = result;
           progress.completeStep("hotspots", `${result.totalFiles} files`, result.totalFiles);
         })
@@ -4069,7 +4893,7 @@ async function runScan(rootDir, opts) {
     if (scanners?.dependencyGraph?.enabled !== false) {
       progress.startStep("depgraph");
       scannerTasks.push(
-        scanDependencyGraph(rootDir).then((result) => {
+        scanDependencyGraph(rootDir, fileCache).then((result) => {
           extended.dependencyGraph = result;
           const dgDetail = result.lockfileType ? `${result.lockfileType} \xB7 ${result.totalUnique} unique` : "no lockfile";
           progress.completeStep("depgraph", dgDetail, result.totalUnique);
@@ -4090,6 +4914,23 @@ async function runScan(rootDir, opts) {
       );
     }
     await Promise.all(scannerTasks);
+    if (scanners?.architecture?.enabled !== false) {
+      progress.startStep("architecture");
+      extended.architecture = await scanArchitecture(
+        rootDir,
+        allProjects,
+        extended.toolingInventory,
+        extended.serviceDependencies,
+        fileCache
+      );
+      const arch = extended.architecture;
+      const layerCount = arch.layers.filter((l) => l.fileCount > 0).length;
+      progress.completeStep(
+        "architecture",
+        `${arch.archetype} \xB7 ${layerCount} layer${layerCount !== 1 ? "s" : ""} \xB7 ${arch.totalClassified} files`,
+        layerCount
+      );
+    }
   }
   progress.startStep("drift");
   const drift = computeDriftScore(allProjects);
@@ -4106,6 +4947,7 @@ async function runScan(rootDir, opts) {
   if (noteCount > 0) findingParts.push(`${noteCount} note${noteCount !== 1 ? "s" : ""}`);
   progress.completeStep("findings", findingParts.join(", ") || "none");
   progress.finish();
+  fileCache.clear();
   if (allProjects.length === 0) {
     console.log(chalk5.yellow("No projects found."));
   }
@@ -4122,7 +4964,7 @@ async function runScan(rootDir, opts) {
     schemaVersion: "1.0",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     vibgrateVersion: VERSION,
-    rootPath: path14.basename(rootDir),
+    rootPath: path15.basename(rootDir),
     ...vcs.type !== "unknown" ? { vcs } : {},
     projects: allProjects,
     drift,
@@ -4132,7 +4974,7 @@ async function runScan(rootDir, opts) {
     filesScanned
   };
   if (opts.baseline) {
-    const baselinePath = path14.resolve(opts.baseline);
+    const baselinePath = path15.resolve(opts.baseline);
     if (await pathExists(baselinePath)) {
       try {
         const baseline = await readJsonFile(baselinePath);
@@ -4143,15 +4985,15 @@ async function runScan(rootDir, opts) {
       }
     }
   }
-  const vibgrateDir = path14.join(rootDir, ".vibgrate");
+  const vibgrateDir = path15.join(rootDir, ".vibgrate");
   await ensureDir(vibgrateDir);
-  await writeJsonFile(path14.join(vibgrateDir, "scan_result.json"), artifact);
+  await writeJsonFile(path15.join(vibgrateDir, "scan_result.json"), artifact);
   for (const project of allProjects) {
     if (project.drift && project.path) {
-      const projectDir = path14.resolve(rootDir, project.path);
-      const projectVibgrateDir = path14.join(projectDir, ".vibgrate");
+      const projectDir = path15.resolve(rootDir, project.path);
+      const projectVibgrateDir = path15.join(projectDir, ".vibgrate");
       await ensureDir(projectVibgrateDir);
-      await writeJsonFile(path14.join(projectVibgrateDir, "project_score.json"), {
+      await writeJsonFile(path15.join(projectVibgrateDir, "project_score.json"), {
         projectId: project.projectId,
         name: project.name,
         type: project.type,
@@ -4168,7 +5010,7 @@ async function runScan(rootDir, opts) {
   if (opts.format === "json") {
     const jsonStr = JSON.stringify(artifact, null, 2);
     if (opts.out) {
-      await writeTextFile(path14.resolve(opts.out), jsonStr);
+      await writeTextFile(path15.resolve(opts.out), jsonStr);
       console.log(chalk5.green("\u2714") + ` JSON written to ${opts.out}`);
     } else {
       console.log(jsonStr);
@@ -4177,7 +5019,7 @@ async function runScan(rootDir, opts) {
     const sarif = formatSarif(artifact);
     const sarifStr = JSON.stringify(sarif, null, 2);
     if (opts.out) {
-      await writeTextFile(path14.resolve(opts.out), sarifStr);
+      await writeTextFile(path15.resolve(opts.out), sarifStr);
       console.log(chalk5.green("\u2714") + ` SARIF written to ${opts.out}`);
     } else {
       console.log(sarifStr);
@@ -4186,7 +5028,7 @@ async function runScan(rootDir, opts) {
     const text = formatText(artifact);
     console.log(text);
     if (opts.out) {
-      await writeTextFile(path14.resolve(opts.out), text);
+      await writeTextFile(path15.resolve(opts.out), text);
     }
   }
   return artifact;
@@ -4245,7 +5087,7 @@ async function autoPush(artifact, rootDir, opts) {
   }
 }
 var scanCommand = new Command3("scan").description("Scan a project for upgrade drift").argument("[path]", "Path to scan", ".").option("--out <file>", "Output file path").option("--format <format>", "Output format (text|json|sarif)", "text").option("--fail-on <level>", "Fail on warn or error").option("--baseline <file>", "Compare against baseline").option("--changed-only", "Only scan changed files").option("--concurrency <n>", "Max concurrent npm calls", "8").option("--push", "Auto-push results to Vibgrate API after scan").option("--dsn <dsn>", "DSN token for push (or use VIBGRATE_DSN env)").option("--region <region>", "Override data residency region for push (us, eu)").option("--strict", "Fail on push errors").action(async (targetPath, opts) => {
-  const rootDir = path14.resolve(targetPath);
+  const rootDir = path15.resolve(targetPath);
   if (!await pathExists(rootDir)) {
     console.error(chalk5.red(`Path does not exist: ${rootDir}`));
     process.exit(1);