@@ -19,14 +19,20 @@ const MAX_API_SCORE = 3;
 /**
  * How much a module looks like a way in: +3 for an entry name (`index`,
  * `main`, `server`, `app`, `cli`, any extension), +1 per exported function
- * nobody calls (at most 3), -1 per directory below a leading `src/`.
+ * nobody calls (at most 3), -1 per directory below a leading `src/`, the
+ * path taken from `root` (a package's directory; `""` for the repository).
  */
 const entryScore = (
   module: ModuleNode,
   graph: CodeGraph,
-  called: ReadonlySet<string>
+  called: ReadonlySet<string>,
+  root: string
 ): number => {
-  const segments = module.id.split("/");
+  const path =
+    root !== "" && module.id.startsWith(`${root}/`)
+      ? module.id.slice(root.length + 1)
+      : module.id;
+  const segments = path.split("/");
   const basename = segments.at(-1) ?? "";
   const directories = segments.slice(0, -1);
   const depth =
@@ -54,14 +60,16 @@ const byPath = (a: ModuleNode, b: ModuleNode): number => {
  * The modules the entrance leads to, best first, among `modules` (all of
  * the graph's by default; a zone's for its hub), counting only imports and
  * calls between those. Every module nobody imports is one (nothing else
- * leads there), ranked by `entryScore`, ties by path. Modules only cycles
- * reach then add the best of what is still out of reach, one at a time,
- * until imports from the entries reach every module. Never empty for a
- * non-empty `modules`.
+ * leads there), ranked by `entryScore` with paths taken from `root` (the
+ * zone's package directory), ties by path. Modules only cycles reach then
+ * add the best of what is still out of reach, one at a time, until imports
+ * from the entries reach every module. Never empty for a non-empty
+ * `modules`.
  */
 const entryModules = (
   graph: CodeGraph,
-  modules: readonly ModuleNode[] = graph.modules
+  modules: readonly ModuleNode[] = graph.modules,
+  root = ""
 ): readonly ModuleNode[] => {
   const inside = new Set(modules.map((module) => module.id));
   const links = new Map(
@@ -81,7 +89,10 @@ const entryModules = (
     )
   );
   const scores = new Map(
-    modules.map((module) => [module.id, entryScore(module, graph, called)])
+    modules.map((module) => [
+      module.id,
+      entryScore(module, graph, called, root),
+    ])
   );
   const ranked = (group: readonly ModuleNode[]): readonly ModuleNode[] =>
     group.toSorted(
 
@@ -3,7 +3,7 @@ import { generateWorld } from "@repo/world-generator";
 import { validateGraph } from "@repo/world-generator/graph";
 import { describe, expect, it } from "vitest";
 
-import { fixtureGraph, packageNode, withPackages } from "./fixture";
+import { fixtureGraph, importOf, packageNode, withPackages } from "./fixture";
 import { ENTRANCE_ID, modulePortalId } from "./ids";
 import { zoneEntranceGraph, zoneGraph } from "./zone-graph";
 import { zonesOf } from "./zones";
@@ -131,6 +131,35 @@ describe("zoneGraph", () => {
     placesEverything(world);
   });
 
+  it("scores entry modules by their path inside the package", () => {
+    const graph = withPackages(
+      fixtureGraph(
+        {
+          path: "packages/lib/helper.ts",
+          functions: [],
+          imports: [importOf("packages/lib/src/api.ts")],
+        },
+        {
+          path: "packages/lib/src/api.ts",
+          functions: [{ name: "fetchAll", exported: true }],
+          imports: [importOf("packages/lib/helper.ts")],
+        },
+        { path: "apps/web/main.ts", functions: [] }
+      ),
+      packageNode("@repo/lib", "packages/lib"),
+      packageNode("web", "apps/web")
+    );
+    const lib = zonesOf(graph).find((zone) => zone.name === "@repo/lib");
+    if (lib === undefined) {
+      throw new Error("Expected a zone for @repo/lib");
+    }
+    // In the cycle, src/api.ts (API, no depth inside the package) beats
+    // helper.ts; scored from the repository root they would tie on depth.
+    expect((zoneGraph(graph, lib).portals ?? []).map((p) => p.to)).toEqual([
+      "packages/lib/src/api.ts",
+    ]);
+  });
+
   it("keeps whole paths for the modules no package owns", () => {
     const graph = withPackages(
       fixtureGraph(
 
@@ -28,13 +28,14 @@ const zoneEntranceGraph = (
 /**
  * A zone's hub chain, labelled with the package's name, holding a module
  * portal to each of the zone's entry modules (`entryModules` among its own
- * modules), each labelled with its path inside the package.
+ * modules, scored from the package's directory), each labelled with its
+ * path inside the package.
  */
 const zoneGraph = (graph: CodeGraph, zone: Zone): WorldGraph =>
   hubChainGraph(
     zone.id,
     zone.name,
-    entryModules(graph, zone.modules).map((module) => ({
+    entryModules(graph, zone.modules, zone.pkg?.dir ?? "").map((module) => ({
       id: module.id,
       label:
         zone.pkg === null