@mrciphersmith/keryx 0.2.9

package/src/gdgraph/find.ts

@@ -0,0 +1,107 @@
+import type { GraphData } from "./types";
+
+// Seed-file search over the file-level graph — the "find files about X" primitive
+// keryx lacked (agents kept mis-reaching for `gdgraph query "<nl>"`, which only
+// does cycles/orphans). Deterministic and offline: rank file nodes by how many
+// query terms match their path, with a basename boost, tie-broken by fan-in
+// (dependents) as an importance proxy. The result is a short seed list to feed
+// into `gdgraph affected <file>`.
+
+export interface FindResult {
+  path: string;
+  score: number;
+  matched: string[];
+  dependents: number;
+}
+
+export interface SymbolFindResult {
+  id: string;
+  name: string;
+  kind: string;
+  path: string;
+  startLine: number;
+  score: number;
+  matched: string[];
+}
+
+const STOP = new Set([
+  "and", "the", "of", "to", "a", "an", "in", "for", "or", "with", "on", "is", "at", "by",
+]);
+
+// Split a free-text query into distinct, meaningful search terms.
+export function tokenize(query: string): string[] {
+  return [
+    ...new Set(
+      query
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length >= 2 && !STOP.has(t)),
+    ),
+  ];
+}
+
+// Rank symbol nodes by name match — the precise half of `find` when the symbol
+// layer is active. Exact name match is boosted so `find "clonePipeline"` returns
+// the definition, not just path hits.
+export function findSymbols(graph: GraphData, query: string, limit = 15): SymbolFindResult[] {
+  const terms = tokenize(query);
+  const symbols = graph.symbols ?? [];
+  if (terms.length === 0 || symbols.length === 0) {
+    return [];
+  }
+
+  const results: SymbolFindResult[] = [];
+  for (const symbol of symbols) {
+    const nameLower = symbol.name.toLowerCase();
+    const matched = terms.filter((t) => nameLower.includes(t));
+    if (matched.length === 0) {
+      continue;
+    }
+    const exactBonus = terms.some((t) => nameLower === t) ? 20 : 0;
+    results.push({
+      id: symbol.id,
+      name: symbol.name,
+      kind: symbol.kind,
+      path: symbol.path,
+      startLine: symbol.startLine,
+      score: matched.length * 10 + exactBonus,
+      matched,
+    });
+  }
+  results.sort((a, b) => b.score - a.score || a.path.localeCompare(b.path) || a.startLine - b.startLine);
+  return results.slice(0, limit);
+}
+
+export function findNodes(graph: GraphData, query: string, limit = 20): FindResult[] {
+  const terms = tokenize(query);
+  if (terms.length === 0) {
+    return [];
+  }
+
+  // fan-in (dependents) per node id: how many edges point at it.
+  const fanIn = new Map<string, number>();
+  for (const edge of graph.edges) {
+    fanIn.set(edge.to, (fanIn.get(edge.to) ?? 0) + 1);
+  }
+
+  const results: FindResult[] = [];
+  for (const node of graph.nodes) {
+    if (node.kind !== "file") {
+      continue;
+    }
+    const lowerPath = node.path.toLowerCase();
+    const base = lowerPath.split("/").pop() ?? lowerPath;
+    const matched = terms.filter((t) => lowerPath.includes(t));
+    if (matched.length === 0) {
+      continue;
+    }
+    const baseHits = matched.filter((t) => base.includes(t)).length;
+    const score = matched.length * 10 + baseHits * 5;
+    results.push({ path: node.path, score, matched, dependents: fanIn.get(node.id) ?? 0 });
+  }
+
+  results.sort(
+    (a, b) => b.score - a.score || b.dependents - a.dependents || a.path.localeCompare(b.path),
+  );
+  return results.slice(0, limit);
+}

package/src/gdgraph/pagerank.ts

