fix(checks): canonicalize source architecture root

scripts/checks/source-architecture.mts

@@ -280,10 +280,13 @@ export function analyzeSourceArchitecture(
   repoRoot = REPO_ROOT,
   options: AnalyzeOptions = {},
 ): SourceArchitectureReport {
+  const canonicalRepoRoot = realpathSync(repoRoot);
   const scanRoots = options.scanRoots ?? DEFAULT_SCAN_ROOTS;
   const rootFileDirectories = options.rootFileDirectories ?? [];
   const absoluteFiles = [
-    ...new Set(scanRoots.flatMap((root) => [...walkSourceFiles(path.join(repoRoot, root))])),
+    ...new Set(
+      scanRoots.flatMap((root) => [...walkSourceFiles(path.join(canonicalRepoRoot, root))]),
+    ),
   ].sort();
   const sourceFiles = new Set(absoluteFiles);
   const edges = new Map<string, Set<string>>();
@@ -304,21 +307,27 @@ export function analyzeSourceArchitecture(
     }
   }
 
-  const files = absoluteFiles.map((file) => toRepoPath(repoRoot, file));
+  const files = absoluteFiles.map((file) => toRepoPath(canonicalRepoRoot, file));
   const fanIn = Object.fromEntries(
-    absoluteFiles.map((file) => [toRepoPath(repoRoot, file), fanInByAbsolutePath.get(file) ?? 0]),
+    absoluteFiles.map((file) => [
+      toRepoPath(canonicalRepoRoot, file),
+      fanInByAbsolutePath.get(file) ?? 0,
+    ]),
   );
   const fanOut = Object.fromEntries(
-    absoluteFiles.map((file) => [toRepoPath(repoRoot, file), edges.get(file)?.size ?? 0]),
+    absoluteFiles.map((file) => [toRepoPath(canonicalRepoRoot, file), edges.get(file)?.size ?? 0]),
   );
   const repoEdges = new Map(
     absoluteFiles.map((file) => [
-      toRepoPath(repoRoot, file),
-      new Set([...(edges.get(file) ?? [])].map((target) => toRepoPath(repoRoot, target))),
+      toRepoPath(canonicalRepoRoot, file),
+      new Set([...(edges.get(file) ?? [])].map((target) => toRepoPath(canonicalRepoRoot, target))),
     ]),
   );
   const rootFiles = Object.fromEntries(
-    rootFileDirectories.map((directory) => [directory, countRootFiles(repoRoot, directory)]),
+    rootFileDirectories.map((directory) => [
+      directory,
+      countRootFiles(canonicalRepoRoot, directory),
+    ]),
   );
 
   return {

test/source-architecture.test.ts

@@ -137,6 +137,31 @@ describe("source architecture budget (#7692)", () => {
     expect(report.fanIn).toMatchObject({ "bin/b.js": 1, "src/b.ts": 1 });
   });
 
+  test("reports repository-relative paths through an aliased repository root (#7692)", ({
+    resources,
+  }) => {
+    const root = resources.temporaryDirectory("nemoclaw-architecture-canonical-root-");
+    const aliasRoot = path.join(
+      resources.temporaryDirectory("nemoclaw-architecture-root-alias-"),
+      "repo",
+    );
+    writeModule(root, "src/a.ts", 'import "./b";\n');
+    writeModule(root, "src/b.ts", "export {};\n");
+    fs.symlinkSync(root, aliasRoot, process.platform === "win32" ? "junction" : "dir");
+
+    const report = analyzeSourceArchitecture(aliasRoot, {
+      scanRoots: ["src"],
+      rootFileDirectories: ["src"],
+    });
+
+    expect(report).toMatchObject({
+      files: ["src/a.ts", "src/b.ts"],
+      fanIn: { "src/a.ts": 0, "src/b.ts": 1 },
+      fanOut: { "src/a.ts": 1, "src/b.ts": 0 },
+      rootFiles: { src: 2 },
+    });
+  });
+
   test("ignores type-only dependency cycles", ({ resources }) => {
     const root = resources.temporaryDirectory("nemoclaw-architecture-types-");
     writeModule(root, "src/a.ts", 'import type { B } from "./b";\nexport type A = B;\n');