@archpilotlabs/archpilot 0.0.10 → 0.0.11

package/dist/archpilot-cli.js

@@ -215333,6 +215333,14 @@ function usesPythonImportParser(adapter) {
 function supportsDependencyImportParsing(adapter) {
   return usesTypeScriptParser(adapter) || usesJavaImportParser(adapter) || usesPhpImportParser(adapter) || usesGoImportParser(adapter) || usesPythonImportParser(adapter);
 }
+async function pathExists4(targetPath) {
+  try {
+    await import_node_fs8.promises.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function readTextFileIfExists2(filePath) {
   try {
     return await import_node_fs8.promises.readFile(filePath, { encoding: "utf8" });
@@ -215352,7 +215360,7 @@ async function readPackageName(packageJsonPath) {
     return void 0;
   }
 }
-async function buildWorkspacePackageAliasMap(moduleRoots) {
+async function buildWorkspacePackageAliasMap(workspaceRoot, moduleRoots) {
   const aliases = [];
   for (const [moduleId, moduleRoot] of [...moduleRoots.entries()].sort(
     ([left], [right]) => left.localeCompare(right)
@@ -215363,6 +215371,7 @@ async function buildWorkspacePackageAliasMap(moduleRoots) {
     }
     aliases.push({ packageName, moduleId, moduleRoot });
   }
+  aliases.push(...await buildTsConfigPathAliasMap(workspaceRoot, moduleRoots));
   return aliases.sort((left, right) => {
     const lengthCompare = right.packageName.length - left.packageName.length;
     if (lengthCompare !== 0) {
@@ -215371,6 +215380,63 @@ async function buildWorkspacePackageAliasMap(moduleRoots) {
     return left.packageName.localeCompare(right.packageName);
   });
 }
+async function buildTsConfigPathAliasMap(workspaceRoot, moduleRoots) {
+  const contents = await readTextFileIfExists2(path8.join(workspaceRoot, "tsconfig.json"));
+  if (!contents) {
+    return [];
+  }
+  let paths;
+  try {
+    const parsed = JSON.parse(contents);
+    paths = parsed.compilerOptions?.paths;
+  } catch {
+    return [];
+  }
+  if (!paths) {
+    return [];
+  }
+  const aliases = [];
+  for (const [aliasPattern, targetPatterns] of Object.entries(paths).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    if (!Array.isArray(targetPatterns)) {
+      continue;
+    }
+    const aliasPrefix = aliasPattern.replace(/\/\*$/u, "");
+    if (aliasPrefix.length === 0) {
+      continue;
+    }
+    for (const targetPattern of targetPatterns) {
+      if (typeof targetPattern !== "string" || targetPattern.trim().length === 0) {
+        continue;
+      }
+      const isWildcard = /\/\*$/u.test(aliasPattern) && /\/\*$/u.test(targetPattern);
+      const normalizedTarget = normalizePath2(targetPattern).replace(/\/\*$/u, "");
+      const absoluteTarget = path8.join(workspaceRoot, ...normalizedTarget.split("/"));
+      const moduleEntry = [...moduleRoots.entries()].filter(([, moduleRoot2]) => isPathInsideOrEqual(absoluteTarget, moduleRoot2)).sort((left, right) => right[1].length - left[1].length || left[0].localeCompare(right[0]))[0];
+      if (!moduleEntry) {
+        continue;
+      }
+      const [moduleId, moduleRoot] = moduleEntry;
+      if (isWildcard) {
+        aliases.push({
+          packageName: aliasPrefix,
+          moduleId,
+          moduleRoot,
+          targetRoot: absoluteTarget
+        });
+        continue;
+      }
+      aliases.push({
+        packageName: aliasPrefix,
+        moduleId,
+        moduleRoot,
+        targetFile: absoluteTarget
+      });
+    }
+  }
+  return aliases;
+}
 function validateDependencyModuleRules(moduleName, value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new DependencyRulesConfigError(
@@ -215430,8 +215496,44 @@ async function readDependencyRulesConfig(workspaceRoot) {
   }, {});
   return { modules };
 }
-async function findModuleRoots(workspaceRoot, modulesRootRelativePath = "src/modules") {
-  return discoverModuleRoots(workspaceRoot, modulesRootRelativePath);
+async function findModuleRoots(workspaceRoot, modulesRootRelativePath = "src/modules", architectureContract) {
+  const discoveredModuleRoots = await discoverModuleRoots(
+    workspaceRoot,
+    modulesRootRelativePath
+  );
+  const moduleRoots = /* @__PURE__ */ new Map();
+  const registryEntries = architectureContract?.modules ? Object.entries(architectureContract.modules).sort(
+    ([left], [right]) => left.localeCompare(right)
+  ) : [];
+  for (const [moduleName, moduleReference] of registryEntries) {
+    const configuredPath = moduleReference.path;
+    if (!configuredPath || typeof configuredPath !== "string") {
+      continue;
+    }
+    const normalizedConfiguredPath = normalizePath2(configuredPath);
+    if (/\.[a-z0-9]+$/iu.test(normalizedConfiguredPath)) {
+      continue;
+    }
+    const absolutePath = path8.join(
+      workspaceRoot,
+      ...normalizedConfiguredPath.split("/")
+    );
+    try {
+      const stats = await import_node_fs8.promises.stat(absolutePath);
+      if (stats.isDirectory()) {
+        moduleRoots.set(moduleName, absolutePath);
+      }
+    } catch {
+    }
+  }
+  for (const [moduleName, moduleRoot] of discoveredModuleRoots.entries()) {
+    if (!moduleRoots.has(moduleName)) {
+      moduleRoots.set(moduleName, moduleRoot);
+    }
+  }
+  return new Map(
+    [...moduleRoots.entries()].sort(([left], [right]) => left.localeCompare(right))
+  );
 }
 async function buildExplicitStandaloneModulePathMap(workspaceRoot, architectureContract) {
   const moduleRegistry = architectureContract?.modules && typeof architectureContract.modules === "object" && !Array.isArray(architectureContract.modules) ? architectureContract.modules : void 0;
@@ -215857,7 +215959,14 @@ async function resolveWorkspacePackageImportPath(importSpecifier, workspacePacka
   const packageAlias = workspacePackageAliases.map((alias2) => ({
     alias: alias2,
     remainder: resolvePackageAliasRemainder(alias2.packageName, importSpecifier)
-  })).find(
+  })).sort((left, right) => {
+    const leftCanResolveRemainder = left.remainder !== void 0 && left.remainder.length > 0 && left.alias.targetRoot !== void 0;
+    const rightCanResolveRemainder = right.remainder !== void 0 && right.remainder.length > 0 && right.alias.targetRoot !== void 0;
+    if (leftCanResolveRemainder !== rightCanResolveRemainder) {
+      return leftCanResolveRemainder ? -1 : 1;
+    }
+    return 0;
+  }).find(
     (candidate) => candidate.remainder !== void 0
   );
   if (!packageAlias) {
@@ -215865,7 +215974,13 @@ async function resolveWorkspacePackageImportPath(importSpecifier, workspacePacka
   }
   const { alias, remainder } = packageAlias;
   if (remainder.length === 0) {
-    return resolveImportPath(alias.moduleRoot, adapter);
+    return resolveImportPath(alias.targetFile ?? alias.targetRoot ?? alias.moduleRoot, adapter);
+  }
+  if (alias.targetRoot) {
+    return resolveImportPath(
+      path8.join(alias.targetRoot, ...remainder.split("/").filter((segment) => segment.length > 0)),
+      adapter
+    );
   }
   return void 0;
 }
@@ -215970,7 +216085,10 @@ async function resolveCrossModuleImport(workspaceRoot, modulesRootRelativePath,
   const indexEntrypointCandidates = adapter.dependencyParsingFileExtensions.map(
     (extension) => `index${extension}`
   );
-  const isPublicImport = indexEntrypointCandidates.includes(targetSubPath) || adapter.publicEntrypointDirectoryNames.some(
+  const nestedIndexEntrypointCandidates = adapter.dependencyParsingFileExtensions.flatMap(
+    (extension) => [`src/index${extension}`, `public/index${extension}`]
+  );
+  const isPublicImport = indexEntrypointCandidates.includes(targetSubPath) || nestedIndexEntrypointCandidates.includes(targetSubPath) || adapter.publicEntrypointDirectoryNames.some(
     (dirName) => targetSubPath.startsWith(`${dirName}/`)
   );
   return {
@@ -216248,9 +216366,87 @@ function isImportWithinPublicEntrypoints(resolvedTargetRelativePath, publicEntry
   }
   return false;
 }
-function buildModuleIndexEntrypointPath(modulesRootRelativePath, moduleName, adapter) {
-  const entrypointFileName = adapter.scaffoldingDefaults?.moduleIndexFileName ?? "index.ts";
-  return normalizePath2(`${modulesRootRelativePath}/${moduleName}/${entrypointFileName}`);
+async function filterExistingPublicEntrypoints(workspaceRoot, publicEntrypoints) {
+  const existingEntrypoints = [];
+  for (const publicEntrypoint of normalizePathList([...publicEntrypoints])) {
+    const absolutePath = path8.join(workspaceRoot, ...publicEntrypoint.split("/"));
+    if (await pathExists4(absolutePath)) {
+      existingEntrypoints.push(publicEntrypoint);
+    }
+  }
+  return existingEntrypoints;
+}
+async function inferExistingPublicEntrypointsFromModuleRoot(workspaceRoot, moduleRoot) {
+  if (!moduleRoot) {
+    return [];
+  }
+  const candidateSubpaths = [
+    "index.ts",
+    "index.tsx",
+    "index.js",
+    "index.jsx",
+    "src/index.ts",
+    "src/index.tsx",
+    "src/index.js",
+    "src/index.jsx",
+    "public/index.ts",
+    "public/index.tsx",
+    "public/index.js",
+    "public/index.jsx"
+  ];
+  const existingEntrypoints = [];
+  for (const candidateSubpath of candidateSubpaths) {
+    const candidatePath = path8.join(moduleRoot, ...candidateSubpath.split("/"));
+    if (await pathExists4(candidatePath)) {
+      existingEntrypoints.push(
+        normalizePath2(path8.relative(workspaceRoot, candidatePath))
+      );
+    }
+  }
+  return existingEntrypoints.sort((left, right) => left.localeCompare(right));
+}
+async function resolveModulePublicEntrypoints(workspaceRoot, architectureContract, moduleName, targetContract, moduleRoots) {
+  const registryPublicEntrypoints = architectureContract.modules[moduleName]?.publicEntrypoints ?? [];
+  const explicitPublicEntrypoints = sortUnique2([
+    ...registryPublicEntrypoints,
+    ...targetContract.publicEntrypoints
+  ]);
+  const existingExplicitEntrypoints = await filterExistingPublicEntrypoints(
+    workspaceRoot,
+    explicitPublicEntrypoints
+  );
+  if (existingExplicitEntrypoints.length > 0) {
+    return existingExplicitEntrypoints;
+  }
+  return inferExistingPublicEntrypointsFromModuleRoot(
+    workspaceRoot,
+    moduleRoots.get(moduleName)
+  );
+}
+function labelPublicEntrypoint(publicEntrypoint) {
+  const normalizedEntrypoint = normalizePath2(publicEntrypoint);
+  const fileName = normalizedEntrypoint.split("/").at(-1) ?? "";
+  return /^index\.[cm]?[jt]sx?$/iu.test(fileName) ? `${fileName} public entrypoint` : "public entrypoint";
+}
+function describePublicEntrypointTargets(publicEntrypoints) {
+  if (publicEntrypoints.length <= 1) {
+    return publicEntrypoints[0] ?? "unknown public entrypoint";
+  }
+  return publicEntrypoints.join(", ");
+}
+async function describeModulePublicImportGuidance(workspaceRoot, moduleName, moduleRoots) {
+  const moduleRoot = moduleRoots.get(moduleName);
+  const inferredEntrypoints = await inferExistingPublicEntrypointsFromModuleRoot(
+    workspaceRoot,
+    moduleRoot
+  );
+  if (inferredEntrypoints.length > 0) {
+    return `Use the public entrypoint at ${describePublicEntrypointTargets(inferredEntrypoints)} instead.`;
+  }
+  if (moduleRoot) {
+    return `Use an existing public entrypoint under ${normalizePath2(path8.relative(workspaceRoot, moduleRoot))} instead.`;
+  }
+  return "Use an existing target module public entrypoint instead.";
 }
 function buildActualImportedModuleSetBySource(imports, registeredModuleIds) {
   const bySource = /* @__PURE__ */ new Map();
@@ -216302,12 +216498,19 @@ function buildInboundDependencyMap(bySource, moduleIds) {
 async function buildDependencyGraphSummary(workspaceRoot, architectureContract, options) {
   const modulesRoot = options?.modulesRootRelativePath ?? resolveModulesRootFromContract(architectureContract);
   const adapter = resolvePrimaryAdapterFromContract(architectureContract);
-  const moduleRoots = await findModuleRoots(workspaceRoot, modulesRoot);
+  const moduleRoots = await findModuleRoots(
+    workspaceRoot,
+    modulesRoot,
+    architectureContract
+  );
   const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(
     workspaceRoot,
     architectureContract
   );
-  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(
+    workspaceRoot,
+    moduleRoots
+  );
   const moduleIds = sortUnique2([...moduleRoots.keys(), ...explicitStandaloneModuleByPath.values()]);
   const registeredModuleIds = new Set(moduleIds);
   const imports = await collectCrossModuleImports(
@@ -216386,12 +216589,19 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
   }
   const modulesRoot = options.modulesRootRelativePath ?? resolveModulesRootFromContract(architectureContract);
   const adapter = resolvePrimaryAdapterFromContract(architectureContract);
-  const moduleRoots = await findModuleRoots(workspaceRoot, modulesRoot);
+  const moduleRoots = await findModuleRoots(
+    workspaceRoot,
+    modulesRoot,
+    architectureContract
+  );
   const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(
     workspaceRoot,
     architectureContract
   );
-  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(
+    workspaceRoot,
+    moduleRoots
+  );
   const imports = await collectCrossModuleImports(
     workspaceRoot,
     modulesRoot,
@@ -216448,6 +216658,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
             ),
             filePath: dependencyImport.sourceFileRelativePath,
             line: dependencyImport.line,
+            importSpecifier: dependencyImport.importSpecifier,
             findingType: "module-dependency",
             module: dependencyImport.sourceModule,
             target: dependencyImport.targetModule
@@ -216470,6 +216681,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
           ),
           filePath: dependencyImport.sourceFileRelativePath,
           line: dependencyImport.line,
+          importSpecifier: dependencyImport.importSpecifier,
           findingType: "module-dependency",
           module: dependencyImport.sourceModule,
           target: dependencyImport.targetModule
@@ -216563,6 +216775,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
             ),
             filePath: dependencyImport.sourceFileRelativePath,
             line: dependencyImport.line,
+            importSpecifier: dependencyImport.importSpecifier,
             findingType: "module-dependency",
             module: dependencyImport.sourceModule,
             target: dependencyImport.targetModule
@@ -216570,42 +216783,31 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
         }
         continue;
       }
-      if (targetContract.contract.publicEntrypoints.length > 0 && !isImportWithinPublicEntrypoints(
-        dependencyImport.resolvedTargetRelativePath,
-        targetContract.contract.publicEntrypoints
-      )) {
-        const expectedEntrypoint = targetContract.contract.publicEntrypoints[0] ?? buildModuleIndexEntrypointPath(modulesRoot, dependencyImport.targetModule, adapter);
-        const publicEntrypointLabel = expectedEntrypoint.endsWith("/index.ts") ? "index.ts public entrypoint" : "public entrypoint";
-        failures.push({
-          result: makeValidationResult(
-            "AP-DEP-005",
-            "error",
-            false,
-            `Module '${dependencyImport.sourceModule}' must import module '${dependencyImport.targetModule}' via its ${publicEntrypointLabel}: ${expectedEntrypoint}.`,
-            {
-              findingType: "module-dependency",
-              module: dependencyImport.sourceModule,
-              target: dependencyImport.targetModule
-            }
-          ),
-          filePath: dependencyImport.sourceFileRelativePath,
-          line: dependencyImport.line,
-          findingType: "module-dependency",
-          module: dependencyImport.sourceModule,
-          target: dependencyImport.targetModule
-        });
+      const publicEntrypoints = await resolveModulePublicEntrypoints(
+        workspaceRoot,
+        architectureContract,
+        dependencyImport.targetModule,
+        targetContract.contract,
+        moduleRoots
+      );
+      if (publicEntrypoints.length === 0) {
+        continue;
+      }
+      if (options.suppressPublicSurfaceFailuresForNonPublicImports === true && !dependencyImport.isPublicImport) {
         continue;
       }
-      if (targetContract.contract.publicEntrypoints.length === 0 && !isImportWithinPublicEntrypoints(
+      if (!isImportWithinPublicEntrypoints(
         dependencyImport.resolvedTargetRelativePath,
-        targetContract.contract.publicEntrypoints
+        publicEntrypoints
       )) {
+        const publicEntrypointLabel = labelPublicEntrypoint(publicEntrypoints[0] ?? "");
+        const expectedEntrypoint = describePublicEntrypointTargets(publicEntrypoints);
         failures.push({
           result: makeValidationResult(
             "AP-DEP-005",
             "error",
             false,
-            `Module '${dependencyImport.sourceModule}' imports a non-public path from module '${dependencyImport.targetModule}': ${dependencyImport.resolvedTargetRelativePath}`,
+            `Module '${dependencyImport.sourceModule}' must import module '${dependencyImport.targetModule}' via its ${publicEntrypointLabel}: ${expectedEntrypoint}.`,
             {
               findingType: "module-dependency",
               module: dependencyImport.sourceModule,
@@ -216614,6 +216816,7 @@ async function validateDependencyContractBoundaries(workspaceRoot, architectureC
           ),
           filePath: dependencyImport.sourceFileRelativePath,
           line: dependencyImport.line,
+          importSpecifier: dependencyImport.importSpecifier,
           findingType: "module-dependency",
           module: dependencyImport.sourceModule,
           target: dependencyImport.targetModule
@@ -216718,12 +216921,19 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
   const parsedArchitectureContract = await loadArchitectureContract(workspaceRoot);
   const adapter = resolvePrimaryAdapterFromContract(parsedArchitectureContract);
   const modulesRootRelativePath = options.modulesRootRelativePath ?? resolveModulesRootFromContract(parsedArchitectureContract);
-  const moduleRoots = await findModuleRoots(workspaceRoot, modulesRootRelativePath);
+  const moduleRoots = await findModuleRoots(
+    workspaceRoot,
+    modulesRootRelativePath,
+    parsedArchitectureContract
+  );
   const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(
     workspaceRoot,
     parsedArchitectureContract
   );
-  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(
+    workspaceRoot,
+    moduleRoots
+  );
   const imports = await collectCrossModuleImports(
     workspaceRoot,
     modulesRootRelativePath,
@@ -216820,6 +217030,7 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
             ),
             filePath: violation.sourceFileRelativePath,
             line: violation.line,
+            importSpecifier: violation.importSpecifier,
             findingType: "module-dependency",
             module: violation.sourceModule,
             target: violation.targetModule
@@ -216852,12 +217063,17 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
         });
       } else {
         for (const violation of violations) {
+          const publicImportGuidance = await describeModulePublicImportGuidance(
+            workspaceRoot,
+            violation.targetModule,
+            moduleRoots
+          );
           findings.push({
             result: makeValidationResult(
               "AP-DEP-003",
               "error",
               false,
-              `${violation.sourceFileRelativePath}:${violation.line} imports non-public path "${violation.importSpecifier}" from module "${violation.targetModule}". Use the public entrypoint at ${modulesRootRelativePath}/${violation.targetModule} or ${modulesRootRelativePath}/${violation.targetModule}/public instead.`,
+              `${violation.sourceFileRelativePath}:${violation.line} imports non-public path "${violation.importSpecifier}" from module "${violation.targetModule}". ${publicImportGuidance}`,
               {
                 findingType: "module-dependency",
                 module: violation.sourceModule,
@@ -216866,6 +217082,7 @@ async function validateDependencyBoundaries(workspaceRoot, options) {
             ),
             filePath: violation.sourceFileRelativePath,
             line: violation.line,
+            importSpecifier: violation.importSpecifier,
             findingType: "module-dependency",
             module: violation.sourceModule,
             target: violation.targetModule
@@ -216880,12 +217097,19 @@ async function buildModuleDependencyGraphSnapshot(workspaceRoot, options) {
   const parsedArchitectureContract = await loadArchitectureContract(workspaceRoot);
   const adapter = resolvePrimaryAdapterFromContract(parsedArchitectureContract);
   const modulesRootRelativePath = options?.modulesRootRelativePath ?? resolveModulesRootFromContract(parsedArchitectureContract);
-  const moduleRoots = await findModuleRoots(workspaceRoot, modulesRootRelativePath);
+  const moduleRoots = await findModuleRoots(
+    workspaceRoot,
+    modulesRootRelativePath,
+    parsedArchitectureContract
+  );
   const explicitStandaloneModuleByPath = await buildExplicitStandaloneModulePathMap(
     workspaceRoot,
     parsedArchitectureContract
   );
-  const workspacePackageAliases = await buildWorkspacePackageAliasMap(moduleRoots);
+  const workspacePackageAliases = await buildWorkspacePackageAliasMap(
+    workspaceRoot,
+    moduleRoots
+  );
   const discoveredModules = sortUnique2([
     ...moduleRoots.keys(),
     ...explicitStandaloneModuleByPath.values()
@@ -216979,7 +217203,7 @@ function normalizeStringArray(value) {
   }
   return normalizedValues;
 }
-async function pathExists4(targetPath) {
+async function pathExists5(targetPath) {
   try {
     await import_node_fs9.promises.access(targetPath);
     return true;
@@ -217115,7 +217339,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
       if (!moduleReference.contract) {
         continue;
       }
-      const exists = await pathExists4(
+      const exists = await pathExists5(
         toWorkspaceAbsolutePath(workspaceRoot, moduleReference.contract)
       );
       if (!exists) {
@@ -217151,7 +217375,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
       }
       const contractPath = moduleReference.contract;
       const fullContractPath = toWorkspaceAbsolutePath(workspaceRoot, contractPath);
-      if (!await pathExists4(fullContractPath)) {
+      if (!await pathExists5(fullContractPath)) {
         continue;
       }
       const parsedContract = await readModuleContract(workspaceRoot, contractPath);
@@ -217210,7 +217434,7 @@ async function validateModuleContractIntegrity(workspaceRoot, contract, options)
       }
       const contractPath = moduleReference.contract;
       const fullContractPath = toWorkspaceAbsolutePath(workspaceRoot, contractPath);
-      if (!await pathExists4(fullContractPath)) {
+      if (!await pathExists5(fullContractPath)) {
         continue;
       }
       const parsedContract = await readModuleContract(workspaceRoot, contractPath);
@@ -217568,7 +217792,7 @@ function hasKeywordMatch(record, keywords) {
   const haystack = `${record.fileName} ${record.title}`.toLowerCase();
   return keywords.some((keyword) => haystack.includes(keyword));
 }
-function pathExists5(targetPath) {
+function pathExists6(targetPath) {
   return (0, import_promises.access)(targetPath).then(() => true).catch(() => false);
 }
 function buildSummary(records) {
@@ -217593,7 +217817,7 @@ function createAdrValidationResult(input2) {
 async function validateAdrEnforcement(workspaceRoot, config) {
   const adrDirectoryRelativePath = await resolveAdrDirectoryRelativePath(workspaceRoot);
   const adrDirectory = getAdrDirectoryPath(workspaceRoot, adrDirectoryRelativePath);
-  const adrDirectoryExists = await pathExists5(adrDirectory);
+  const adrDirectoryExists = await pathExists6(adrDirectory);
   if (!adrDirectoryExists) {
     return {
       results: [
@@ -217646,7 +217870,7 @@ async function validateAdrEnforcement(workspaceRoot, config) {
       }
     ]
   ];
-  const dependencyContextExists = await pathExists5(path11.join(workspaceRoot, ".archpilot", "dependency-rules.json")) || await pathExists5(path11.join(workspaceRoot, ".archpilot", "contracts"));
+  const dependencyContextExists = await pathExists6(path11.join(workspaceRoot, ".archpilot", "dependency-rules.json")) || await pathExists6(path11.join(workspaceRoot, ".archpilot", "contracts"));
   const checksToRun = [
     requiredCoverageChecks[0],
     ...dependencyContextExists ? [requiredCoverageChecks[1]] : [],
@@ -218157,13 +218381,6 @@ var overallSetupGapWarningPenalty = 1;
 var overallSetupGapInfoPenalty = 1;
 var minScore = 0;
 var maxScore = 100;
-var crossModuleDependencyRuleIds = /* @__PURE__ */ new Set([
-  "AP-DEP-002",
-  "AP-DEP-003",
-  "AP-DEP-004",
-  "AP-DEP-005",
-  "AP-DEP-010"
-]);
 var crossModuleContractRuleIds = /* @__PURE__ */ new Set(["AP-DEP-004", "AP-DEP-005"]);
 var cycleRuleIds = /* @__PURE__ */ new Set(["AP-DEP-001", "AP-DEP-008"]);
 function clampScore(value) {
@@ -218217,6 +218434,22 @@ function getQualityPenaltyForResult(result) {
   }
   return base + getAdditionalQualityPenalty(result);
 }
+function dedupeResultsByDeductionKey(results) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const result of results) {
+    if (!result.deductionKey) {
+      deduped.push(result);
+      continue;
+    }
+    if (seen.has(result.deductionKey)) {
+      continue;
+    }
+    seen.add(result.deductionKey);
+    deduped.push(result);
+  }
+  return deduped;
+}
 function getReadinessPenaltyForSetupGapSeverity(severity) {
   if (severity === "error") {
     return readinessSetupGapErrorPenalty;
@@ -218227,7 +218460,7 @@ function getReadinessPenaltyForSetupGapSeverity(severity) {
   return readinessSetupGapInfoPenalty;
 }
 function deriveGovernanceRiskLevelFromResults(results) {
-  const qualityFailures = results.filter(
+  const qualityFailures = dedupeResultsByDeductionKey(results).filter(
     (result) => !result.passed && (result.impact ?? "quality") === "quality"
   );
   const hasCriticalRule = qualityFailures.some(
@@ -218246,21 +218479,14 @@ function deriveGovernanceRiskLevelFromResults(results) {
 }
 function applyFinalScoreAdjustments(input2) {
   let adjusted = input2.baseScore;
-  const crossModuleDependencyViolations = input2.results.filter(
-    (result) => !result.passed && (result.impact ?? "quality") === "quality" && typeof result.ruleId === "string" && crossModuleDependencyRuleIds.has(result.ruleId)
-  ).length;
-  const crossModuleContractViolations = input2.results.filter(
+  const uniqueResults = dedupeResultsByDeductionKey(input2.results);
+  const crossModuleContractViolations = uniqueResults.filter(
     (result) => !result.passed && (result.impact ?? "quality") === "quality" && typeof result.ruleId === "string" && crossModuleContractRuleIds.has(result.ruleId)
   ).length;
-  const cycleViolations = input2.results.filter(
+  const cycleViolations = uniqueResults.filter(
     (result) => !result.passed && (result.impact ?? "quality") === "quality" && typeof result.ruleId === "string" && cycleRuleIds.has(result.ruleId)
   ).length;
-  const blockingViolations = input2.results.filter(
-    (result) => !result.passed && result.severity === "error" && (result.impact ?? "quality") === "quality"
-  ).length;
-  adjusted -= Math.min(8, blockingViolations * 2);
   adjusted -= Math.min(6, crossModuleContractViolations * 2);
-  adjusted -= Math.min(4, crossModuleDependencyViolations);
   adjusted -= Math.min(4, cycleViolations * 2);
   const governanceRiskLevel = input2.context?.governanceRiskLevel ?? deriveGovernanceRiskLevelFromResults(input2.results);
   if (governanceRiskLevel === "critical") {
@@ -219744,7 +219970,7 @@ function normalizeSqlTableName(raw) {
   }
   return trimmed;
 }
-async function pathExists6(targetPath) {
+async function pathExists7(targetPath) {
   try {
     await import_node_fs19.promises.access(targetPath);
     return true;
@@ -219765,7 +219991,7 @@ async function readTextFileIfReasonable(filePath) {
 }
 async function collectFilesRecursive(rootPath, includeFile, ignoredDirectoryNames8) {
   const collected = [];
-  if (!await pathExists6(rootPath)) {
+  if (!await pathExists7(rootPath)) {
     return collected;
   }
   const stack = [rootPath];
@@ -220649,6 +220875,23 @@ function buildSetupGapDeductionKeyFromMessage(message) {
   }
   return void 0;
 }
+function buildDependencyDeductionKey(result) {
+  if (result.findingType !== "module-dependency") {
+    return void 0;
+  }
+  if (typeof result.sourceFile !== "string" || typeof result.sourceLine !== "number" || typeof result.module !== "string" || typeof result.target !== "string") {
+    return void 0;
+  }
+  return [
+    "quality",
+    result.id,
+    result.module,
+    result.target,
+    result.sourceFile.replace(/\\/g, "/"),
+    String(result.sourceLine),
+    result.importSpecifier ?? ""
+  ].join("|");
+}
 function classifyValidationResult(result) {
   if (result.passed) {
     return {
@@ -220676,7 +220919,7 @@ function classifyValidationResult(result) {
   return {
     kind: "violation",
     scoreImpact: "quality",
-    deductionKey: `quality:${result.id}:${normalizedMessage}`
+    deductionKey: buildDependencyDeductionKey(result) ?? `quality:${result.id}:${normalizedMessage}`
   };
 }
 function getRuleIdSet() {
@@ -221266,7 +221509,7 @@ function applyValidationExceptions(results, exceptions) {
     approvedExceptions: dedupedApprovedExceptions
   };
 }
-async function pathExists7(targetPath) {
+async function pathExists8(targetPath) {
   try {
     await import_node_fs20.promises.access(targetPath);
     return true;
@@ -221305,11 +221548,11 @@ async function readDependencyRulesRawConfig(workspaceRoot) {
 async function resolveValidationConfigPath(workspaceRoot) {
   const configDir = path21.join(workspaceRoot, ".archpilot");
   const jsoncPath = path21.join(configDir, "validation-config.jsonc");
-  if (await pathExists7(jsoncPath)) {
+  if (await pathExists8(jsoncPath)) {
     return jsoncPath;
   }
   const jsonPath = path21.join(configDir, "validation-config.json");
-  if (await pathExists7(jsonPath)) {
+  if (await pathExists8(jsonPath)) {
     return jsonPath;
   }
   return void 0;
@@ -221435,7 +221678,7 @@ async function validateApiStyle(workspaceRoot, contract, config, validationConfi
   }
   const openApiRelativePath = resolveOpenApiRelativePath(contract);
   const openApiPath = path21.join(workspaceRoot, ...openApiRelativePath.split("/"));
-  const exists = await pathExists7(openApiPath);
+  const exists = await pathExists8(openApiPath);
   if (openApiRequired) {
     results.push({
       id: ValidationRuleIds.API_OPENAPI_EXISTS,
@@ -221488,7 +221731,7 @@ async function validateTenantModel(workspaceRoot, contract, config, validationCo
   if (config.tenantModel === "same_db_different_schema" && !isRuleDisabled(ValidationRuleIds.DOC_TENANT_DIFFERENT_SCHEMA_ADR, validationConfig)) {
     const tenantModelAdrRelativePath = resolveTenantModelAdrRelativePath(contract);
     const adrPath = path21.join(workspaceRoot, ...tenantModelAdrRelativePath.split("/"));
-    const exists = await pathExists7(adrPath);
+    const exists = await pathExists8(adrPath);
     results.push({
       id: ValidationRuleIds.DOC_TENANT_DIFFERENT_SCHEMA_ADR,
       severity: "warning",
@@ -221541,7 +221784,7 @@ async function validateArchitectureStyle(workspaceRoot, contract, validationConf
   if (implementationProfile === "typescript-backend" && !isRuleDisabled(ValidationRuleIds.ARCH_OVERVIEW_ARTIFACT_EXISTS, validationConfig)) {
     const overviewRelativePath = resolveOverviewRelativePath(contract);
     const overviewPath = path21.join(workspaceRoot, ...overviewRelativePath.split("/"));
-    const overviewExists = await pathExists7(overviewPath);
+    const overviewExists = await pathExists8(overviewPath);
     results.push({
       id: ValidationRuleIds.ARCH_OVERVIEW_ARTIFACT_EXISTS,
       severity: "error",
@@ -221553,7 +221796,7 @@ async function validateArchitectureStyle(workspaceRoot, contract, validationConf
     const normalizeEntrypoint = (entry) => normalizeRelativePath2(entry.trim());
     const hasDeclaredPublicEntrypoint = async (moduleName, entry) => {
       const entryPath = path21.join(workspaceRoot, ...normalizeEntrypoint(entry).split("/"));
-      return pathExists7(entryPath);
+      return pathExists8(entryPath);
     };
     const readModuleContractPublicEntrypoints = async (moduleName) => {
       const registryEntry = contract.modules[moduleName];
@@ -221578,7 +221821,7 @@ async function validateArchitectureStyle(workspaceRoot, contract, validationConf
     };
     const modulesRootRelativePath2 = await getConfiguredModulesRoot(workspaceRoot, contract);
     const modulesRoot = path21.join(workspaceRoot, ...modulesRootRelativePath2.split("/"));
-    if (await pathExists7(modulesRoot)) {
+    if (await pathExists8(modulesRoot)) {
       const hierarchicalModules = await discoverHierarchicalModuleRoots(
         workspaceRoot,
         modulesRootRelativePath2
@@ -221600,8 +221843,8 @@ async function validateArchitectureStyle(workspaceRoot, contract, validationConf
       for (const moduleDirectory of moduleDirectories2) {
         const moduleName = moduleDirectory.moduleName;
         const moduleDir = path21.join(workspaceRoot, ...moduleDirectory.sourcePath.split("/"));
-        const readmeExists = await pathExists7(path21.join(moduleDir, "README.md"));
-        const indexExists = await pathExists7(path21.join(moduleDir, "index.ts"));
+        const readmeExists = await pathExists8(path21.join(moduleDir, "README.md"));
+        const indexExists = await pathExists8(path21.join(moduleDir, "index.ts"));
         const registryPublicEntrypoints = (contract.modules[moduleName]?.publicEntrypoints ?? []).filter((entry) => typeof entry === "string").map((entry) => normalizeEntrypoint(entry));
         const contractPublicEntrypoints = await readModuleContractPublicEntrypoints(moduleName);
         const declaredPublicEntrypoints = [
@@ -221648,7 +221891,7 @@ async function validateDatabaseArtifacts(workspaceRoot, contract, config, valida
   }
   const sqlBaselineRelativePath = resolveSqlBaselineRelativePath(contract);
   const sqlBaselinePath = path21.join(workspaceRoot, ...sqlBaselineRelativePath.split("/"));
-  const exists = await pathExists7(sqlBaselinePath);
+  const exists = await pathExists8(sqlBaselinePath);
   results.push({
     id: ValidationRuleIds.DB_SQL_BASELINE_EXISTS,
     severity: "error",
@@ -221657,6 +221900,34 @@ async function validateDatabaseArtifacts(workspaceRoot, contract, config, valida
   });
   return results;
 }
+function buildDependencyFindingStableKey(finding) {
+  if (!finding.result.id || !finding.module || !finding.target || !finding.filePath || finding.line === void 0 || !finding.importSpecifier) {
+    return void 0;
+  }
+  return [
+    finding.result.id,
+    finding.module,
+    finding.target,
+    finding.filePath.replace(/\\/g, "/"),
+    String(finding.line),
+    finding.importSpecifier
+  ].join("|");
+}
+function dedupeDependencyFindings(findings) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const finding of findings) {
+    const stableKey = buildDependencyFindingStableKey(finding);
+    if (stableKey && seen.has(stableKey)) {
+      continue;
+    }
+    if (stableKey) {
+      seen.add(stableKey);
+    }
+    deduped.push(finding);
+  }
+  return deduped;
+}
 async function validateModuleDependencies(workspaceRoot, contract, validationConfig, onDependencyConfigError, dependencyRulesConfigOverride) {
   const modulesRootRelativePath = await getConfiguredModulesRoot(workspaceRoot, contract);
   const dependencyRuleChecks = {
@@ -221696,10 +221967,11 @@ async function validateModuleDependencies(workspaceRoot, contract, validationCon
       }),
       validateDependencyContractBoundaries(workspaceRoot, contract, {
         ...contractDependencyRuleChecks,
-        modulesRootRelativePath
+        modulesRootRelativePath,
+        suppressPublicSurfaceFailuresForNonPublicImports: dependencyRuleChecks.checkNonPublicImports
       })
     ]);
-    const findings = [...legacyFindings, ...contractFindings];
+    const findings = dedupeDependencyFindings([...legacyFindings, ...contractFindings]);
     const results = [];
     for (const finding of findings) {
       const resultWithSource = {
@@ -221710,7 +221982,8 @@ async function validateModuleDependencies(workspaceRoot, contract, validationCon
         ...finding.api ? { api: finding.api } : {},
         ...finding.findingType ? { findingType: finding.findingType } : {},
         ...finding.filePath ? { sourceFile: finding.filePath, filePath: finding.filePath } : {},
-        ...finding.line !== void 0 ? { sourceLine: finding.line } : {}
+        ...finding.line !== void 0 ? { sourceLine: finding.line } : {},
+        ...finding.importSpecifier ? { importSpecifier: finding.importSpecifier } : {}
       };
       results.push(resultWithSource);
     }
@@ -221838,7 +222111,7 @@ async function validateDependencyGraphIsolation(workspaceRoot, contract, depende
       continue;
     }
     const moduleDirectoryPath = path21.join(workspaceRoot, ...registryEntry.path.split("/"));
-    const moduleDirectoryExists = await pathExists7(moduleDirectoryPath);
+    const moduleDirectoryExists = await pathExists8(moduleDirectoryPath);
     if (!moduleDirectoryExists) {
       continue;
     }
@@ -224408,7 +224681,7 @@ var import_node_fs22 = require("node:fs");
 async function ensureDirectory(directoryPath) {
   await import_node_fs22.promises.mkdir(directoryPath, { recursive: true });
 }
-async function pathExists8(targetPath) {
+async function pathExists9(targetPath) {
   try {
     await import_node_fs22.promises.access(targetPath);
     return true;
@@ -224417,7 +224690,7 @@ async function pathExists8(targetPath) {
   }
 }
 async function createFileIfMissing(filePath, content) {
-  if (await pathExists8(filePath)) {
+  if (await pathExists9(filePath)) {
     return false;
   }
   await ensureDirectory(path23.dirname(filePath));
@@ -224525,7 +224798,7 @@ async function previewArch001(context) {
   ];
   const filesCreated = [];
   for (const targetPath of targetPaths) {
-    if (!await pathExists8(targetPath)) {
+    if (!await pathExists9(targetPath)) {
       filesCreated.push(relative5(targetPath, context.workspaceRoot));
     }
   }
@@ -224546,7 +224819,7 @@ async function applyArch001(context) {
   ];
   const filesCreated = [];
   for (const targetPath of targetPaths) {
-    const existed = await pathExists8(targetPath);
+    const existed = await pathExists9(targetPath);
     await ensureDirectory(targetPath);
     if (!existed) {
       filesCreated.push(relative5(targetPath, context.workspaceRoot));
@@ -224562,8 +224835,8 @@ async function applyArch001(context) {
 async function previewArch003(context) {
   const directoryPath = path24.join(context.workspaceRoot, "docs", "architecture");
   const filePath = path24.join(directoryPath, "overview.md");
-  const directoryExists2 = await pathExists8(directoryPath);
-  const fileExists4 = await pathExists8(filePath);
+  const directoryExists2 = await pathExists9(directoryPath);
+  const fileExists4 = await pathExists9(filePath);
   const filesCreated = [];
   if (!directoryExists2) {
     filesCreated.push(relative5(directoryPath, context.workspaceRoot));
@@ -224582,7 +224855,7 @@ async function previewArch003(context) {
 async function applyArch003(context) {
   const directoryPath = path24.join(context.workspaceRoot, "docs", "architecture");
   const filePath = path24.join(directoryPath, "overview.md");
-  const directoryExisted = await pathExists8(directoryPath);
+  const directoryExisted = await pathExists9(directoryPath);
   const fileCreated = await createFileIfMissing(filePath, architectureOverviewStarterTemplate);
   const filesCreated = [];
   if (!directoryExisted) {
@@ -224600,7 +224873,7 @@ async function applyArch003(context) {
 }
 async function previewApi001(context) {
   const filePath = path24.join(context.workspaceRoot, "contracts", "openapi.yaml");
-  const exists = await pathExists8(filePath);
+  const exists = await pathExists9(filePath);
   return {
     filesCreated: exists ? [] : [relative5(filePath, context.workspaceRoot)],
     filesModified: [],
@@ -224641,7 +224914,7 @@ async function previewArch005(context) {
     };
   }
   const absolutePath = path24.join(context.workspaceRoot, ...modulePath.split("/"));
-  const exists = await pathExists8(absolutePath);
+  const exists = await pathExists9(absolutePath);
   return {
     filesCreated: exists ? [] : [modulePath],
     filesModified: [],
@@ -224660,7 +224933,7 @@ async function applyArch005(context) {
     };
   }
   const absolutePath = path24.join(context.workspaceRoot, ...modulePath.split("/"));
-  const existed = await pathExists8(absolutePath);
+  const existed = await pathExists9(absolutePath);
   await ensureDirectory(absolutePath);
   return {
     applied: !existed,
@@ -224681,7 +224954,7 @@ async function previewArch006(context) {
     };
   }
   const absolutePath = path24.join(context.workspaceRoot, ...contractPath.split("/"));
-  const exists = await pathExists8(absolutePath);
+  const exists = await pathExists9(absolutePath);
   return {
     filesCreated: exists ? [] : [contractPath],
     filesModified: [],
@@ -224723,7 +224996,7 @@ async function applyArch006(context) {
 }
 async function previewDoc001(context) {
   const filePath = path24.join(context.workspaceRoot, "docs", "adrs", "adr-001-tenant-model.md");
-  const exists = await pathExists8(filePath);
+  const exists = await pathExists9(filePath);
   return {
     filesCreated: exists ? [] : [relative5(filePath, context.workspaceRoot)],
     filesModified: [],
@@ -224756,7 +225029,7 @@ async function applyDoc001(context) {
 }
 async function previewDoc002(context) {
   const filePath = path24.join(context.workspaceRoot, "docs", "adrs", "adr-rbac-model.md");
-  const exists = await pathExists8(filePath);
+  const exists = await pathExists9(filePath);
   return {
     filesCreated: exists ? [] : [relative5(filePath, context.workspaceRoot)],
     filesModified: [],
@@ -224891,7 +225164,7 @@ async function applyDep006(context) {
     "contracts",
     `${parsed.sourceModule}.contract.json`
   );
-  if (!await pathExists8(contractPath)) {
+  if (!await pathExists9(contractPath)) {
     return {
       applied: false,
       filesCreated: [],
@@ -225304,7 +225577,7 @@ var jsxExtensions = /* @__PURE__ */ new Set([".tsx", ".jsx"]);
 function normalizePath4(value) {
   return value.replace(/\\/g, "/").replace(/^\.\/+/u, "").replace(/\/+$/u, "").toLowerCase();
 }
-function pathExists9(targetPath) {
+function pathExists10(targetPath) {
   try {
     fs24.accessSync(targetPath);
     return true;
@@ -225391,7 +225664,7 @@ function hasDependencyPrefix(dependencies, prefixes) {
   return false;
 }
 function hasAnyFile(candidateRoot, filePaths) {
-  return filePaths.some((filePath) => pathExists9(path25.join(candidateRoot, ...filePath.split("/"))));
+  return filePaths.some((filePath) => pathExists10(path25.join(candidateRoot, ...filePath.split("/"))));
 }
 function scanForJsxFiles(candidateRoot) {
   const queue = [{ absolutePath: candidateRoot, depth: 0 }];
@@ -225427,25 +225700,25 @@ function collectCandidateSignals(candidateRoot) {
   const dependencies = collectDependencyNames(packageJsonPath);
   return {
     dependencies,
-    hasNextConfig: pathExists9(path25.join(candidateRoot, "next.config.js")) || pathExists9(path25.join(candidateRoot, "next.config.mjs")) || pathExists9(path25.join(candidateRoot, "next.config.ts")),
-    hasViteConfig: pathExists9(path25.join(candidateRoot, "vite.config.js")) || pathExists9(path25.join(candidateRoot, "vite.config.ts")) || pathExists9(path25.join(candidateRoot, "vite.config.mjs")),
-    hasIndexHtml: pathExists9(path25.join(candidateRoot, "index.html")),
-    hasPublicDir: pathExists9(path25.join(candidateRoot, "public")),
-    hasSrcComponents: pathExists9(path25.join(candidateRoot, "src", "components")),
-    hasSrcPages: pathExists9(path25.join(candidateRoot, "src", "pages")),
-    hasSrcApp: pathExists9(path25.join(candidateRoot, "src", "app")),
+    hasNextConfig: pathExists10(path25.join(candidateRoot, "next.config.js")) || pathExists10(path25.join(candidateRoot, "next.config.mjs")) || pathExists10(path25.join(candidateRoot, "next.config.ts")),
+    hasViteConfig: pathExists10(path25.join(candidateRoot, "vite.config.js")) || pathExists10(path25.join(candidateRoot, "vite.config.ts")) || pathExists10(path25.join(candidateRoot, "vite.config.mjs")),
+    hasIndexHtml: pathExists10(path25.join(candidateRoot, "index.html")),
+    hasPublicDir: pathExists10(path25.join(candidateRoot, "public")),
+    hasSrcComponents: pathExists10(path25.join(candidateRoot, "src", "components")),
+    hasSrcPages: pathExists10(path25.join(candidateRoot, "src", "pages")),
+    hasSrcApp: pathExists10(path25.join(candidateRoot, "src", "app")),
     hasJsxTsconfig: hasJsxEnabled(path25.join(candidateRoot, "tsconfig.json")) || hasJsxEnabled(path25.join(candidateRoot, "jsconfig.json")),
     hasJsxFiles: scanForJsxFiles(candidateRoot),
-    hasRoutesDir: pathExists9(path25.join(candidateRoot, "routes")),
-    hasControllersDir: pathExists9(path25.join(candidateRoot, "controllers")),
-    hasPrismaDir: pathExists9(path25.join(candidateRoot, "prisma")),
-    hasDbDir: pathExists9(path25.join(candidateRoot, "db")),
-    hasMigrationsDir: pathExists9(path25.join(candidateRoot, "migrations")),
-    hasApiDir: pathExists9(path25.join(candidateRoot, "api")),
+    hasRoutesDir: pathExists10(path25.join(candidateRoot, "routes")),
+    hasControllersDir: pathExists10(path25.join(candidateRoot, "controllers")),
+    hasPrismaDir: pathExists10(path25.join(candidateRoot, "prisma")),
+    hasDbDir: pathExists10(path25.join(candidateRoot, "db")),
+    hasMigrationsDir: pathExists10(path25.join(candidateRoot, "migrations")),
+    hasApiDir: pathExists10(path25.join(candidateRoot, "api")),
     hasServerEntrypoint: hasAnyFile(candidateRoot, backendEntrypoints),
     hasOpenApiArtifacts: hasAnyFile(candidateRoot, openApiArtifacts),
     hasWorkerEntrypoint: hasAnyFile(candidateRoot, workerEntrypoints),
-    hasPackageJson: pathExists9(packageJsonPath),
+    hasPackageJson: pathExists10(packageJsonPath),
     hasExportsField: hasExportsField(packageJsonPath),
     hasIndexEntrypoint: hasAnyFile(candidateRoot, indexEntrypoints)
   };
@@ -225614,7 +225887,7 @@ function classifyModuleScope(input2) {
     return "backend";
   }
   const candidateRoots = getCandidateRoots(input2.workspaceRoot, input2.modulePath).filter(
-    (candidate) => pathExists9(candidate)
+    (candidate) => pathExists10(candidate)
   );
   const scores = sumScores(
     candidateRoots.map(
@@ -225637,7 +225910,7 @@ function classifyModuleScope(input2) {
 function normalizePath5(value) {
   return value.replace(/\\/g, "/");
 }
-async function pathExists10(targetPath) {
+async function pathExists11(targetPath) {
   try {
     await import_node_fs24.promises.access(targetPath);
     return true;
@@ -225851,7 +226124,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
     const contractPath = normalizePath5(
       typeof registryEntry.contract === "string" ? registryEntry.contract : `${contractsRoot}/${toSafeContractModuleFileStem2(moduleName)}.contract.json`
     );
-    const contractExists = await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")));
+    const contractExists = await pathExists11(path26.join(workspaceRoot, ...contractPath.split("/")));
     const missingPublicEntrypointAlignment = await resolveMissingPublicEntrypointAlignment(
       registryEntry,
       contractPath
@@ -225876,7 +226149,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
     const registryEntry = moduleRegistry[moduleName];
     const sourcePath = normalizePath5(registryEntry?.path ?? `${normalizedModulesRoot}/${moduleName}`);
     const contractPath = toContractPath(moduleName, registryEntry);
-    const contractExists = await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")));
+    const contractExists = await pathExists11(path26.join(workspaceRoot, ...contractPath.split("/")));
     const missingPublicEntrypointAlignment = await resolveMissingPublicEntrypointAlignment(
       registryEntry,
       contractPath
@@ -225900,7 +226173,7 @@ async function discoverModulesFromArchitectureContract(workspaceRoot, contract,
     }
     const registryEntry = moduleRegistry[moduleRoot.moduleId];
     const contractPath = toContractPath(moduleRoot.moduleId, registryEntry);
-    const contractExists = await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")));
+    const contractExists = await pathExists11(path26.join(workspaceRoot, ...contractPath.split("/")));
     const missingPublicEntrypointAlignment = await resolveMissingPublicEntrypointAlignment(
       registryEntry,
       contractPath
@@ -225933,7 +226206,7 @@ async function discoverModulesFromFallbackScan(workspaceRoot, modulesRoot = "src
       sourcePathExists: true,
       ...resolveModuleScopeForPath(workspaceRoot, moduleRoot.sourcePath) ? { scope: resolveModuleScopeForPath(workspaceRoot, moduleRoot.sourcePath) } : {},
       contractPath,
-      contractExists: await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")))
+      contractExists: await pathExists11(path26.join(workspaceRoot, ...contractPath.split("/")))
     });
   }
   for (const moduleName of moduleNames) {
@@ -225946,7 +226219,7 @@ async function discoverModulesFromFallbackScan(workspaceRoot, modulesRoot = "src
       sourcePathExists: true,
       ...resolveModuleScopeForPath(workspaceRoot, sourcePath) ? { scope: resolveModuleScopeForPath(workspaceRoot, sourcePath) } : {},
       contractPath,
-      contractExists: await pathExists10(path26.join(workspaceRoot, ...contractPath.split("/")))
+      contractExists: await pathExists11(path26.join(workspaceRoot, ...contractPath.split("/")))
     });
   }
   return discovered;
@@ -227708,7 +227981,7 @@ async function runGithubPrCommentAdapter(workspaceRoot) {
 // ../core/src/generateOnboardingDocs.ts
 var path31 = __toESM(require("node:path"));
 var import_node_fs29 = require("node:fs");
-async function pathExists11(filePath) {
+async function pathExists12(filePath) {
   try {
     await import_node_fs29.promises.access(filePath);
     return true;
@@ -227762,10 +228035,10 @@ async function generateOnboardingDocs(workspaceRoot) {
     [...map.modules].sort((left, right) => left.moduleName.localeCompare(right.moduleName)).map(async (moduleEntry) => {
       const readmePath = `${moduleEntry.sourcePath}/README.md`;
       const indexPath = `${moduleEntry.sourcePath}/index.ts`;
-      const readmeExists = await pathExists11(
+      const readmeExists = await pathExists12(
         path31.join(workspaceRoot, ...readmePath.split("/"))
       );
-      const indexExists = await pathExists11(
+      const indexExists = await pathExists12(
         path31.join(workspaceRoot, ...indexPath.split("/"))
       );
       const hotspot = hotspotByModule.get(moduleEntry.moduleName);
@@ -228547,7 +228820,7 @@ function normalizePath9(value) {
 function sortUnique10(values) {
   return [...new Set(values)].sort((left, right) => left.localeCompare(right));
 }
-async function pathExists12(targetPath) {
+async function pathExists13(targetPath) {
   try {
     await import_node_fs30.promises.access(targetPath);
     return true;
@@ -228792,18 +229065,18 @@ async function generateImpactAnalysis(workspaceRoot, target, options) {
     const contractPath = moduleEntry.contractPath;
     suggestedFilesToInspect.push({
       path: readmePath,
-      exists: await pathExists12(path32.join(workspaceRoot, ...readmePath.split("/"))),
+      exists: await pathExists13(path32.join(workspaceRoot, ...readmePath.split("/"))),
       kind: "readme"
     });
     suggestedFilesToInspect.push({
       path: indexPath,
-      exists: await pathExists12(path32.join(workspaceRoot, ...indexPath.split("/"))),
+      exists: await pathExists13(path32.join(workspaceRoot, ...indexPath.split("/"))),
       kind: "entrypoint"
     });
     if (contractPath) {
       suggestedFilesToInspect.push({
         path: contractPath,
-        exists: await pathExists12(path32.join(workspaceRoot, ...contractPath.split("/"))),
+        exists: await pathExists13(path32.join(workspaceRoot, ...contractPath.split("/"))),
         kind: "contract"
       });
     }
@@ -231126,7 +231399,7 @@ async function applyQuickFixPlan(workspaceRoot, plan) {
         continue;
       }
       const absoluteTargetPath = path43.resolve(workspaceRoot, action.targetPath);
-      if (await pathExists8(absoluteTargetPath)) {
+      if (await pathExists9(absoluteTargetPath)) {
         skippedExists.push(action.targetPath);
         continue;
       }
@@ -231179,7 +231452,7 @@ function normalizePath11(value) {
 function toAbsolutePath(workspaceRoot, relativePath) {
   return path44.join(workspaceRoot, ...relativePath.split("/"));
 }
-async function pathExists13(targetPath) {
+async function pathExists14(targetPath) {
   try {
     await import_node_fs39.promises.access(targetPath);
     return true;
@@ -231208,7 +231481,7 @@ async function inferModulePublicEntrypoints(workspaceRoot, moduleSourcePath, ada
   const normalizedSourcePath = normalizePath11(moduleSourcePath);
   if (/\.[a-z0-9]+$/iu.test(normalizedSourcePath)) {
     const absoluteSourcePath = toAbsolutePath(workspaceRoot, normalizedSourcePath);
-    if (await pathExists13(absoluteSourcePath)) {
+    if (await pathExists14(absoluteSourcePath)) {
       return [normalizedSourcePath];
     }
   }
@@ -231235,14 +231508,14 @@ async function inferModulePublicEntrypoints(workspaceRoot, moduleSourcePath, ada
   const inferred = [];
   for (const fileName of orderedCandidates) {
     const candidateRelative = `${normalizedSourcePath}/${fileName}`;
-    if (await pathExists13(toAbsolutePath(workspaceRoot, candidateRelative))) {
+    if (await pathExists14(toAbsolutePath(workspaceRoot, candidateRelative))) {
       inferred.push(candidateRelative);
       break;
     }
   }
   for (const publicDirName of adapter.publicEntrypointDirectoryNames) {
     const publicDirectoryRelative = `${normalizedSourcePath}/${publicDirName}`;
-    if (await pathExists13(toAbsolutePath(workspaceRoot, publicDirectoryRelative))) {
+    if (await pathExists14(toAbsolutePath(workspaceRoot, publicDirectoryRelative))) {
       inferred.push(publicDirectoryRelative);
       break;
     }
@@ -231333,7 +231606,7 @@ async function generateMissingModuleContracts(workspaceRoot) {
     const contractPath = resolveContractPath(contract, moduleEntry.moduleName);
     const sourcePath = normalizePath11(moduleEntry.sourcePath);
     const absoluteContractPath = toAbsolutePath(workspaceRoot, contractPath);
-    const contractExists = await pathExists13(absoluteContractPath);
+    const contractExists = await pathExists14(absoluteContractPath);
     const existingContractPublicEntrypoints = contractExists ? await readExistingModuleContractPublicEntrypoints(workspaceRoot, contractPath) : void 0;
     const configuredPublicEntrypoints = !contractExists && Array.isArray(getModuleRegistry2(contract)[moduleEntry.moduleName]?.publicEntrypoints) ? sortUnique12(
       getModuleRegistry2(contract)[moduleEntry.moduleName]?.publicEntrypoints?.map(
@@ -231396,7 +231669,7 @@ function normalizePath12(value) {
 function toAbsolutePath2(workspaceRoot, relativePath) {
   return path45.join(workspaceRoot, ...relativePath.split("/"));
 }
-async function pathExists14(targetPath) {
+async function pathExists15(targetPath) {
   try {
     await import_node_fs40.promises.access(targetPath);
     return true;
@@ -231459,7 +231732,7 @@ async function bootstrapArchitectureConfig(workspaceRoot, options) {
   ensuredDirectories.push(".archpilot", ".archpilot/contracts");
   const dependencyRulesPath = ".archpilot/dependency-rules.json";
   const dependencyRulesAbsolutePath = toAbsolutePath2(workspaceRoot, dependencyRulesPath);
-  if (await pathExists14(dependencyRulesAbsolutePath)) {
+  if (await pathExists15(dependencyRulesAbsolutePath)) {
     skippedExistingFiles.push(dependencyRulesPath);
   } else {
     await import_node_fs40.promises.writeFile(
@@ -231471,7 +231744,7 @@ async function bootstrapArchitectureConfig(workspaceRoot, options) {
   }
   const layerRulesPath = ".archpilot/layer-rules.json";
   const layerRulesAbsolutePath = toAbsolutePath2(workspaceRoot, layerRulesPath);
-  if (await pathExists14(layerRulesAbsolutePath)) {
+  if (await pathExists15(layerRulesAbsolutePath)) {
     skippedExistingFiles.push(layerRulesPath);
   } else {
     await import_node_fs40.promises.writeFile(layerRulesAbsolutePath, renderLayerRulesConfig(modules), {
@@ -233550,7 +233823,7 @@ function safeReadDirEntries(directoryPath) {
     return [];
   }
 }
-function pathExists15(pathValue) {
+function pathExists16(pathValue) {
   try {
     fs48.accessSync(pathValue);
     return true;
@@ -233785,7 +234058,7 @@ function collectExplicitRoots(workspaceRoot) {
     "packages",
     "libs"
   ]) {
-    if (pathExists15(path53.join(workspaceRoot, ...root.split("/")))) {
+    if (pathExists16(path53.join(workspaceRoot, ...root.split("/")))) {
       roots.push(root);
     }
   }
@@ -233805,7 +234078,7 @@ function collectExplicitRoots(workspaceRoot) {
       `apps/${appEntry.name}/app`,
       `apps/${appEntry.name}/src/app`
     ]) {
-      if (pathExists15(path53.join(workspaceRoot, ...candidate.split("/")))) {
+      if (pathExists16(path53.join(workspaceRoot, ...candidate.split("/")))) {
         roots.push(candidate);
       }
     }
@@ -233825,7 +234098,7 @@ function collectExplicitRoots(workspaceRoot) {
         `${container}/${containerEntry.name}/src/application`,
         `${container}/${containerEntry.name}/src/infrastructure`
       ]) {
-        if (pathExists15(path53.join(workspaceRoot, ...candidate.split("/")))) {
+        if (pathExists16(path53.join(workspaceRoot, ...candidate.split("/")))) {
           roots.push(candidate);
         }
       }
@@ -233837,7 +234110,7 @@ function collectJavaPackageRoots(workspaceRoot) {
   const roots = [];
   for (const sourceRoot of ["src/main/java", "src/main/kotlin", "src"]) {
     const absoluteSourceRoot = path53.join(workspaceRoot, ...sourceRoot.split("/"));
-    if (!pathExists15(absoluteSourceRoot)) {
+    if (!pathExists16(absoluteSourceRoot)) {
       continue;
     }
     const queue = [
@@ -234644,7 +234917,7 @@ function safeReadText3(filePath, maxChars = 3e4) {
     return void 0;
   }
 }
-function pathExists16(pathValue) {
+function pathExists17(pathValue) {
   try {
     fs51.accessSync(pathValue);
     return true;
@@ -234750,7 +235023,7 @@ function collectCandidateRoots(workspaceRoot, topology) {
     }
   }
   for (const root of ["backend", "frontend"]) {
-    if (pathExists16(path56.join(workspaceRoot, root))) {
+    if (pathExists17(path56.join(workspaceRoot, root))) {
       roots.add(root);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archpilotlabs/archpilot",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Executable architecture governance CLI",
   "homepage": "https://archpilot.org",
   "bugs": {