@@ -0,0 +1,129 @@
+// Pure personalized PageRank (specification.md §8.3; T-B6, B-4/B-5/B-7).
+//
+// Deterministic power-iteration with FIXED params (damping / iterations /
+// tolerance) and a total-order tie-break, so a re-run is byte-identical. No dep,
+// no network, no vectors/embeddings — a plain weighted graph centrality.
+//
+// Rank flows ALONG edges `from → to`, so a file imported/called by many
+// accumulates rank from its dependents — surfacing the central, widely-depended
+// files/symbols first. Dangling nodes (no out-edges) redistribute their mass via
+// the personalization vector, conserving total mass every iteration.
+
+export interface RankEdge {
+  from: string;
+  to: string;
+  weight: number;
+}
+
+export interface PageRankOptions {
+  damping: number;
+  iterations: number;
+  tolerance: number;
+  // Restart distribution: node id → mass. Missing/empty ⇒ uniform over nodes.
+  personalization?: Map<string, number>;
+}
+
+export interface RankedNode {
+  id: string;
+  score: number;
+}
+
+// Compute personalized PageRank over `nodes` with weighted `edges`. Returns a
+// total-ordered ranking (score desc, then id asc) — reproducible for identical
+// input + params.
+export function personalizedPageRank(
+  nodes: string[],
+  edges: RankEdge[],
+  options: PageRankOptions,
+): RankedNode[] {
+  const uniqueNodes = [...new Set(nodes)].sort();
+  const n = uniqueNodes.length;
+  if (n === 0) {
+    return [];
+  }
+
+  const index = new Map<string, number>();
+  uniqueNodes.forEach((id, i) => index.set(id, i));
+
+  // Out-weight totals + adjacency (only edges whose both endpoints are nodes).
+  const outWeight = new Array<number>(n).fill(0);
+  const incoming: Array<Array<{ src: number; weight: number }>> = Array.from(
+    { length: n },
+    () => [],
+  );
+  for (const edge of edges) {
+    const from = index.get(edge.from);
+    const to = index.get(edge.to);
+    if (from === undefined || to === undefined) {
+      continue;
+    }
+    const weight = edge.weight > 0 ? edge.weight : 0;
+    if (weight === 0) {
+      continue;
+    }
+    outWeight[from] = (outWeight[from] ?? 0) + weight;
+    (incoming[to] ??= []).push({ src: from, weight });
+  }
+
+  // Personalization / restart vector, normalized. Empty ⇒ uniform.
+  const restart = new Array<number>(n).fill(0);
+  const personalization = options.personalization;
+  let restartTotal = 0;
+  if (personalization && personalization.size > 0) {
+    for (const [id, mass] of personalization) {
+      const i = index.get(id);
+      if (i !== undefined && mass > 0) {
+        restart[i] = (restart[i] ?? 0) + mass;
+        restartTotal += mass;
+      }
+    }
+  }
+  if (restartTotal <= 0) {
+    for (let i = 0; i < n; i += 1) {
+      restart[i] = 1 / n;
+    }
+  } else {
+    for (let i = 0; i < n; i += 1) {
+      restart[i] = (restart[i] ?? 0) / restartTotal;
+    }
+  }
+
+  const damping = options.damping;
+  let rank = restart.slice();
+
+  for (let iter = 0; iter < options.iterations; iter += 1) {
+    // Mass held by dangling nodes (no out-weight) is redistributed via restart.
+    let danglingMass = 0;
+    for (let i = 0; i < n; i += 1) {
+      if ((outWeight[i] ?? 0) === 0) {
+        danglingMass += rank[i] ?? 0;
+      }
+    }
+
+    const next = new Array<number>(n).fill(0);
+    for (let i = 0; i < n; i += 1) {
+      let inbound = 0;
+      for (const { src, weight } of incoming[i] ?? []) {
+        const srcOut = outWeight[src] ?? 0;
+        if (srcOut > 0) {
+          inbound += ((rank[src] ?? 0) * weight) / srcOut;
+        }
+      }
+      const restartI = restart[i] ?? 0;
+      next[i] = (1 - damping) * restartI + damping * (inbound + danglingMass * restartI);
+    }
+
+    let delta = 0;
+    for (let i = 0; i < n; i += 1) {
+      delta += Math.abs((next[i] ?? 0) - (rank[i] ?? 0));
+    }
+    rank = next;
+    if (delta < options.tolerance) {
+      break;
+    }
+  }
+
+  return uniqueNodes
+    .map((id, i) => ({ id, score: rank[i] ?? 0 }))
+    .sort((a, b) => b.score - a.score || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}

package/src/gdgraph/path.test.ts

@@ -0,0 +1,56 @@
+import { expect, test } from "bun:test";
+import { findPath, labelNode } from "./path";
+import type { GraphData, SymbolNode } from "./types";
+
+function fileNode(path: string) {
+  return { id: path, kind: "file" as const, path, language: "typescript" as const };
+}
+function importEdge(from: string, to: string) {
+  return { id: `${from}->${to}`, from, to, kind: "imports" as const, specifier: to };
+}
+function sym(id: string, name: string, path: string, line: number): SymbolNode {
+  return { id, kind: "function", path, name, container: null, startLine: line, endLine: line + 3, language: "typescript" };
+}
+function call(from: string, to: string) {
+  return { id: `${from}=>${to}`, from, to, kind: "calls" as const, resolved: true };
+}
+
+// a.ts imports b.ts imports c.ts; symbols foo(a) -> bar(b)
+const GRAPH: GraphData = {
+  nodes: [fileNode("src/a.ts"), fileNode("src/b.ts"), fileNode("src/c.ts")],
+  edges: [importEdge("src/a.ts", "src/b.ts"), importEdge("src/b.ts", "src/c.ts")],
+  symbols: [sym("src/a.ts#foo", "foo", "src/a.ts", 1), sym("src/b.ts#bar", "bar", "src/b.ts", 2)],
+  calls: [call("src/a.ts#foo", "src/b.ts#bar")],
+};
+
+test("finds a file-to-file import path", () => {
+  const r = findPath(GRAPH, "src/a.ts", "src/c.ts");
+  expect(r.nodes).toEqual(["src/a.ts", "src/b.ts", "src/c.ts"]);
+});
+
+test("connects two symbols across the file+call layers", () => {
+  const r = findPath(GRAPH, "foo", "bar");
+  // foo -> bar via the resolved call edge (or foo -> a.ts -> b.ts -> bar)
+  expect(r.nodes[0]).toBe("src/a.ts#foo");
+  expect(r.nodes.at(-1)).toBe("src/b.ts#bar");
+  expect(r.nodes.length).toBeGreaterThanOrEqual(2);
+});
+
+test("resolves endpoints by symbol name and by file substring", () => {
+  const r = findPath(GRAPH, "foo", "c.ts");
+  expect(r.fromResolved).toContain("src/a.ts#foo");
+  expect(r.toResolved).toContain("src/c.ts");
+  expect(r.nodes.length).toBeGreaterThan(0);
+});
+
+test("returns empty nodes when an endpoint cannot be resolved", () => {
+  const r = findPath(GRAPH, "foo", "does-not-exist-xyz");
+  expect(r.toResolved).toEqual([]);
+  expect(r.nodes).toEqual([]);
+});
+
+test("labelNode renders symbols as name (path:line) and files verbatim", () => {
+  const byId = new Map(GRAPH.symbols!.map((s) => [s.id, s]));
+  expect(labelNode("src/a.ts#foo", byId)).toBe("foo (src/a.ts:1)");
+  expect(labelNode("src/c.ts", byId)).toBe("src/c.ts");
+});

package/src/gdgraph/path.ts

@@ -0,0 +1,112 @@
+import type { GraphData, SymbolNode } from "./types";
+import { resolveSymbols } from "./symbol";
+
+// "How are A and B connected?" — shortest path over a UNIFIED graph that spans
+// both layers: file import edges, symbol call edges, and file→symbol "defines"
+// bridges (a symbol's owning file). Endpoints may be file paths or symbol names.
+// Undirected BFS so a connection is found regardless of edge direction; the
+// rendered chain still shows the concrete hops. Pure over the in-memory graph.
+
+export interface PathResult {
+  fromToken: string;
+  toToken: string;
+  fromResolved: string[];
+  toResolved: string[];
+  // Node-id chain from an A-endpoint to a B-endpoint, or [] when unconnected.
+  nodes: string[];
+}
+
+// Resolve an endpoint token to candidate node ids: exact file path, then symbol
+// name matches, then file-path substring.
+function resolveEndpoint(graph: GraphData, token: string): string[] {
+  const filePaths = new Set(
+    graph.nodes.filter((n) => n.kind === "file").map((n) => n.path),
+  );
+  if (filePaths.has(token)) {
+    return [token];
+  }
+  const bySymbol = resolveSymbols(graph.symbols ?? [], token, 10).map((s) => s.id);
+  if (bySymbol.length > 0) {
+    return bySymbol;
+  }
+  return [...filePaths].filter((p) => p.includes(token));
+}
+
+function buildAdjacency(graph: GraphData): Map<string, Set<string>> {
+  const adj = new Map<string, Set<string>>();
+  const link = (a: string, b: string): void => {
+    if (!adj.has(a)) adj.set(a, new Set());
+    if (!adj.has(b)) adj.set(b, new Set());
+    adj.get(a)!.add(b);
+    adj.get(b)!.add(a);
+  };
+
+  for (const edge of graph.edges) {
+    link(edge.from, edge.to); // file → file imports
+  }
+  const symbolIds = new Set((graph.symbols ?? []).map((s) => s.id));
+  for (const symbol of graph.symbols ?? []) {
+    link(symbol.path, symbol.id); // file defines symbol (layer bridge)
+  }
+  for (const call of graph.calls ?? []) {
+    if (call.kind === "calls" && symbolIds.has(call.from) && symbolIds.has(call.to)) {
+      link(call.from, call.to); // resolved symbol → symbol call
+    }
+  }
+  return adj;
+}
+
+function bfs(adj: Map<string, Set<string>>, starts: string[], goals: Set<string>): string[] {
+  const prev = new Map<string, string | null>();
+  const queue: string[] = [];
+  for (const start of starts) {
+    if (!prev.has(start)) {
+      prev.set(start, null);
+      queue.push(start);
+    }
+  }
+
+  let found: string | null = null;
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    if (goals.has(current)) {
+      found = current;
+      break;
+    }
+    for (const next of adj.get(current) ?? []) {
+      if (!prev.has(next)) {
+        prev.set(next, current);
+        queue.push(next);
+      }
+    }
+  }
+
+  if (found === null) {
+    return [];
+  }
+  const chain: string[] = [];
+  let node: string | null = found;
+  while (node !== null) {
+    chain.unshift(node);
+    node = prev.get(node) ?? null;
+  }
+  return chain;
+}
+
+export function findPath(graph: GraphData, fromToken: string, toToken: string): PathResult {
+  const fromResolved = resolveEndpoint(graph, fromToken);
+  const toResolved = resolveEndpoint(graph, toToken);
+  if (fromResolved.length === 0 || toResolved.length === 0) {
+    return { fromToken, toToken, fromResolved, toResolved, nodes: [] };
+  }
+  const adj = buildAdjacency(graph);
+  const nodes = bfs(adj, fromResolved, new Set(toResolved));
+  return { fromToken, toToken, fromResolved, toResolved, nodes };
+}
+
+// Render a node id as a human label: "name (path:line)" for a symbol, else the
+// file path verbatim.
+export function labelNode(nodeId: string, symbolsById: Map<string, SymbolNode>): string {
+  const symbol = symbolsById.get(nodeId);
+  return symbol ? `${symbol.name} (${symbol.path}:${symbol.startLine})` : nodeId;
+}

