pi-mega-compact 0.13.0 → 0.13.2

package/src/dedup-engine.test/_helpers.ts

@@ -0,0 +1,79 @@
+/**
+ * Shared test fixtures/harness for the dedup-engine split test files.
+ *
+ * Extracted from dedup-engine.test.ts: tmp-dir lifecycle (beforeEach/afterEach),
+ * store construction, message builders, and the compact + okReason helpers.
+ * `currentTmpDir` is module-scoped per test-file subprocess (the runner isolates
+ * each file in its own node --test process), so tests never collide.
+ */
+import { beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { compactSession } from "../engine.js";
+import { VectorStore } from "../vectorStore.js";
+import { loadDedupConfig, type DedupConfigShape } from "../config/dedup.js";
+import type { EngineMessage } from "../types.js";
+
+function mkTmpDir(): string {
+	return fs.mkdtempSync(path.join(os.tmpdir(), "mc-dedup-"));
+}
+
+let currentTmpDir: string | undefined;
+
+beforeEach(() => {
+	currentTmpDir = mkTmpDir();
+});
+
+afterEach(() => {
+	if (currentTmpDir && fs.existsSync(currentTmpDir)) {
+		fs.rmSync(currentTmpDir, { recursive: true, force: true });
+	}
+	currentTmpDir = undefined;
+});
+
+function baseConfig(): DedupConfigShape {
+	return loadDedupConfig();
+}
+
+export function makeStore(over: Partial<DedupConfigShape> = {}): VectorStore {
+	return new VectorStore({
+		stateDir: currentTmpDir,
+		config: { ...baseConfig(), ...over },
+	});
+}
+
+export function makeMsg(role: EngineMessage["role"], text: string): EngineMessage {
+	return { role, text };
+}
+
+export function buildConversation(n: number, prefix = "turn"): EngineMessage[] {
+	const out: EngineMessage[] = [];
+	for (let i = 0; i < n; i++) {
+		const role = i % 2 === 0 ? "user" : "assistant";
+		out.push(
+			makeMsg(
+				role,
+				`${prefix} ${i + 1}: ${role} discusses implementation of feature ${i + 1} in src/module${i + 1}.ts and considers tradeoffs.`,
+			),
+		);
+	}
+	return out;
+}
+
+export function compactFull(
+	store: VectorStore,
+	sessionId: string,
+	messages: EngineMessage[],
+	keepFrom?: number,
+): ReturnType<typeof compactSession> {
+	return compactSession({ sessionId, messages, keepFrom: keepFrom ?? messages.length }, store);
+}
+
+export function okReason(reason: string | undefined, expected: string[]): void {
+	assert.ok(
+		reason !== undefined && expected.includes(reason),
+		`expected dedupReason one of ${expected.join(", ")}, got ${reason}`,
+	);
+}

package/src/e2e.test/_helpers.ts

@@ -0,0 +1,59 @@
+/**
+ * Shared helpers for the src/e2e.test split files.
+ *
+ * Extracted from the top of src/e2e.test.ts: isolated temp-store management,
+ * the config-overridable VectorStore factory (store), the message builder
+ * (msg), and the direct SQLite seeder (seedDirect) that bypasses online dedup.
+ *
+ * Relative paths are one directory deeper than the original file, hence
+ * `../vectorStore.js` etc.
+ */
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { VectorStore, computeRegionHash } from "../vectorStore.js";
+import { loadDedupConfig, type DedupConfigShape } from "../config/dedup.js";
+import { defaultEmbedder } from "../embedder.js";
+import { upsertCheckpoint } from "../store/sqlite.js";
+import type { EngineMessage } from "../types.js";
+import type { StoredCheckpoint } from "../store.js";
+
+export const baseTmp = mkdtempSync(join(tmpdir(), "mc-e2e-"));
+let counter = 0;
+
+export function storeDir(): string {
+	return join(baseTmp, `run-${counter++}`);
+}
+
+/** Build an isolated VectorStore with a fresh state dir + optional config overrides. */
+export function store(over: Partial<DedupConfigShape> = {}): VectorStore {
+	const dir = storeDir();
+	const config: DedupConfigShape = { ...loadDedupConfig(), ...over };
+	return new VectorStore({ stateDir: dir, config });
+}
+
+export function msg(role: EngineMessage["role"], text: string, toolName?: string, input?: string, output?: string): EngineMessage {
+	return toolName
+		? { role, text, toolName, input: input ?? text, output: output ?? text }
+		: { role, text };
+}
+
+/** Seed a checkpoint directly into SQLite (bypasses online dedup tiers). */
+export function seedDirect(dir: string, sessionId: string, rows: { id: string; text: string; tok: number; ts?: number }[]): void {
+	const e = defaultEmbedder();
+	for (const r of rows) {
+		const cp: StoredCheckpoint = {
+			checkpointId: r.id,
+			sessionId,
+			summary: r.text,
+			keyDecisions: [],
+			nextSteps: [],
+			filesModified: [],
+			tokenEstimate: r.tok,
+			regionHash: computeRegionHash(r.text),
+			embedding: e.embed(r.text),
+			timestamp: r.ts ?? 1,
+		};
+		upsertCheckpoint(cp, dir);
+	}
+}

package/src/embedder.ts

@@ -18,6 +18,9 @@ export type Vector = number[];
 export interface Embedder {
   /** Dimensionality of vectors this embedder produces. */
   readonly dim: number;
+  /** Discriminator: "trigram" | "http". Lets callers branch on the embedder
+   *  backend without instanceof checks (e.g. HyDE is http-only). */
+  readonly kind: string;
   embed(text: string): Vector;
 }
 
@@ -65,6 +68,7 @@ function fnv1a(str: string): number {
  * from corrupting stored vectors. Set MEGACOMPACT_EMBED_CACHE=0 to disable.
  */
 export class TrigramEmbedder implements Embedder {
+  readonly kind = "trigram";
   readonly dim: number;
   private readonly seed: number;
   /** @type {Map<string, Vector>} */

package/src/httpEmbedder.ts

@@ -203,6 +203,7 @@ try {
 `;
 
 export class HttpEmbedder implements Embedder {
+  readonly kind = "http";
   private readonly url: string;
   private readonly apiKey?: string;
   private readonly headers: Record<string, string>;
@@ -219,6 +220,12 @@ export class HttpEmbedder implements Embedder {
     return this.resolvedDim;
   }
 
+  /** Derive the Ollama /api/chat endpoint from the embedding endpoint's origin
+   *  (same host:port as the BYO embedding server). Used by HyDE (src/hyde.ts). */
+  get chatUrl(): string {
+    return new URL("/api/chat", this.url).href;
+  }
+
   embed(text: string): Vector {
     const body = JSON.stringify({ input: [text] });
     const headers: Record<string, string> = {

package/src/hyde.ts

@@ -0,0 +1,162 @@
+/**
+ * hyde.ts — Hypothetical Document Embeddings for LLM-backed recall (S43 re-plan).
+ *
+ * When an HttpEmbedder (localhost Ollama) is active and RAG_HYDE_ENABLED, we
+ * generate a hypothetical answer to the recall query via the Ollama /api/chat
+ * endpoint, embed it, and RRF-fuse the resulting search hits with the raw-query
+ * hits. This gives a stronger recall signal than TF-IDF term expansion (S57 B1)
+ * when an LLM is available. Non-fatal: any error → returns "" (caller uses raw-only).
+ *
+ * PREVENT-PI-004: reuses HttpEmbedder's loopback-child-process pattern (spawnSync
+ * with its own event loop). The remote opt-in (MEGACOMPACT_ALLOW_REMOTE_EMBEDDER)
+ * governs this too — derived chat URL is on the same host as the embedding URL.
+ */
+
+import { spawnSync } from "node:child_process"; // guardrails-allow PREVENT-PI-004: localhost-only LLM generation — reuses HttpEmbedder's loopback exception; governed by MEGACOMPACT_ALLOW_REMOTE_EMBEDDER
+import type { Embedder } from "./embedder.js";
+import type { SearchHit } from "./vectorStore.js";
+import { reciprocalRankFusion, type RankedItem } from "./queryReformulation/rrf.js";
+import { Logger } from "./log.js";
+
+/** Narrow view of an embedder that can produce LLM chat output (HttpEmbedder). */
+interface LlmEmbedder {
+  readonly chatUrl: string;
+}
+
+// Inline worker: POSTs to the derived Ollama /api/chat endpoint in a child
+// process (its own event loop, so spawnSync blocks without a fetch deadlock).
+const CHAT_WORKER = String.raw`
+const u = process.env.MC_HYDE_URL, b = process.env.MC_HYDE_BODY;
+try {
+  const r = await fetch(u, { method: "POST", headers: { "content-type": "application/json" }, body: b }); // guardrails-allow PREVENT-PI-004: localhost-only /api/chat — same host as BYO embedding endpoint; remote only via MEGACOMPACT_ALLOW_REMOTE_EMBEDDER
+  const out = JSON.stringify({ status: r.status, ok: r.ok, text: await r.text() });
+  process.stdout.write(out);
+} catch (e) {
+  process.stdout.write(JSON.stringify({ error: String(e && e.message ? e.message : e) }));
+}
+`;
+
+/**
+ * Generate a hypothetical answer document for a recall query via the LLM-hosted
+ * /api/chat endpoint (HttpEmbedder only). Returns "" when the embedder has no
+ * LLM chat surface (TrigramEmbedder) or on ANY error. Non-fatal — the caller
+ * falls back to raw-query recall only.
+ */
+/** Best-effort structured failure log. Never throws (PyDE is non-fatal). */
+function logHydeFailure(reason: string): void {
+  try {
+    new Logger().warn("hyde_failed", { reason });
+  } catch {
+    /* ignore — logging must never break recall */
+  }
+}
+
+export function generateHypotheticalDoc(query: string, embedder: Embedder): string {
+  if (embedder.kind !== "http") return ""; // TrigramEmbedder: no LLM surface
+  const url = (embedder as Embedder & Partial<LlmEmbedder>).chatUrl;
+  if (!url) {
+    logHydeFailure("no chatUrl");
+    return "";
+  }
+
+  const model = process.env.MEGACOMPACT_HYDE_MODEL ?? "llama3.2";
+  const content =
+    "Answer this question about the codebase concisely (2-3 sentences): " + query;
+  const body = JSON.stringify({
+    model,
+    messages: [{ role: "user", content }],
+    stream: false,
+  });
+
+  let res;
+  try {
+    res = spawnSync(process.execPath, ["-e", CHAT_WORKER], { // guardrails-allow PREVENT-PI-004: localhost-only LLM generation — reuses HttpEmbedder's loopback exception; governed by MEGACOMPACT_ALLOW_REMOTE_EMBEDDER
+      encoding: "utf8",
+      env: { ...process.env, MC_HYDE_URL: url, MC_HYDE_BODY: body },
+      timeout: 20000,
+    });
+  } catch {
+    logHydeFailure("spawn-error");
+    return "";
+  }
+  if (
+    res.error ||
+    typeof res.stdout !== "string" ||
+    res.stdout.length === 0 ||
+    res.status !== 0
+  ) {
+    logHydeFailure("child-error");
+    return "";
+  }
+
+  let parsed: { status?: number; ok?: boolean; text?: unknown; error?: string };
+  try {
+    parsed = JSON.parse(res.stdout);
+  } catch {
+    logHydeFailure("non-json");
+    return "";
+  }
+  if (parsed.error || !parsed.ok || (parsed.status ?? 0) >= 400) {
+    logHydeFailure("chat-http");
+    return "";
+  }
+  // Ollama /api/chat (stream:false) returns { message: { role, content } }.
+  let messageBody: unknown;
+  try {
+    if (typeof parsed.text === "string") messageBody = JSON.parse(parsed.text);
+    else {
+      logHydeFailure("empty-body");
+      return "";
+    }
+  } catch {
+    logHydeFailure("non-json-body");
+    return "";
+  }
+  if (!messageBody || typeof messageBody !== "object") {
+    logHydeFailure("bad-body");
+    return "";
+  }
+  const msg = (messageBody as Record<string, unknown>).message;
+  if (!msg || typeof msg !== "object") {
+    logHydeFailure("no-message");
+    return "";
+  }
+  const contentOut = (msg as Record<string, unknown>).content;
+  if (typeof contentOut !== "string" || contentOut.length === 0) {
+    logHydeFailure("empty-content");
+    return "";
+  }
+
+  return contentOut;
+}
+
+/**
+ * RRF-fuse two recall hit lists (raw-query and hypothetical-doc) into a single
+ * deduplicated ranking, sliced to `limit`. Order is by fused RRF score.
+ */
+export function fuseRecallHits(
+  raw: SearchHit[],
+  hyde: SearchHit[],
+  limit: number,
+): SearchHit[] {
+  const byId = new Map<string, SearchHit>();
+  const rawRanked: RankedItem[] = raw.map((h, i) => {
+    byId.set(h.checkpoint.checkpointId, h);
+    return { id: h.checkpoint.checkpointId, rank: i + 1 };
+  });
+  const hydeRanked: RankedItem[] = hyde.map((h, i) => {
+    if (!byId.has(h.checkpoint.checkpointId)) {
+      byId.set(h.checkpoint.checkpointId, h);
+    }
+    return { id: h.checkpoint.checkpointId, rank: i + 1 };
+  });
+
+  const fused = reciprocalRankFusion([rawRanked, hydeRanked]);
+  const out: SearchHit[] = [];
+  for (const item of fused) {
+    const hit = byId.get(item.id);
+    if (hit) out.push(hit);
+    if (out.length >= limit) break;
+  }
+  return out;
+}

package/src/importance.test/_helpers.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared helpers for the importance.test split files.
+ * Extracted from src/importance.test.ts: the fixed NOW epoch constant.
+ */
+export const NOW = 1_700_000_000_000; // fixed epoch ms for determinism

package/src/memoryGraph/sources/checkpoints.ts

@@ -0,0 +1,99 @@
+/**
+ * checkpoints.ts — checkpoint node builder (extracted from sources.ts).
+ */
+import type { DatabaseSync } from "node:sqlite";
+import type { MemoryGraphNode, MemoryGraphEdge } from "../../memoryGraph.js";
+import { decodeEmbedding } from "../../store/sqlite/utils.js";
+import { cosineSimilarity } from "../embedding.js";
+import { safeJsonCount } from "./helpers.js";
+
+export function buildCheckpointNodes(
+  db: DatabaseSync,
+  sessionId: string,
+  nodes: MemoryGraphNode[],
+  edges: MemoryGraphEdge[],
+): void {
+  const rows = sessionId
+    ? (db
+        .prepare(
+          `SELECT id, session_id, summary, token_estimate, timestamp,
+                  dedup_status, topic_summary, key_decisions,
+                  normalized_text, embedding_blob
+           FROM context_chunks
+           WHERE session_id = ?
+           ORDER BY timestamp ASC`,
+        )
+        .all(sessionId) as Array<Record<string, unknown>>)
+    : (db
+        .prepare(
+          `SELECT id, session_id, summary, token_estimate, timestamp,
+                  dedup_status, topic_summary, key_decisions,
+                  normalized_text, embedding_blob
+           FROM context_chunks
+           ORDER BY timestamp ASC`,
+        )
+        .all() as Array<Record<string, unknown>>);
+
+  if (rows.length === 0) return;
+
+  let prevId: string | null = null;
+  for (const row of rows) {
+    const id = String(row.id);
+    const rowSessionId = sessionId || String(row.session_id ?? "");
+    const summary = String(row.summary ?? "");
+    const node: MemoryGraphNode = {
+      id,
+      sessionId: rowSessionId,
+      label: id,
+      summaryTruncated: summary.length > 200 ? summary.slice(0, 197) + "..." : summary,
+      tokenEstimate: Number(row.token_estimate ?? 0),
+      timestamp: Number(row.timestamp ?? Date.now()),
+      dedupStatus: row.dedup_status ? String(row.dedup_status) : undefined,
+      raptorLevel: 0,
+      topicSummary: row.topic_summary ? String(row.topic_summary) : undefined,
+      decisionCount: row.key_decisions ? safeJsonCount(String(row.key_decisions)) : 0,
+      textSnippet: summary.length > 200 ? summary.slice(0, 197) + "..." : summary,
+      nodeType: "checkpoint",
+    };
+    nodes.push(node);
+
+    if (prevId !== null) {
+      edges.push({ source: prevId, target: id, weight: 1.0, type: "temporal" });
+    }
+    prevId = id;
+  }
+
+  addCheckpointSemanticEdges(rows, edges);
+}
+
+function addCheckpointSemanticEdges(
+  rows: Array<Record<string, unknown>>,
+  edges: MemoryGraphEdge[],
+): void {
+  const embeddings: Array<{ id: string; blob: Buffer | null }> = [];
+  for (const row of rows) {
+    const blob = row.embedding_blob;
+    embeddings.push({
+      id: String(row.id),
+      blob: blob instanceof Buffer ? blob : null,
+    });
+  }
+
+  for (let i = 0; i < embeddings.length; i++) {
+    if (!embeddings[i].blob) continue;
+    const a = decodeEmbedding(embeddings[i].blob!);
+    for (let j = i + 1; j < embeddings.length; j++) {
+      if (!embeddings[j].blob) continue;
+      const b = decodeEmbedding(embeddings[j].blob!);
+      const sim = cosineSimilarity(a, b);
+      if (sim > 0) {
+        edges.push({
+          source: embeddings[i].id,
+          target: embeddings[j].id,
+          weight: sim,
+          type: "semantic",
+        });
+      }
+    }
+  }
+}

package/src/memoryGraph/sources/edges.ts

@@ -0,0 +1,23 @@
+/**
+ * edges.ts — edge deduplication (extracted from sources.ts).
+ */
+import type { MemoryGraphEdge } from "../../memoryGraph.js";
+
+export function deduplicateEdges(edges: MemoryGraphEdge[]): MemoryGraphEdge[] {
+  const seen = new Map<string, MemoryGraphEdge>();
+
+  for (const e of edges) {
+    const keyA = `${e.source}|${e.target}`;
+    const keyB = `${e.target}|${e.source}`;
+    const existing = seen.get(keyA) ?? seen.get(keyB);
+    if (existing) {
+      if (e.weight > existing.weight) {
+        seen.set(keyA, e);
+      }
+    } else {
+      seen.set(keyA, e);
+    }
+  }
+
+  return [...seen.values()];
+}

package/src/memoryGraph/sources/flags.ts

@@ -0,0 +1,26 @@
+/**
+ * flags.ts — memory-graph feature-flag / env helpers (extracted from sources.ts).
+ */
+
+export function flagEnabled(name: string, def: boolean): boolean {
+  const v = process.env[name];
+  if (v === undefined) return def;
+  return v === "true" || v === "1";
+}
+
+export function areTurnsEnabled(): boolean {
+  return flagEnabled("MEGACOMPACT_MEMORY_GRAPH_SEED_TURNS", true);
+}
+
+export function isTurnContentEnabled(): boolean {
+  return flagEnabled("MEGACOMPACT_MEMORY_GRAPH_SEED_TURN_CONTENT", true) &&
+         flagEnabled("MEGACOMPACT_DB_MIRROR", false);
+}
+
+export function isTurnContentFlaggedOn(): boolean {
+  return flagEnabled("MEGACOMPACT_MEMORY_GRAPH_SEED_TURN_CONTENT", true);
+}
+
+export function areMemoriesEnabled(): boolean {
+  return flagEnabled("MEGACOMPACT_MEMORY_GRAPH_SEED_MEMORIES", true);
+}

package/src/memoryGraph/sources/helpers.ts

@@ -0,0 +1,13 @@
+/**
+ * helpers.ts — shared micro-helpers (extracted from sources.ts).
+ */
+
+export function safeJsonCount(raw: string | null | undefined): number {
+  if (!raw || typeof raw !== "string") return 0;
+  try {
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr.length : 0;
+  } catch {
+    return 0;
+  }
+}

package/src/memoryGraph/sources/memories.ts

@@ -0,0 +1,108 @@
+/**
+ * memories.ts — memory node builder (extracted from sources.ts).
+ */
+import type { DatabaseSync } from "node:sqlite";
+import type { MemoryGraphNode, MemoryGraphEdge } from "../../memoryGraph.js";
+import { getOrComputeEmbedding, cosineSimilarity } from "../embedding.js";
+
+export function buildMemoryNodes(
+  db: DatabaseSync,
+  sessionId: string,
+  nodes: MemoryGraphNode[],
+  edges: MemoryGraphEdge[],
+): void {
+  const existingIds = new Set(nodes.map((n) => n.id));
+  const rows = db
+    .prepare(
+      `SELECT id, content, source_turn, created_at
+       FROM memories
+       ORDER BY created_at ASC`,
+    )
+    .all() as Array<Record<string, unknown>>;
+
+  if (rows.length === 0) return;
+
+  const memoryNodes: MemoryGraphNode[] = [];
+
+  for (const row of rows) {
+    const id = `mem:${String(row.id)}`;
+    if (existingIds.has(id)) continue;
+    existingIds.add(id);
+
+    const content = row.content ? String(row.content) : "";
+    const snippet = content.length > 200 ? content.slice(0, 197) + "..." : content;
+
+    const node: MemoryGraphNode = {
+      id,
+      sessionId,
+      label: `Memory ${String(row.id)}`,
+      summaryTruncated: snippet,
+      tokenEstimate: content.length,
+      timestamp: row.created_at ? Number(row.created_at) : Date.now(),
+      dedupStatus: undefined,
+      raptorLevel: 0,
+      topicSummary: undefined,
+      decisionCount: 0,
+      textSnippet: snippet,
+      nodeType: "memory",
+      epochId: undefined,
+    };
+    memoryNodes.push(node);
+  }
+
+  if (memoryNodes.length > 1) {
+    const embeddings = memoryNodes.map((n) => {
+      try {
+        return { id: n.id, vec: getOrComputeEmbedding(db, n.textSnippet) };
+      } catch {
+        return { id: n.id, vec: null as number[] | null };
+      }
+    });
+
+    for (let i = 0; i < embeddings.length; i++) {
+      if (!embeddings[i].vec) continue;
+      for (let j = i + 1; j < embeddings.length; j++) {
+        if (!embeddings[j].vec) continue;
+        const sim = cosineSimilarity(embeddings[i].vec!, embeddings[j].vec!);
+        if (sim > 0) {
+          edges.push({
+            source: embeddings[i].id,
+            target: embeddings[j].id,
+            weight: sim,
+            type: "semantic",
+          });
+        }
+      }
+    }
+
+    crossLinkMemoryToCheckpoints(memoryNodes, nodes, edges);
+  }
+
+  nodes.push(...memoryNodes);
+}
+
+function crossLinkMemoryToCheckpoints(
+  memoryNodes: MemoryGraphNode[],
+  allNodes: MemoryGraphNode[],
+  edges: MemoryGraphEdge[],
+): void {
+  for (const mn of memoryNodes) {
+    let bestNeighbor: { id: string; diff: number } | null = null;
+    for (const n of allNodes) {
+      if (n.nodeType !== "checkpoint" && n.nodeType !== "turn-content") continue;
+      if (n.id === mn.id) continue;
+      const diff = Math.abs(mn.timestamp - n.timestamp);
+      if (bestNeighbor === null || diff < bestNeighbor.diff) {
+        bestNeighbor = { id: n.id, diff };
+      }
+    }
+    if (bestNeighbor) {
+      edges.push({
+        source: mn.id,
+        target: bestNeighbor.id,
+        weight: 0.85,
+        type: "semantic",
+      });
+    }
+  }
+}

package/src/memoryGraph/sources/raptor.ts

@@ -0,0 +1,37 @@
+/**
+ * raptor.ts — RAPTOR annotations that enrich checkpoint nodes (extracted from
+ * sources.ts).
+ */
+import type { MemoryGraphNode, MemoryGraphEdge } from "../../memoryGraph.js";
+import { listRaptorNodes } from "../../store/sqlite/raptor.js";
+
+export function addRaptorAnnotations(
+  sessionId: string,
+  stateDir: string,
+  nodes: MemoryGraphNode[],
+  edges: MemoryGraphEdge[],
+): void {
+  const raptorNodes = listRaptorNodes(sessionId, stateDir);
+  if (!raptorNodes || raptorNodes.length === 0) return;
+
+  const nodeIndex = new Map<string, number>();
+  for (let i = 0; i < nodes.length; i++) {
+    nodeIndex.set(nodes[i].id, i);
+  }
+
+  for (const rn of raptorNodes) {
+    const idx = nodeIndex.get(rn.id);
+    if (idx !== undefined) {
+      nodes[idx].raptorLevel = rn.level;
+    }
+    if (!rn.parentId) continue;
+    if (nodeIndex.has(rn.id) && nodeIndex.has(rn.parentId)) {
+      edges.push({
+        source: rn.id,
+        target: rn.parentId,
+        weight: Math.max(0.1, 1.0 - rn.level * 0.1),
+        type: "raptor_parent",
+      });
+    }
+  }
+}