@pratik7368patil/anchor-core 0.1.31 → 0.1.33

package/dist/index.js

@@ -617,8 +617,12 @@ CREATE TABLE IF NOT EXISTS org_cross_repo_edges (
   source_path TEXT NOT NULL,
   target_repo TEXT NOT NULL,
   target_path TEXT,
+  layer TEXT NOT NULL DEFAULT 'file',
   relationship TEXT NOT NULL,
   evidence_json TEXT NOT NULL,
+  match_reasons_json TEXT NOT NULL DEFAULT '[]',
+  evidence_count INTEGER NOT NULL DEFAULT 0,
+  is_weak INTEGER NOT NULL DEFAULT 0,
   confidence REAL NOT NULL,
   created_at TEXT NOT NULL
 );
@@ -643,6 +647,9 @@ CREATE TABLE IF NOT EXISTS org_api_consumers (
   consumer_path TEXT NOT NULL,
   contract TEXT NOT NULL,
   evidence_json TEXT NOT NULL,
+  match_reasons_json TEXT NOT NULL DEFAULT '[]',
+  evidence_count INTEGER NOT NULL DEFAULT 0,
+  is_weak INTEGER NOT NULL DEFAULT 0,
   confidence REAL NOT NULL,
   created_at TEXT NOT NULL
 );