package/src/gdgraph/query.ts

@@ -0,0 +1,133 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import type { CallEdge, GraphData, GraphEdge, GraphNode, SymbolNode } from "./types";
+import { resolveGraphTarget } from "./target";
+
+export async function loadGraph(projectRoot: string): Promise<GraphData> {
+  const storageDir = path.join(projectRoot, ".metaproject", "data", "gdgraph", "storage");
+  const nodes = await readJsonl<GraphNode>(path.join(storageDir, "nodes.jsonl"));
+  const edges = await readJsonl<GraphEdge>(path.join(storageDir, "edges.jsonl"));
+  // B1 symbol layer: loaded ONLY if present. Missing files ⇒ empty/omitted layer
+  // (never an error — mirrors `readJsonl` tolerance). File-level graph unchanged.
+  const symbols = await readJsonl<SymbolNode>(path.join(storageDir, "symbols.jsonl"));
+  const calls = await readJsonl<CallEdge>(path.join(storageDir, "calls.jsonl"));
+  const graph: GraphData = { nodes, edges };
+  if (symbols.length > 0) {
+    graph.symbols = symbols;
+  }
+  if (calls.length > 0) {
+    graph.calls = calls;
+  }
+  return graph;
+}
+
+export function getOrphans(graph: GraphData): string[] {
+  const inbound = new Set(
+    graph.edges.filter((edge) => edge.kind !== "unresolved").map((edge) => edge.to),
+  );
+  const outbound = new Set(
+    graph.edges.filter((edge) => edge.kind !== "unresolved").map((edge) => edge.from),
+  );
+  return graph.nodes
+    .map((node) => node.path)
+    .filter((file) => !inbound.has(file) && !outbound.has(file))
+    .sort();
+}
+
+export function getAffected(
+  graph: GraphData,
+  target: string,
+): { target: string; dependencies: string[]; dependents: string[] } {
+  // Exact-then-suffix, refusing an ambiguous suffix (see ./target.ts). Shared
+  // with `computeAffected` so the two entry points cannot drift apart.
+  const resolvedTarget = resolveGraphTarget(graph, target);
+
+  return {
+    target: resolvedTarget,
+    dependencies: graph.edges
+      .filter((edge) => edge.kind !== "unresolved" && edge.from === resolvedTarget)
+      .map((edge) => edge.to)
+      .sort(),
+    dependents: graph.edges
+      .filter((edge) => edge.kind !== "unresolved" && edge.to === resolvedTarget)
+      .map((edge) => edge.from)
+      .sort(),
+  };
+}
+
+export function getCycles(graph: GraphData): string[][] {
+  const adjacency = new Map<string, string[]>();
+  for (const node of graph.nodes) {
+    adjacency.set(node.path, []);
+  }
+  for (const edge of graph.edges) {
+    if (edge.kind !== "imports") {
+      continue;
+    }
+    adjacency.get(edge.from)?.push(edge.to);
+  }
+
+  const cycles = new Map<string, string[]>();
+  const visited = new Set<string>();
+  const stack = new Set<string>();
+  const pathStack: string[] = [];
+
+  function visit(node: string): void {
+    visited.add(node);
+    stack.add(node);
+    pathStack.push(node);
+
+    for (const next of adjacency.get(node) ?? []) {
+      if (!visited.has(next)) {
+        visit(next);
+        continue;
+      }
+
+      if (stack.has(next)) {
+        const start = pathStack.indexOf(next);
+        const cycle = [...pathStack.slice(start), next];
+        cycles.set(canonicalCycle(cycle), cycle);
+      }
+    }
+
+    stack.delete(node);
+    pathStack.pop();
+  }
+
+  for (const node of graph.nodes.map((item) => item.path)) {
+    if (!visited.has(node)) {
+      visit(node);
+    }
+  }
+
+  return [...cycles.values()].sort((a, b) => a.join("").localeCompare(b.join("")));
+}
+
+async function readJsonl<T>(filePath: string): Promise<T[]> {
+  let content: string;
+  try {
+    content = await readFile(filePath, "utf8");
+  } catch {
+    // Absent file ⇒ empty layer (the symbol layer is optional, and a missing
+    // core file should degrade rather than crash graph navigation).
+    return [];
+  }
+  const items: T[] = [];
+  for (const line of content.split("\n").map((entry) => entry.trim()).filter(Boolean)) {
+    try {
+      items.push(JSON.parse(line) as T);
+    } catch {
+      // Ignore malformed JSONL records so one bad line does not break graph navigation.
+    }
+  }
+  return items;
+}
+
+function canonicalCycle(cycle: string[]): string {
+  const withoutLast = cycle.slice(0, -1);
+  const variants = withoutLast.map((_, index) => [
+    ...withoutLast.slice(index),
+    ...withoutLast.slice(0, index),
+  ].join("->"));
+  return variants.sort()[0] ?? cycle.join("->");
+}

package/src/gdgraph/repomap.test.ts

@@ -0,0 +1,110 @@
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect, test } from "bun:test";
+import { DEFAULT_GDGRAPH_CONFIG, mergeGdgraphConfig } from "./config";
+import { personalizedPageRank } from "./pagerank";
+import { buildRankEdges, computeRepomap, estimateTokens, writeRepomap } from "./repomap";
+import type { GraphData } from "./types";
+
+const FIXTURE_DIR = fileURLToPath(new URL("../../fixtures/repomap/", import.meta.url));
+
+async function loadFixtureGraph(): Promise<GraphData> {
+  const raw = JSON.parse(await readFile(path.join(FIXTURE_DIR, "graph.json"), "utf8"));
+  return { nodes: raw.nodes, edges: raw.edges };
+}
+
+async function loadExpected(): Promise<any> {
+  return JSON.parse(await readFile(path.join(FIXTURE_DIR, "expected.json"), "utf8"));
+}
+
+test("AC3.3 — top-ranked entries match expected centrality ordering", async () => {
+  const graph = await loadFixtureGraph();
+  const expected = await loadExpected();
+  const nodes = graph.nodes.filter((node) => node.kind === "file").map((node) => node.path);
+  const edges = buildRankEdges(graph, DEFAULT_GDGRAPH_CONFIG);
+  const ranked = personalizedPageRank(nodes, edges, {
+    damping: DEFAULT_GDGRAPH_CONFIG.repomap.damping,
+    iterations: DEFAULT_GDGRAPH_CONFIG.repomap.iterations,
+    tolerance: DEFAULT_GDGRAPH_CONFIG.repomap.tolerance,
+  });
+  expect(ranked.map((entry) => entry.id)).toEqual(expected.centralityOrder);
+});
+
+test("AC3.2 — repomap fits the token budget with a stable omission marker", async () => {
+  const graph = await loadFixtureGraph();
+  const expected = await loadExpected();
+  const config = mergeGdgraphConfig({ repomap: { tokenBudget: expected.tokenBudget } });
+  const result = computeRepomap(graph, config, {});
+
+  expect(result.tokens).toBeLessThanOrEqual(expected.tokenBudget);
+  expect(estimateTokens(result.content)).toBeLessThanOrEqual(expected.tokenBudget);
+  expect(result.entries.map((entry) => entry.path)).toEqual(expected.topWithinBudget);
+  expect(result.omitted).toBe(expected.omitted);
+  expect(result.content).toContain(`… ${expected.omitted} entries omitted …`);
+});
+
+test("AC3.2 — --budget override is honored and bounds the output", async () => {
+  const graph = await loadFixtureGraph();
+  const result = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, { budget: 30 });
+  expect(result.tokens).toBeLessThanOrEqual(30);
+  expect(result.omitted).toBeGreaterThan(0);
+});
+
+test("AC3.4 — re-running repomap yields a byte-identical file", async () => {
+  const graph = await loadFixtureGraph();
+  const root = await mkdtemp(path.join(tmpdir(), "keryx-repomap-"));
+  try {
+    const config = mergeGdgraphConfig({ repomap: { tokenBudget: 40 } });
+    const first = await writeRepomap(root, graph, config, {});
+    const firstBytes = await readFile(first.path, "utf8");
+    const second = await writeRepomap(root, graph, config, {});
+    const secondBytes = await readFile(second.path, "utf8");
+    expect(secondBytes).toBe(firstBytes);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("AC3.6 — --seed biases personalization; seeded/unseeded each reproducible", async () => {
+  const graph = await loadFixtureGraph();
+  const unseeded = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, {});
+  const seeded = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, { seed: ["src/a.ts"] });
+  const seededAgain = computeRepomap(graph, DEFAULT_GDGRAPH_CONFIG, { seed: ["src/a.ts"] });
+
+  // Each run reproducible.
+  expect(seeded.content).toBe(seededAgain.content);
+  // Seeding on a.ts lifts it above its unseeded rank position.
+  const unseededRank = unseeded.entries.findIndex((entry) => entry.path === "src/a.ts");
+  const seededRank = seeded.entries.findIndex((entry) => entry.path === "src/a.ts");
+  expect(seededRank).toBeGreaterThanOrEqual(0);
+  expect(seededRank).toBeLessThan(unseededRank === -1 ? Number.MAX_SAFE_INTEGER : unseededRank + 1);
+});
+
+test("AC3.5 — repomap ranks symbol-aware weights when the layer is present", async () => {
+  const graph = await loadFixtureGraph();
+  // Add a tiny symbol layer so buildRankEdges exercises calls/defines weights.
+  const withSymbols: GraphData = {
+    ...graph,
+    symbols: [
+      {
+        id: "src/core.ts#run",
+        kind: "function",
+        path: "src/core.ts",
+        name: "run",
+        container: null,
+        startLine: 1,
+        endLine: 2,
+        language: "typescript",
+        signature: "run()",
+      },
+    ],
+    calls: [
+      { id: "d", from: "src/core.ts", to: "src/core.ts#run", kind: "defines", resolved: true },
+    ],
+  };
+  const result = computeRepomap(withSymbols, DEFAULT_GDGRAPH_CONFIG, { budget: 400 });
+  const core = result.entries.find((entry) => entry.path === "src/core.ts");
+  expect(core?.symbols).toEqual(["run()"]);
+});