@@ -667,6 +674,10 @@ CREATE TABLE IF NOT EXISTS org_graph_state (
   last_status TEXT NOT NULL DEFAULT 'unknown',
   last_duration_ms INTEGER,
   edge_count INTEGER NOT NULL DEFAULT 0,
+  visible_edge_count INTEGER NOT NULL DEFAULT 0,
+  weak_edge_count INTEGER NOT NULL DEFAULT 0,
+  edge_confidence_json TEXT NOT NULL DEFAULT '{"strong":0,"moderate":0,"weak":0}',
+  last_render_prep_ms INTEGER,
   api_contract_count INTEGER NOT NULL DEFAULT 0,
   api_consumer_count INTEGER NOT NULL DEFAULT 0,
   last_error TEXT,
@@ -707,8 +718,11 @@ CREATE INDEX IF NOT EXISTS idx_org_repositories_org ON org_repositories(org);
 CREATE INDEX IF NOT EXISTS idx_org_repo_state_org ON org_repo_state(org);
 CREATE INDEX IF NOT EXISTS idx_org_edges_source ON org_cross_repo_edges(org, source_repo);
 CREATE INDEX IF NOT EXISTS idx_org_edges_target ON org_cross_repo_edges(org, target_repo);
+CREATE INDEX IF NOT EXISTS idx_org_edges_layer ON org_cross_repo_edges(org, layer, confidence);
+CREATE INDEX IF NOT EXISTS idx_org_edges_repo_pair ON org_cross_repo_edges(org, layer, source_repo, target_repo, relationship);
 CREATE INDEX IF NOT EXISTS idx_org_consumers_provider ON org_api_consumers(org, provider_repo);
 CREATE INDEX IF NOT EXISTS idx_org_consumers_consumer ON org_api_consumers(org, consumer_repo);
+CREATE INDEX IF NOT EXISTS idx_org_consumers_contract ON org_api_consumers(org, contract);
 CREATE INDEX IF NOT EXISTS idx_org_anomalies_org ON org_anomaly_events(org, severity);
 CREATE INDEX IF NOT EXISTS idx_org_graph_state_status ON org_graph_state(org, last_status);
 
@@ -1783,6 +1797,41 @@ function initializeSchema(db) {
   ensureColumn(db, "sync_state", "graphql_cursor_reason", "TEXT");
   ensureColumn(db, "sync_state", "graphql_cursor_updated_at", "TEXT");
   ensureColumn(db, "code_index_state", "last_indexed_commit", "TEXT");
+  ensureColumn(db, "org_cross_repo_edges", "layer", "TEXT NOT NULL DEFAULT 'file'");
+  ensureColumn(
+    db,
+    "org_cross_repo_edges",
+    "match_reasons_json",
+    "TEXT NOT NULL DEFAULT '[]'"
+  );
+  ensureColumn(db, "org_cross_repo_edges", "evidence_count", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "org_cross_repo_edges", "is_weak", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(
+    db,
+    "org_api_consumers",
+    "match_reasons_json",
+    "TEXT NOT NULL DEFAULT '[]'"
+  );
+  ensureColumn(db, "org_api_consumers", "evidence_count", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "org_api_consumers", "is_weak", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "org_graph_state", "visible_edge_count", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(db, "org_graph_state", "weak_edge_count", "INTEGER NOT NULL DEFAULT 0");
+  ensureColumn(
+    db,
+    "org_graph_state",
+    "edge_confidence_json",
+    `TEXT NOT NULL DEFAULT '{"strong":0,"moderate":0,"weak":0}'`
+  );
+  ensureColumn(db, "org_graph_state", "last_render_prep_ms", "INTEGER");
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_org_edges_layer ON org_cross_repo_edges(org, layer, confidence)"
+  );
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_org_edges_repo_pair ON org_cross_repo_edges(org, layer, source_repo, target_repo, relationship)"
+  );
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_org_consumers_contract ON org_api_consumers(org, contract)"
+  );
 }
 function ensureColumn(db, tableName, columnName, definition) {
   const columns = db.prepare(`PRAGMA table_info(${tableName})`).all();
@@ -2695,19 +2744,36 @@ function insertPrCochangeTestLinks(db, repoId, filePaths) {
   }
 }
 function insertTestAwareness(db, repoId, repo, testFiles, testLinks, options = {}) {
+  const dedupedTestFilesByPath = /* @__PURE__ */ new Map();
+  for (const file of testFiles) dedupedTestFilesByPath.set(file.path, file);
+  const dedupedTestFiles = [...dedupedTestFilesByPath.values()];
+  const dedupedTestLinksByKey = /* @__PURE__ */ new Map();
+  for (const link of testLinks) {
+    const key = `${link.sourcePath}\0${link.testPath}\0${link.reason}`;
+    const existing = dedupedTestLinksByKey.get(key);
+    if (!existing || link.strength > existing.strength) {
+      dedupedTestLinksByKey.set(key, link);
+    }
+  }
+  const dedupedTestLinks = [...dedupedTestLinksByKey.values()];
   const insertTestFile = db.prepare(
     `INSERT INTO test_files
      (repo_id, path, language, size_bytes, content_hash, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?)`
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(repo_id, path) DO UPDATE SET
+       language = excluded.language,
+       size_bytes = excluded.size_bytes,
+       content_hash = excluded.content_hash,
+       updated_at = excluded.updated_at`
   );
   options.onProgress?.({
     stage: "writing_test_awareness",
     repo,
     current: 0,
-    total: testFiles.length,
+    total: dedupedTestFiles.length,
     kind: "test_files"
   });
-  for (const [index, file] of testFiles.entries()) {
+  for (const [index, file] of dedupedTestFiles.entries()) {
     insertTestFile.run(
       repoId,
       file.path,
@@ -2717,36 +2783,38 @@ function insertTestAwareness(db, repoId, repo, testFiles, testLinks, options = {
       file.updatedAt
     );
     const current = index + 1;
-    if (shouldEmitCodeWriteProgress(current, testFiles.length)) {
+    if (shouldEmitCodeWriteProgress(current, dedupedTestFiles.length)) {
       options.onProgress?.({
         stage: "writing_test_awareness",
         repo,
         current,
-        total: testFiles.length,
+        total: dedupedTestFiles.length,
         kind: "test_files"
       });
     }
   }
   const insertTestLink = db.prepare(
     `INSERT INTO test_links (repo_id, source_path, test_path, reason, strength)
-     VALUES (?, ?, ?, ?, ?)`
+     VALUES (?, ?, ?, ?, ?)
+     ON CONFLICT(repo_id, source_path, test_path, reason) DO UPDATE SET
+       strength = excluded.strength`
   );
   options.onProgress?.({
     stage: "writing_test_awareness",
     repo,
     current: 0,
-    total: testLinks.length,
+    total: dedupedTestLinks.length,
     kind: "test_links"
   });
-  for (const [index, link] of testLinks.entries()) {
+  for (const [index, link] of dedupedTestLinks.entries()) {
     insertTestLink.run(repoId, link.sourcePath, link.testPath, link.reason, link.strength);
     const current = index + 1;
-    if (shouldEmitCodeWriteProgress(current, testLinks.length)) {
+    if (shouldEmitCodeWriteProgress(current, dedupedTestLinks.length)) {
       options.onProgress?.({
         stage: "writing_test_awareness",
         repo,
         current,
-        total: testLinks.length,
+        total: dedupedTestLinks.length,
         kind: "test_links"
       });
     }
@@ -8687,6 +8755,24 @@ function resolveOrgForTool(org, baseDir = defaultOrgBaseDir()) {
 
 // src/org/database.ts
 import fs10 from "fs";
+var DEFAULT_EDGE_DISTRIBUTION = {
+  strong: 0,
+  moderate: 0,
+  weak: 0
+};
+function parseEdgeDistribution(value) {
+  if (!value) return { ...DEFAULT_EDGE_DISTRIBUTION };
+  try {
+    const parsed = JSON.parse(value);
+    return {
+      strong: Number(parsed.strong ?? 0),
+      moderate: Number(parsed.moderate ?? 0),
+      weak: Number(parsed.weak ?? 0)
+    };
+  } catch {
+    return { ...DEFAULT_EDGE_DISTRIBUTION };
+  }
+}
 function openOrgDatabase(org, baseDir) {
   const root = orgRoot(org, baseDir);
   const db = openAnchorDatabase(root, orgDatabasePath(org, baseDir));
@@ -8816,8 +8902,9 @@ function recordOrgGraphState(db, input) {
   db.prepare(
     `INSERT INTO org_graph_state
      (org, last_built_at, last_status, last_duration_ms, edge_count, api_contract_count,
-      api_consumer_count, last_error, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      api_consumer_count, visible_edge_count, weak_edge_count, edge_confidence_json,
+      last_render_prep_ms, last_error, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
      ON CONFLICT(org) DO UPDATE SET
        last_built_at = COALESCE(excluded.last_built_at, org_graph_state.last_built_at),
        last_status = excluded.last_status,
@@ -8825,6 +8912,10 @@ function recordOrgGraphState(db, input) {
        edge_count = excluded.edge_count,
        api_contract_count = excluded.api_contract_count,
        api_consumer_count = excluded.api_consumer_count,
+       visible_edge_count = excluded.visible_edge_count,
+       weak_edge_count = excluded.weak_edge_count,
+       edge_confidence_json = excluded.edge_confidence_json,
+       last_render_prep_ms = excluded.last_render_prep_ms,
        last_error = excluded.last_error,
        updated_at = excluded.updated_at`
   ).run(
@@ -8835,6 +8926,10 @@ function recordOrgGraphState(db, input) {
     input.edgeCount ?? 0,
     input.apiContractCount ?? 0,
     input.apiConsumerCount ?? 0,
+    input.visibleEdgeCount ?? input.edgeCount ?? 0,
+    input.weakEdgeCount ?? 0,
+    JSON.stringify(input.edgeConfidenceDistribution ?? DEFAULT_EDGE_DISTRIBUTION),
+    input.lastRenderPrepMs ?? null,
     input.error ?? null,
     now
   );
@@ -8849,6 +8944,10 @@ function getOrgGraphState(db, org) {
     lastStatus: row.last_status ?? void 0,
     lastDurationMs: row.last_duration_ms ?? void 0,
     edgeCount: row.edge_count ?? void 0,
+    visibleEdgeCount: row.visible_edge_count ?? void 0,
+    weakEdgeCount: row.weak_edge_count ?? void 0,
+    edgeConfidenceDistribution: parseEdgeDistribution(row.edge_confidence_json),
+    lastRenderPrepMs: row.last_render_prep_ms ?? void 0,
     apiContractCount: row.api_contract_count ?? void 0,
     apiConsumerCount: row.api_consumer_count ?? void 0,
     lastError: row.last_error ?? void 0
@@ -8861,7 +8960,19 @@ function count(db, table, where = "", params = []) {
 function getOrgGraphCounts(db, org) {
   initializeSchema(db);
   return {
-    edges: count(db, "org_cross_repo_edges", "WHERE org = ?", [org]),
+    edges: count(db, "org_cross_repo_edges", "WHERE org = ? AND layer = 'repo'", [org]),
+    visibleEdges: count(
+      db,
+      "org_cross_repo_edges",
+      "WHERE org = ? AND layer = 'repo' AND is_weak = 0",
+      [org]
+    ),
+    weakEdges: count(
+      db,
+      "org_cross_repo_edges",
+      "WHERE org = ? AND layer = 'repo' AND is_weak = 1",
+      [org]
+    ),
     apiContracts: count(db, "org_api_contracts", "WHERE org = ?", [org]),
     apiConsumers: count(db, "org_api_consumers", "WHERE org = ?", [org])
   };
@@ -8888,11 +8999,22 @@ function getOrgStatus(db, config, baseDir, options = {}) {
   const codeFileCount = count(db, "code_files");
   const codeChunkCount = count(db, "code_chunks");
   const wisdomUnitCount = count(db, "wisdom_units");
-  const crossRepoEdgeCount = count(db, "org_cross_repo_edges", "WHERE org = ?", [config.org]);
+  const crossRepoEdgeCount = count(
+    db,
+    "org_cross_repo_edges",
+    "WHERE org = ? AND layer = 'repo' AND is_weak = 0",
+    [config.org]
+  );
+  const graphWeakEdgeCount = count(
+    db,
+    "org_cross_repo_edges",
+    "WHERE org = ? AND layer = 'repo' AND is_weak = 1",
+    [config.org]
+  );
   const apiContractCount = count(db, "org_api_contracts", "WHERE org = ?", [config.org]);
   const apiConsumerCount = count(db, "org_api_consumers", "WHERE org = ?", [config.org]);
   const anomalyCount = count(db, "org_anomaly_events", "WHERE org = ?", [config.org]);
-  const graphState = db.prepare("SELECT * FROM org_graph_state WHERE org = ?").get(config.org);
+  const graphState = getOrgGraphState(db, config.org);
   let score = 0;
   const reasons = [];
   if (enabledRepos.length > 0) {
@@ -8936,10 +9058,14 @@ function getOrgStatus(db, config, baseDir, options = {}) {
     apiContractCount,
     apiConsumerCount,
     anomalyCount,
-    graphLastBuiltAt: graphState?.last_built_at ?? void 0,
-    graphLastStatus: graphState?.last_status ?? void 0,
-    graphLastDurationMs: graphState?.last_duration_ms ?? void 0,
-    graphLastError: graphState?.last_error ?? void 0,
+    graphLastBuiltAt: graphState?.lastBuiltAt,
+    graphLastStatus: graphState?.lastStatus,
+    graphLastDurationMs: graphState?.lastDurationMs,
+    graphLastError: graphState?.lastError,
+    graphVisibleEdgeCount: graphState?.visibleEdgeCount ?? crossRepoEdgeCount,
+    graphWeakEdgeCount: graphState?.weakEdgeCount ?? graphWeakEdgeCount,
+    graphRenderPrepMs: graphState?.lastRenderPrepMs,
+    graphEdgeConfidenceDistribution: graphState?.edgeConfidenceDistribution ?? { ...DEFAULT_EDGE_DISTRIBUTION },
     coverageScore: score,
     coverageGrade: grade(score),
     coverageReasons: reasons,
@@ -9243,6 +9369,34 @@ function orgCloneStateFromResult(org, repo, result) {
 import crypto9 from "crypto";
 import fs13 from "fs";
 import path23 from "path";
+var MIN_FILE_EDGE_CONFIDENCE = 0.62;
+var MIN_REPO_EDGE_CONFIDENCE = 0.7;
+var MIN_VISIBLE_EVIDENCE = 2;
+var MIN_API_CONSUMER_CONFIDENCE = 0.68;
+var MAX_EDGE_EVIDENCE = 8;
+var MAX_EDGE_REASONS = 6;
+var MAX_CONTRACTS_PER_CHUNK = 24;
+var CONTRACT_IGNORE = /* @__PURE__ */ new Set([
+  "api",
+  "v1",
+  "v2",
+  "v3",
+  "graphql",
+  "query",
+  "mutation",
+  "subscription",
+  "schema",
+  "route",
+  "routes",
+  "controller",
+  "client",
+  "request"
+]);
+var DEFAULT_EDGE_DISTRIBUTION2 = {
+  strong: 0,
+  moderate: 0,
+  weak: 0
+};
 function stableId(parts) {
   return crypto9.createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 32);
 }
@@ -9255,6 +9409,9 @@ function fileEvidence(repo, filePath, note) {
     note
   };
 }
+function evidenceJson(evidence) {
+  return JSON.stringify(evidence);
+}
 function readPackageManifest(repoPath) {
   const packagePath = path23.join(repoPath, "package.json");
   if (!fs13.existsSync(packagePath)) return void 0;
@@ -9300,19 +9457,53 @@ function parseJsonArray10(value) {
     return [];
   }
 }
-function extractContracts(text) {
-  const contracts = [];
-  const routeMatches = text.matchAll(/["'`]((?:\/api)?\/[A-Za-z0-9_./:{}-]{2,})["'`]/g);
-  for (const match of routeMatches) {
-    const route = match[1];
-    if (route && route.length <= 120 && !route.includes(" ")) contracts.push(route);
-  }
-  const gqlMatches = text.matchAll(/\b(query|mutation)\s+([A-Za-z0-9_]+)/g);
-  for (const match of gqlMatches) {
-    const operation = match[2];
-    if (operation) contracts.push(operation);
+function normalizeToken(value) {
+  return value.toLowerCase().replace(/[{}()[\],:"'`]/g, "").replace(/\/+/g, "/").replace(/\/$/g, "").replace(/^-+/g, "").trim();
+}
+function splitTokenSymbols(value) {
+  return value.split(/[^A-Za-z0-9_/-]+/).map((item) => normalizeToken(item)).filter((item) => item.length >= 3 && !CONTRACT_IGNORE.has(item)).slice(0, 12);
+}
+function normalizeContract(contract, kind) {
+  if (kind === "route") {
+    const normalized = normalizeToken(contract);
+    return normalized.startsWith("/") ? normalized : `/${normalized}`;
   }
-  return uniqueStrings(contracts).slice(0, 20);
+  return normalizeToken(contract);
+}
+function isGenericRoute(route) {
+  const normalized = normalizeToken(route);
+  if (!normalized.startsWith("/")) return true;
+  const segments = normalized.split("/").filter((segment) => segment && !segment.startsWith(":") && segment !== "*");
+  if (segments.length === 0) return true;
+  const informative = segments.filter((segment) => !CONTRACT_IGNORE.has(segment));
+  return informative.length < 1;
+}
+function extractContracts(text) {
+  const tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushToken = (rawValue, kind) => {
+    const sanitized = sanitizeHistoricalText(rawValue).slice(0, 180);
+    if (!sanitized) return;
+    const normalized = normalizeContract(sanitized, kind);
+    if (!normalized || CONTRACT_IGNORE.has(normalized)) return;
+    if (kind === "route" && isGenericRoute(normalized)) return;
+    const key = `${kind}\0${normalized}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    tokens.push({
+      raw: sanitized,
+      normalized,
+      kind,
+      symbols: splitTokenSymbols(sanitized)
+    });
+  };
+  const routeMatches = text.matchAll(/["'`]((?:\/api)?\/[A-Za-z0-9_./:{}-]{3,})["'`]/g);
+  for (const match of routeMatches) pushToken(match[1] ?? "", "route");
+  const gqlMatches = text.matchAll(/\b(query|mutation|subscription)\s+([A-Za-z][A-Za-z0-9_]{2,})/g);
+  for (const match of gqlMatches) pushToken(match[2] ?? "", "graphql");
+  const schemaMatches = text.matchAll(/\b(?:type|interface|enum|input)\s+([A-Z][A-Za-z0-9_]{2,})\b/g);
+  for (const match of schemaMatches) pushToken(match[1] ?? "", "schema");
+  return tokens.slice(0, MAX_CONTRACTS_PER_CHUNK);
 }
 function isApiProviderPath(filePath) {
   const normalized = filePath.toLowerCase();
@@ -9323,28 +9514,216 @@ function isApiProviderPath(filePath) {
 function isApiConsumerText(text) {
   return /\b(fetch|axios|ky|graphql|gql|client|sdk|request)\b/i.test(text);
 }
-function evidenceJson(evidence) {
-  return JSON.stringify(evidence);
-}
 function shouldEmitProgress3(current, total, interval = 100) {
   return current === 1 || current === total || current % interval === 0;
 }
 function resolveOptions(baseDirOrOptions) {
   return typeof baseDirOrOptions === "string" ? { baseDir: baseDirOrOptions } : baseDirOrOptions ?? {};
 }
+function clampConfidence(value) {
+  if (Number.isNaN(value)) return 0;
+  return Math.max(0, Math.min(0.99, Number(value.toFixed(3))));
+}
+function confidenceBucket(confidence) {
+  if (confidence >= 0.82) return "strong";
+  if (confidence >= 0.68) return "moderate";
+  return "weak";
+}
+function uniqueEvidenceRefs(evidence) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of evidence) {
+    const key = `${item.prNumber}|${item.prUrl}|${item.sourceType}|${item.filePath ?? ""}|${item.note ?? ""}`;
+    if (!map.has(key)) map.set(key, item);
+  }
+  return [...map.values()].slice(0, MAX_EDGE_EVIDENCE);
+}
+function mergeReasons(a, b) {
+  return uniqueStrings([...a, ...b]).slice(0, MAX_EDGE_REASONS);
+}
+function updateWeakFlag(edge, minConfidence2, minEvidence) {
+  edge.evidence = uniqueEvidenceRefs(edge.evidence);
+  edge.evidenceCount = edge.evidence.length;
+  edge.confidence = clampConfidence(edge.confidence);
+  edge.weak = edge.confidence < minConfidence2 || edge.evidenceCount < minEvidence;
+}
+function fileEdgeKey(edge) {
+  return [
+    edge.layer,
+    edge.sourceRepo,
+    edge.sourcePath,
+    edge.targetRepo,
+    edge.targetPath ?? "",
+    edge.relationship
+  ].join("\0");
+}
+function repoEdgeKey(edge) {
+  return [edge.layer, edge.sourceRepo, edge.targetRepo, edge.relationship].join("\0");
+}
+function upsertEdge(map, edge, minConfidence2, minEvidence) {
+  const layer = edge.layer ?? "file";
+  if (edge.sourceRepo === edge.targetRepo) return { inserted: false, updated: false };
+  const key = layer === "repo" ? repoEdgeKey({ ...edge, layer }) : fileEdgeKey({ ...edge, layer });
+  const existing = map.get(key);
+  if (!existing) {
+    const created = {
+      ...edge,
+      layer,
+      evidence: uniqueEvidenceRefs(edge.evidence),
+      matchReasons: mergeReasons([], edge.matchReasons),
+      evidenceCount: 0,
+      weak: false
+    };
+    updateWeakFlag(created, minConfidence2, minEvidence);
+    map.set(key, created);
+    return { inserted: true, updated: false };
+  }
+  const merged = {
+    ...existing,
+    sourcePath: existing.layer === "repo" ? "*" : existing.sourcePath,
+    targetPath: existing.layer === "repo" ? void 0 : existing.targetPath ?? edge.targetPath,
+    evidence: uniqueEvidenceRefs([...existing.evidence, ...edge.evidence]),
+    matchReasons: mergeReasons(existing.matchReasons, edge.matchReasons),
+    confidence: Math.max(existing.confidence, edge.confidence),
+    evidenceCount: 0,
+    weak: false
+  };
+  updateWeakFlag(merged, minConfidence2, minEvidence);
+  map.set(key, merged);
+  return { inserted: false, updated: true };
+}
+function scorePackageDependency(dependency) {
+  const normalized = sanitizeHistoricalText(dependency);
+  const reasons = ["exact_package_dependency"];
+  const confidence = normalized.startsWith("@") ? 0.93 : 0.9;
+  return { confidence, reasons };
+}
+function scoreImportEdge(input) {
+  let score = 0.58;
+  const reasons = ["cross_repo_import"];
+  if (input.specifier.includes("/")) {
+    score += 0.12;
+    reasons.push("qualified_specifier");
+  }
+  if (input.importedPath) {
+    score += 0.16;
+    reasons.push("resolved_import_path");
+  }
+  if (input.importedSymbols.length > 0) {
+    score += 0.11;
+    reasons.push("explicit_import_symbols");
+  }
+  return { confidence: clampConfidence(score), reasons };
+}
+function scoreContract(input) {
+  let score = 0.66;
+  if (input.token.kind === "route") score += 0.08;
+  if (input.token.kind === "graphql") score += 0.06;
+  if (input.token.kind === "schema") score += 0.03;
+  if (/\b(route|controller|api|schema|client)\b/i.test(input.filePath)) score += 0.05;
+  if (input.token.symbols.length > 0) score += 0.04;
+  return clampConfidence(score);
+}
+function overlapScore(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const set = new Set(a);
+  let overlaps = 0;
+  for (const value of b) {
+    if (set.has(value)) overlaps += 1;
+  }
+  return overlaps / Math.max(1, Math.min(a.length, b.length));
+}
+function scoreConsumerMatch(input) {
+  let score = 0.58;
+  const reasons = ["matched_contract_token"];
+  if (input.consumerToken.kind === input.contract.kind) {
+    score += 0.12;
+    reasons.push("matching_contract_kind");
+  }
+  const symbolOverlap = overlapScore(
+    uniqueStrings([...input.contract.symbols, ...splitTokenSymbols(input.contract.contract)]),
+    uniqueStrings([...input.chunkSymbols, ...input.consumerToken.symbols])
+  );
+  if (symbolOverlap > 0) {
+    score += Math.min(0.2, symbolOverlap * 0.22);
+    reasons.push("symbol_overlap");
+  }
+  if (input.contract.kind === "route" && input.consumerToken.raw.includes("/")) {
+    score += 0.08;
+    reasons.push("route_literal_match");
+  }
+  return { confidence: clampConfidence(score), reasons };
+}
+function aggregateRepoEdges(fileEdges) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const edge of fileEdges) {
+    const key = repoEdgeKey({
+      layer: "repo",
+      sourceRepo: edge.sourceRepo,
+      targetRepo: edge.targetRepo,
+      relationship: edge.relationship
+    });
+    const bucket = grouped.get(key) ?? [];
+    bucket.push(edge);
+    grouped.set(key, bucket);
+  }
+  const repoEdges = [];
+  for (const [key, group] of grouped.entries()) {
+    const [layerValue = "repo", sourceRepo = "", targetRepo = ""] = key.split("\0");
+    const relationship = group[0]?.relationship ?? "imports";
+    const confidences = group.map((edge) => edge.confidence);
+    const maxConfidence = Math.max(...confidences);
+    const avgConfidence = confidences.reduce((sum, value) => sum + value, 0) / confidences.length;
+    const repetitionBoost = Math.min(0.18, Math.log2(group.length + 1) * 0.06);
+    const confidence = clampConfidence(maxConfidence * 0.6 + avgConfidence * 0.25 + repetitionBoost);
+    const evidence = uniqueEvidenceRefs(group.flatMap((edge) => edge.evidence));
+    const matchReasons6 = mergeReasons([], group.flatMap((edge) => edge.matchReasons));
+    const repoEdge = {
+      org: group[0]?.org ?? "",
+      sourceRepo,
+      sourcePath: "*",
+      targetRepo,
+      targetPath: void 0,
+      layer: layerValue,
+      relationship,
+      evidence,
+      matchReasons: matchReasons6,
+      evidenceCount: 0,
+      weak: false,
+      confidence
+    };
+    updateWeakFlag(repoEdge, MIN_REPO_EDGE_CONFIDENCE, MIN_VISIBLE_EVIDENCE);
+    repoEdges.push(repoEdge);
+  }
+  return repoEdges.sort((a, b) => b.confidence - a.confidence);
+}
+function buildQuality(repoEdges, hiddenRepoEdges) {
+  const distribution = { ...DEFAULT_EDGE_DISTRIBUTION2 };
+  for (const edge of repoEdges) {
+    distribution[confidenceBucket(edge.confidence)] += 1;
+  }
+  return {
+    edgeConfidenceDistribution: distribution,
+    weakEdgesFiltered: hiddenRepoEdges.length,
+    minVisibleConfidence: MIN_REPO_EDGE_CONFIDENCE,
+    minVisibleEvidence: MIN_VISIBLE_EVIDENCE
+  };
+}
+function isVisibleRepoEdge(edge) {
+  return !edge.weak && edge.confidence >= MIN_REPO_EDGE_CONFIDENCE && edge.evidenceCount >= MIN_VISIBLE_EVIDENCE;
+}
 function rebuildOrgGraph(db, config, baseDirOrOptions) {
   initializeSchema(db);
   const options = resolveOptions(baseDirOrOptions);
   const startedAt = Date.now();
   try {
+    const enabledRepos = config.repos.filter((repo) => repo.enabled);
+    const repoByName = new Map(enabledRepos.map((repo) => [repo.fullName, repo]));
     options.onProgress?.({
       stage: "loading_package_manifests",
       org: config.org,
-      totalRepos: config.repos.filter((repo) => repo.enabled).length
+      totalRepos: enabledRepos.length
     });
     const packageNames = repoPackageNames(config, options.baseDir);
-    const enabledRepos = config.repos.filter((repo) => repo.enabled);
-    const repoByName = new Map(enabledRepos.map((repo) => [repo.fullName, repo]));
     const packageToRepo = /* @__PURE__ */ new Map();
     for (const [repo, names] of packageNames.entries()) {
       for (const name of names) packageToRepo.set(name, repo);
@@ -9355,31 +9734,22 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       repos: enabledRepos.length,
       packageNames: packageToRepo.size
     });
-    const edges = [];
-    const edgeKeys = /* @__PURE__ */ new Set();
-    const addEdge = (edge) => {
-      if (edge.sourceRepo === edge.targetRepo) return;
-      const key = [
-        edge.sourceRepo,
-        edge.sourcePath,
-        edge.targetRepo,
-        edge.targetPath ?? "",
-        edge.relationship
-      ].join("\0");
-      if (edgeKeys.has(key)) return;
-      edgeKeys.add(key);
-      edges.push(edge);
+    const fileEdgeMap = /* @__PURE__ */ new Map();
+    const addFileEdge = (edge) => {
+      upsertEdge(fileEdgeMap, { ...edge, layer: "file" }, MIN_FILE_EDGE_CONFIDENCE, 1);
     };
     enabledRepos.forEach((repo, index) => {
       const manifest = readPackageManifest(orgRepoLocalPath(config.org, repo, options.baseDir));
       for (const dependency of dependenciesFor(manifest)) {
         const targetRepo = packageToRepo.get(dependency);
         if (!targetRepo || targetRepo === repo.fullName) continue;
-        addEdge({
+        const score = scorePackageDependency(dependency);
+        addFileEdge({
           org: config.org,
           sourceRepo: repo.fullName,
           sourcePath: "package.json",
           targetRepo,
+          targetPath: "package.json",
           relationship: "depends_on_package",
           evidence: [
             fileEvidence(
@@ -9388,7 +9758,8 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
               `depends on ${sanitizeHistoricalText(dependency)}`
             )
           ],
-          confidence: 0.9
+          matchReasons: score.reasons,
+          confidence: score.confidence
         });
       }
       options.onProgress?.({
@@ -9397,7 +9768,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         current: index + 1,
         total: enabledRepos.length,
         repo: repo.fullName,
-        edges: edges.length
+        edges: fileEdgeMap.size
       });
     });
     options.onProgress?.({ stage: "loading_imports", org: config.org });
@@ -9412,7 +9783,13 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       const rootSpecifier = packageRootForSpecifier(item.specifier);
       const targetRepo = packageToRepo.get(rootSpecifier) ?? packageToRepo.get(item.specifier);
       if (targetRepo && targetRepo !== item.repo) {
-        addEdge({
+        const importedSymbols = parseJsonArray10(item.imported_symbols_json);
+        const score = scoreImportEdge({
+          specifier: item.specifier,
+          importedPath: item.imported_path,
+          importedSymbols
+        });
+        addFileEdge({
           org: config.org,
           sourceRepo: item.repo,
           sourcePath: item.source_path,
@@ -9426,7 +9803,8 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
               `imports ${sanitizeHistoricalText(rootSpecifier || item.specifier)}`
             )
           ],
-          confidence: parseJsonArray10(item.imported_symbols_json).length > 0 ? 0.88 : 0.76
+          matchReasons: score.reasons,
+          confidence: score.confidence
         });
       }
       if (shouldEmitProgress3(index + 1, imports.length)) {
@@ -9436,7 +9814,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           current: index + 1,
           total: imports.length,
           sourcePath: item.source_path,
-          edges: edges.length
+          edges: fileEdgeMap.size
         });
       }
     });
@@ -9450,25 +9828,27 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       (chunk) => repoByName.has(chunk.repo) && isApiProviderPath(chunk.file_path)
     );
     const apiContracts = [];
-    const contractKeys = /* @__PURE__ */ new Set();
+    const contractByKey = /* @__PURE__ */ new Map();
     const contractsByToken = /* @__PURE__ */ new Map();
     providerChunks.forEach((chunk, index) => {
-      for (const contract of extractContracts(chunk.sanitized_text)) {
-        const sanitizedContract = sanitizeHistoricalText(contract);
-        const key = [chunk.repo, chunk.file_path, sanitizedContract].join("\0");
-        if (contractKeys.has(key)) continue;
-        contractKeys.add(key);
-        const apiContract = {
+      for (const token of extractContracts(chunk.sanitized_text)) {
+        const key = [chunk.repo, chunk.file_path, token.kind, token.normalized].join("\0");
+        if (contractByKey.has(key)) continue;
+        const contract = {
           repo: chunk.repo,
           filePath: chunk.file_path,
-          contract: sanitizedContract,
-          evidence: [fileEvidence(chunk.repo, chunk.file_path, `defines ${sanitizedContract}`)],
-          confidence: 0.74
+          contract: token.raw,
+          normalizedContract: token.normalized,
+          kind: token.kind,
+          symbols: token.symbols,
+          evidence: [fileEvidence(chunk.repo, chunk.file_path, `defines ${token.raw}`)],
+          confidence: scoreContract({ token, filePath: chunk.file_path })
         };
-        apiContracts.push(apiContract);
-        const bucket = contractsByToken.get(sanitizedContract) ?? [];
-        bucket.push(apiContract);
-        contractsByToken.set(sanitizedContract, bucket);
+        contractByKey.set(key, contract);
+        apiContracts.push(contract);
+        const bucket = contractsByToken.get(contract.normalizedContract) ?? [];
+        bucket.push(contract);
+        contractsByToken.set(contract.normalizedContract, bucket);
       }
       if (shouldEmitProgress3(index + 1, providerChunks.length)) {
         options.onProgress?.({
@@ -9481,28 +9861,39 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
         });
       }
     });
-    const apiConsumers = [];
-    const consumerKeys = /* @__PURE__ */ new Set();
     const consumerChunks = chunks.filter(
       (chunk) => repoByName.has(chunk.repo) && isApiConsumerText(chunk.sanitized_text)
     );
+    const apiConsumers = [];
+    const consumerKeySet = /* @__PURE__ */ new Set();
     consumerChunks.forEach((chunk, index) => {
-      const consumerTokens = extractContracts(chunk.sanitized_text);
-      let chunkMatches = 0;
-      for (const token of consumerTokens) {
-        const contracts = contractsByToken.get(sanitizeHistoricalText(token));
-        if (!contracts) continue;
+      const chunkTokens = extractContracts(chunk.sanitized_text);
+      const chunkSymbols = parseJsonArray10(chunk.symbols_json);
+      let matchesForChunk = 0;
+      for (const consumerToken of chunkTokens) {
+        const contracts = contractsByToken.get(consumerToken.normalized);
+        if (!contracts?.length) continue;
         for (const contract of contracts) {
           if (chunk.repo === contract.repo) continue;
+          const score = scoreConsumerMatch({
+            consumerToken,
+            contract,
+            chunkSymbols
+          });
+          if (score.confidence < MIN_API_CONSUMER_CONFIDENCE) continue;
           const consumerKey = [
             contract.repo,
             contract.filePath,
             chunk.repo,
             chunk.file_path,
-            contract.contract
+            contract.normalizedContract
           ].join("\0");
-          if (consumerKeys.has(consumerKey)) continue;
-          consumerKeys.add(consumerKey);
+          if (consumerKeySet.has(consumerKey)) continue;
+          consumerKeySet.add(consumerKey);
+          const evidence = uniqueEvidenceRefs([
+            ...contract.evidence,
+            fileEvidence(chunk.repo, chunk.file_path, `consumes ${contract.contract}`)
+          ]);
           const consumer = {
             org: config.org,
             providerRepo: contract.repo,
@@ -9510,23 +9901,24 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
             consumerRepo: chunk.repo,
             consumerPath: chunk.file_path,
             contract: contract.contract,
-            evidence: [
-              ...contract.evidence,
-              fileEvidence(chunk.repo, chunk.file_path, `consumes ${contract.contract}`)
-            ],
-            confidence: 0.86
+            evidence,
+            matchReasons: mergeReasons([], score.reasons),
+            evidenceCount: evidence.length,
+            weak: score.confidence < MIN_API_CONSUMER_CONFIDENCE || evidence.length < MIN_VISIBLE_EVIDENCE,
+            confidence: score.confidence
           };
-          chunkMatches += 1;
           apiConsumers.push(consumer);
-          addEdge({
+          matchesForChunk += 1;
+          addFileEdge({
             org: config.org,
             sourceRepo: chunk.repo,
             sourcePath: chunk.file_path,
             targetRepo: contract.repo,
             targetPath: contract.filePath,
             relationship: "api_consumer",
-            evidence: consumer.evidence,
-            confidence: consumer.confidence
+            evidence,
+            matchReasons: score.reasons,
+            confidence: score.confidence
           });
         }
       }
@@ -9537,46 +9929,79 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           current: index + 1,
           total: consumerChunks.length,
           filePath: chunk.file_path,
-          matches: chunkMatches
+          matches: matchesForChunk
         });
       }
     });
+    const allFileEdges = [...fileEdgeMap.values()].sort((a, b) => b.confidence - a.confidence);
+    const repoEdges = aggregateRepoEdges(allFileEdges);
+    const visibleRepoEdges = repoEdges.filter(isVisibleRepoEdge);
+    const hiddenRepoEdges = repoEdges.filter((edge) => !isVisibleRepoEdge(edge));
+    const hiddenFileEdges = allFileEdges.filter(
+      (edge) => edge.confidence < MIN_FILE_EDGE_CONFIDENCE || edge.evidenceCount < 1
+    );
+    const visibleFileEdges = allFileEdges.filter((edge) => !hiddenFileEdges.includes(edge));
+    const quality = buildQuality(visibleRepoEdges, hiddenRepoEdges);
     options.onProgress?.({
       stage: "writing_org_graph",
       org: config.org,
-      edges: edges.length,
+      edges: repoEdges.length,
       apiContracts: apiContracts.length,
       apiConsumers: apiConsumers.length
     });
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const renderPrepStartedAt = Date.now();
     const transaction = db.transaction(() => {
       db.prepare("DELETE FROM org_cross_repo_edges WHERE org = ?").run(config.org);
       db.prepare("DELETE FROM org_api_contracts WHERE org = ?").run(config.org);
       db.prepare("DELETE FROM org_api_consumers WHERE org = ?").run(config.org);
       const insertEdge = db.prepare(
         `INSERT INTO org_cross_repo_edges
-         (id, org, source_repo, source_path, target_repo, target_path, relationship, evidence_json, confidence, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         (id, org, source_repo, source_path, target_repo, target_path, layer, relationship,
+          evidence_json, match_reasons_json, evidence_count, is_weak, confidence, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(id) DO UPDATE SET
+           source_path = excluded.source_path,
+           target_path = excluded.target_path,
+           layer = excluded.layer,
            evidence_json = excluded.evidence_json,
+           match_reasons_json = excluded.match_reasons_json,
+           evidence_count = excluded.evidence_count,
+           is_weak = excluded.is_weak,
            confidence = excluded.confidence,
            created_at = excluded.created_at`
       );
-      for (const [index, edge] of edges.entries()) {
+      const persistEdge = (edge) => {
         insertEdge.run(
-          `oge_${stableId([edge.org, edge.sourceRepo, edge.sourcePath, edge.targetRepo, edge.targetPath ?? "", edge.relationship])}`,
+          `oge_${stableId([
+            edge.org,
+            edge.layer,
+            edge.sourceRepo,
+            edge.sourcePath,
+            edge.targetRepo,
+            edge.targetPath ?? "",
+            edge.relationship
+          ])}`,
           edge.org,
           edge.sourceRepo,
           edge.sourcePath,
           edge.targetRepo,
           edge.targetPath ?? null,
+          edge.layer,
           edge.relationship,
           evidenceJson(edge.evidence),
+          JSON.stringify(edge.matchReasons),
+          edge.evidenceCount,
+          edge.weak ? 1 : 0,
           edge.confidence,
           now
         );
+      };
+      const persistedEdges = [...repoEdges, ...allFileEdges];
+      for (const [index, edge] of persistedEdges.entries()) {
+        persistEdge(edge);
         const current = index + 1;
-        if (shouldEmitProgress3(current, edges.length, 500)) {
+        if (shouldEmitProgress3(current, persistedEdges.length, 500)) {
           options.onProgress?.({
             stage: "writing_org_graph",
             org: config.org,
@@ -9584,7 +10009,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
             apiContracts: apiContracts.length,
             apiConsumers: apiConsumers.length,
             current,
-            total: edges.length,
+            total: persistedEdges.length,
             kind: "edges"
           });
         }
@@ -9601,7 +10026,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       );
       for (const [index, contract] of apiContracts.entries()) {
         insertContract.run(
-          `oac_${stableId([config.org, contract.repo, contract.filePath, contract.contract])}`,
+          `oac_${stableId([config.org, contract.repo, contract.filePath, contract.normalizedContract])}`,
           config.org,
           contract.repo,
           contract.filePath,
@@ -9615,7 +10040,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           options.onProgress?.({
             stage: "writing_org_graph",
             org: config.org,
-            edges: edges.length,
+            edges: persistedEdges.length,
             apiContracts: current,
             apiConsumers: apiConsumers.length,
             current,
@@ -9626,11 +10051,15 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       }
       const insertConsumer = db.prepare(
         `INSERT INTO org_api_consumers
-         (id, org, provider_repo, provider_path, consumer_repo, consumer_path, contract, evidence_json, confidence, created_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         (id, org, provider_repo, provider_path, consumer_repo, consumer_path, contract, evidence_json,
+          match_reasons_json, evidence_count, is_weak, confidence, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
          ON CONFLICT(id) DO UPDATE SET
            contract = excluded.contract,
            evidence_json = excluded.evidence_json,
+           match_reasons_json = excluded.match_reasons_json,
+           evidence_count = excluded.evidence_count,
+           is_weak = excluded.is_weak,
            confidence = excluded.confidence,
            created_at = excluded.created_at`
       );
@@ -9642,7 +10071,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
             consumer.providerPath ?? "",
             consumer.consumerRepo,
             consumer.consumerPath,
-            consumer.contract
+            normalizeToken(consumer.contract)
           ])}`,
           consumer.org,
           consumer.providerRepo,
@@ -9651,6 +10080,9 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           consumer.consumerPath,
           sanitizeHistoricalText(consumer.contract),
           evidenceJson(consumer.evidence),
+          JSON.stringify(consumer.matchReasons),
+          consumer.evidenceCount,
+          consumer.weak ? 1 : 0,
           consumer.confidence,
           now
         );
@@ -9659,7 +10091,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
           options.onProgress?.({
             stage: "writing_org_graph",
             org: config.org,
-            edges: edges.length,
+            edges: persistedEdges.length,
             apiContracts: apiContracts.length,
             apiConsumers: current,
             current,
@@ -9670,6 +10102,7 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       }
     });
     transaction();
+    const renderPrepMs = Date.now() - renderPrepStartedAt;
     const durationMs = Date.now() - startedAt;
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     recordOrgGraphState(db, {
@@ -9677,22 +10110,40 @@ function rebuildOrgGraph(db, config, baseDirOrOptions) {
       status: "success",
       builtAt: finishedAt,
       durationMs,
-      edgeCount: edges.length,
+      edgeCount: repoEdges.length,
+      visibleEdgeCount: visibleRepoEdges.length,
+      weakEdgeCount: hiddenRepoEdges.length,
+      edgeConfidenceDistribution: quality.edgeConfidenceDistribution,
+      lastRenderPrepMs: renderPrepMs,
       apiContractCount: apiContracts.length,
       apiConsumerCount: apiConsumers.length
     });
     options.onProgress?.({
       stage: "completed_org_graph",
       org: config.org,
-      edges: edges.length,
+      edges: repoEdges.length,
       apiContracts: apiContracts.length,
       apiConsumers: apiConsumers.length,
       durationMs
     });
     return {
-      edges,
+      edges: visibleRepoEdges,
+      repoEdges: visibleRepoEdges,
+      fileEdges: visibleFileEdges,
+      hiddenFileEdges,
+      hiddenRepoEdges,
       apiConsumers,
-      apiContracts,
+      apiContracts: apiContracts.map((contract) => ({
+        repo: contract.repo,
+        filePath: contract.filePath,
+        contract: contract.contract,
+        evidence: contract.evidence,
+        confidence: contract.confidence
+      })),
+      quality: {
+        ...quality,
+        lastRenderPrepMs: renderPrepMs
+      },
       durationMs
     };
   } catch (error) {
@@ -10036,6 +10487,8 @@ async function indexOrgRepos(db, config, options = {}) {
       org: config.org,
       status: "skipped",
       edgeCount: counts.edges,
+      visibleEdgeCount: counts.visibleEdges,
+      weakEdgeCount: counts.weakEdges,
       apiContractCount: counts.apiContracts,
       apiConsumerCount: counts.apiConsumers
     });
@@ -10045,7 +10498,12 @@ async function indexOrgRepos(db, config, options = {}) {
       command,
       reason: "Graph skipped because --no-graph was passed."
     });
-    graph = { ...counts, skipped: true };
+    graph = {
+      edges: counts.visibleEdges,
+      apiConsumers: counts.apiConsumers,
+      apiContracts: counts.apiContracts,
+      skipped: true
+    };
   } else {
     try {
       const rebuiltGraph = rebuildOrgGraph(db, config, {
@@ -10060,7 +10518,12 @@ async function indexOrgRepos(db, config, options = {}) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       const counts = getOrgGraphCounts(db, config.org);
-      graph = { ...counts, error: message };
+      graph = {
+        edges: counts.visibleEdges,
+        apiConsumers: counts.apiConsumers,
+        apiContracts: counts.apiContracts,
+        error: message
+      };
     }
   }
   recordOrgIndexRun(db, {
@@ -10104,6 +10567,15 @@ function parseEvidence2(value) {
     return [];
   }
 }
+function parseStringArray(value) {
+  if (!value) return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
 function fileEvidence2(repo, filePath, note) {
   return {
     prNumber: 0,
@@ -10135,7 +10607,7 @@ function affectedConsumers(db, org, repo, changedFiles) {
   const rows = db.prepare(
     `SELECT provider_repo, provider_path, consumer_repo, consumer_path, contract, evidence_json, confidence
        FROM org_api_consumers
-       WHERE org = ?`
+       WHERE org = ? AND is_weak = 0`
   ).all(org);
   return rows.filter((row) => !repo || row.provider_repo === repo || row.consumer_repo === repo).filter((row) => {
     if (changedFiles.length === 0) return true;
@@ -10150,14 +10622,18 @@ function affectedConsumers(db, org, repo, changedFiles) {
     consumerPath: row.consumer_path,
     contract: sanitizeHistoricalText(row.contract),
     evidence: parseEvidence2(row.evidence_json),
+    matchReasons: parseStringArray(row.match_reasons_json),
+    evidenceCount: row.evidence_count ?? parseEvidence2(row.evidence_json).length,
+    weak: (row.is_weak ?? 0) === 1,
     confidence: row.confidence
   }));
 }
 function affectedEdges(db, org, repo, changedFiles) {
   const rows = db.prepare(
-    `SELECT source_repo, source_path, target_repo, target_path, relationship, evidence_json, confidence
+    `SELECT source_repo, source_path, target_repo, target_path, layer, relationship, evidence_json,
+              match_reasons_json, evidence_count, is_weak, confidence
        FROM org_cross_repo_edges
-       WHERE org = ?`
+       WHERE org = ? AND layer = 'file'`
   ).all(org);
   return rows.filter((row) => !repo || row.source_repo === repo || row.target_repo === repo).filter((row) => {
     if (changedFiles.length === 0) return true;
@@ -10168,8 +10644,12 @@ function affectedEdges(db, org, repo, changedFiles) {
     sourcePath: row.source_path,
     targetRepo: row.target_repo,
     targetPath: row.target_path ?? void 0,
+    layer: row.layer,
     relationship: row.relationship,
     evidence: parseEvidence2(row.evidence_json),
+    matchReasons: parseStringArray(row.match_reasons_json),
+    evidenceCount: row.evidence_count ?? parseEvidence2(row.evidence_json).length,
+    weak: (row.is_weak ?? 0) === 1,
     confidence: row.confidence
   }));
 }
@@ -10487,7 +10967,7 @@ function evidenceLabel(evidence) {
   if (first.prNumber > 0) return `PR #${first.prNumber}`;
   return first.filePath ? `file ${first.filePath}` : first.note ?? "local file evidence";
 }
-function parseStringArray(value) {
+function parseStringArray2(value) {
   try {
     const parsed = JSON.parse(value);
     return Array.isArray(parsed) ? parsed.filter((item) => typeof item === "string") : [];
@@ -10534,7 +11014,7 @@ function getWisdom(db, input, limit) {
   const lowerTerms = queryTerms(input).map((term) => term.toLowerCase());
   return rows.filter((row) => matchesRepo(row.repo, input.repos)).map((row) => ({
     row,
-    score: rowScore(input, row.sanitized_text, parseStringArray(row.file_paths_json), [], lowerTerms)
+    score: rowScore(input, row.sanitized_text, parseStringArray2(row.file_paths_json), [], lowerTerms)
   })).filter((item) => item.score > 0 || (input.files ?? []).length === 0).sort((a, b) => b.score - a.score || b.row.confidence - a.row.confidence).slice(0, limit).map((item) => item.row);
 }
 function getCodeEvidence(db, input, limit) {
@@ -10551,7 +11031,7 @@ function getCodeEvidence(db, input, limit) {
       input,
       row.sanitized_text,
       [row.file_path],
-      parseStringArray(row.symbols_json),
+      parseStringArray2(row.symbols_json),
       lowerTerms
     )
   })).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((item) => item.row);
@@ -10569,7 +11049,7 @@ function getArchitecture(db, input, limit) {
     score: rowScore(
       input,
       row.summary_sanitized,
-      parseStringArray(row.source_files_json),
+      parseStringArray2(row.source_files_json),
       [],
       lowerTerms
     )
@@ -10580,9 +11060,10 @@ function findOrgApiConsumers(db, config, input) {
   const repoClause = input.repo ? " AND (provider_repo = ? OR consumer_repo = ?)" : "";
   const repoParams = input.repo ? [input.repo, input.repo] : [];
   const rows = db.prepare(
-    `SELECT provider_repo, provider_path, consumer_repo, consumer_path, contract, evidence_json, confidence
+    `SELECT provider_repo, provider_path, consumer_repo, consumer_path, contract, evidence_json,
+              match_reasons_json, evidence_count, is_weak, confidence
        FROM org_api_consumers
-       WHERE org = ?${repoClause}
+       WHERE org = ? AND is_weak = 0${repoClause}
        ORDER BY confidence DESC`
   ).all(config.org, ...repoParams);
   const limit = Math.max(1, Math.min(input.maxResults ?? 8, 25));
@@ -10598,6 +11079,9 @@ function findOrgApiConsumers(db, config, input) {
     consumerPath: row.consumer_path,
     contract: sanitizeHistoricalText(row.contract),
     evidence: parseEvidence3(row.evidence_json),
+    matchReasons: parseStringArray2(row.match_reasons_json ?? "[]"),
+    evidenceCount: row.evidence_count ?? parseEvidence3(row.evidence_json).length,
+    weak: (row.is_weak ?? 0) === 1,
     confidence: row.confidence
   }));
 }
@@ -10606,7 +11090,7 @@ function getOrgArchitectureMap(db, config, format = "mermaid") {
   const rows = db.prepare(
     `SELECT source_repo, source_path, target_repo, target_path, relationship, confidence
        FROM org_cross_repo_edges
-       WHERE org = ?
+       WHERE org = ? AND layer = 'repo' AND is_weak = 0
        ORDER BY confidence DESC, source_repo, target_repo`
   ).all(config.org);
   const nodes = uniqueStrings(rows.flatMap((row) => [row.source_repo, row.target_repo])).map(
@@ -10684,7 +11168,7 @@ function buildOrgContextResult(db, config, input) {
   if (architecture.length === 0) lines.push("- No matching architecture patterns found.");
   else {
     for (const pattern of architecture) {
-      const files = parseStringArray(pattern.source_files_json);
+      const files = parseStringArray2(pattern.source_files_json);
       lines.push(
         `- [${pattern.repo}] [${pattern.area}] ${pattern.summary_sanitized} Evidence: ${files[0] ?? "indexed current code"}.`
       );