engramx 0.4.3 → 0.5.0

package/README.md

@@ -15,28 +15,28 @@
   <a href="https://github.com/NickCirv/engram/actions"><img src="https://github.com/NickCirv/engram/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
   <img src="https://img.shields.io/badge/license-Apache%202.0-blue" alt="License">
   <img src="https://img.shields.io/badge/node-%3E%3D20-brightgreen" alt="Node">
-  <img src="https://img.shields.io/badge/tests-486%20passing-brightgreen" alt="Tests">
+  <img src="https://img.shields.io/badge/tests-520%20passing-brightgreen" alt="Tests">
   <img src="https://img.shields.io/badge/LLM%20cost-$0-green" alt="Zero LLM cost">
   <img src="https://img.shields.io/badge/native%20deps-zero-green" alt="Zero native deps">
-  <img src="https://img.shields.io/badge/token%20reduction-82%25-orange" alt="82% token reduction">
+  <img src="https://img.shields.io/badge/token%20savings-up%20to%2090%25-orange" alt="Up to 90% token savings">
 </p>
 
 ---
 
-# The structural code graph your AI agent can't forget to use.
+# The context spine for AI coding agents.
 
-**Context rot is empirically solved.** Chroma's July 2025 research proved that even Claude Opus 4.6 scores only 76% on MRCR v2 8-needle at 1M tokens. Long context windows don't save you — they drown you. engram is the answer: a **structural graph** of your codebase that replaces file reads with ~300-token summaries *before the agent sees them*.
+**One call replaces five.** engram intercepts file reads and serves rich context packets — structural summaries, decisions, library docs, known issues, and git history — assembled from 6 providers in a single ~500-token response. Your AI agent gets everything it needs without making 5 separate tool calls.
 
-engram installs a Claude Code hook layer at the tool-call boundary. Every `Read`, `Edit`, `Write`, and `Bash cat` gets intercepted. When the graph has confident coverage of a file, the raw read never happens — the agent sees a structural summary instead.
+engram installs a hook layer at the Claude Code tool-call boundary. Every `Read`, `Edit`, `Write`, and `Bash cat` gets intercepted. When the graph has confident coverage of a file, it serves a **rich context packet** combining structure, decisions, docs, and history — all pre-assembled, all within budget.
 
-Not a memory tool. Not a RAG layer. Not a context manager. **A structural code graph with a Claude Code hook layer that turns it into the memory your agent can't forget to exist.**
+Not a memory tool. Not a RAG layer. **The context spine that connects your knowledge graph, semantic memory, library docs, and project notes into a single context layer your AI agent can't forget to use.**
 
 | What it is | What it isn't |
 |---|---|
-| Structural code graph (AST + git + session miners) | Prose memory like Anthropic's MEMORY.md |
+| Context spine (graph + 6 providers assembled per read) | A single-purpose file summarizer |
 | Local SQLite, zero cloud, zero native deps | Vector RAG that phones home |
 | Hook-based interception at the tool boundary | A tool the agent has to remember to call |
-| 82% measured token reduction on real code | Another LongMemEval chatbot benchmark |
+| Up to 90% session-level token savings | A theoretical benchmark |
 | Complements native Claude memory | Competes with native Claude memory |
 
 ```bash
@@ -46,27 +46,23 @@ engram init             # scan codebase → .engram/graph.db (~40 ms, 0 tokens)
 engram install-hook     # wire the Sentinel into Claude Code
 ```
 
-```bash
-npm install -g engramx
-cd ~/my-project
-engram init             # scan codebase → .engram/graph.db
-engram install-hook     # wire into Claude Code (project-local)
-```
-
 That's it. The next Claude Code session in that directory automatically:
 
-- **Replaces file reads with graph summaries** (Read intercept, deny+reason)
+- **Serves rich context packets** — structure + git changes + decisions + library docs in one response (Context Spine)
+- **Warms provider caches at session start** — MemPalace, Context7, Obsidian pre-fetched in background
 - **Warns before edits that hit known mistakes** (Edit landmine injection)
 - **Pre-loads relevant context when you ask a question** (UserPromptSubmit pre-query)
-- **Injects a project brief at session start** (SessionStart additionalContext)
-- **Logs every decision for `engram hook-stats`** (PostToolUse observer)
-
-## Architecture Diagram
+- **Injects a project brief at session start** with semantic context (SessionStart)
+- **Survives context compaction** — re-injects critical nodes before compression (PreCompact)
+- **Auto-switches project context** when you navigate to a different repo (CwdChanged)
+- **Shows live HUD in Claude Code status bar** — auto-configured on `install-hook`
 
-An 11-page visual walkthrough of the full lifecycle — the four hook events, the Read handler's 9-branch decision tree (with a real JSON response), the six-layer ecosystem substrate, and measured numbers from engram's own code.
+## Docs
 
-- 📄 **[View the PDF](docs/engram-sentinel-ecosystem.pdf)** — A3 landscape, 11 pages, 1 MB. GitHub renders it inline when clicked.
-- 🌐 **[HTML source](docs/engram-sentinel-ecosystem.html)** — single self-contained file. Download raw and open in any browser for the interactive scroll-reveal version.
+- **[Architecture Diagram](docs/engram-sentinel-ecosystem.pdf)** — 11-page visual walkthrough of the full lifecycle. [HTML version](docs/engram-sentinel-ecosystem.html).
+- **[Installation Guide](docs/engram-user-manual.html)** — AAA-designed step-by-step setup guide with experience tiers.
+- **[Integration Guide](docs/engram-integration-guide.html)** — how memory tools, compression plugins, and workflow managers integrate with engram. Real token savings numbers + code examples.
+- **[INTEGRATION.md](docs/INTEGRATION.md)** — MCP server setup and programmatic API reference.
 
 ## The Problem
 
@@ -117,9 +113,10 @@ Each tier builds on the previous. You can stop at any level — each one works s
 | Tier | What you run | What you get | Token savings |
 |---|---|---|---|
 | **1. Graph only** | `engram init` | CLI queries, MCP server, `engram gen` for CLAUDE.md | ~6x per query vs reading files |
-| **2. + Sentinel hooks** | `engram install-hook` | Automatic Read interception, Edit landmine warnings, session-start briefs, prompt pre-query | ~82% per session (measured) |
-| **3. + Skills index** | `engram init --with-skills` | Graph includes your `~/.claude/skills/` — queries surface relevant skills alongside code | ~23% overhead on graph size |
-| **4. + Git hooks** | `engram hooks install` | Auto-rebuild graph on every `git commit` — graph never goes stale | Zero token cost |
+| **2. + Sentinel hooks** | `engram install-hook` | Automatic Read interception, Edit warnings, session briefs, HUD | ~80% per session |
+| **3. + Context Spine** | Configure providers.json | Rich packets: structure + decisions + docs + git in one response | Up to 90% session-level |
+| **4. + Skills index** | `engram init --with-skills` | Graph includes your `~/.claude/skills/` — queries surface relevant skills | ~23% overhead on graph size |
+| **5. + Git hooks** | `engram hooks install` | Auto-rebuild graph on every `git commit` — graph never goes stale | Zero token cost |
 
 **Recommended full setup** (one-time, per project):
 
@@ -161,7 +158,7 @@ engram gen --task bug-fix       # Task-aware view (general|bug-fix|feature|refac
 engram hooks install            # Auto-rebuild graph on git commit
 ```
 
-### Sentinel (v0.3 — new)
+### Sentinel (v0.3+)
 
 ```bash
 engram intercept                        # Hook entry point (called by Claude Code, reads stdin)
@@ -178,9 +175,51 @@ engram hook-disable                     # Kill switch (touch .engram/hook-disabl
 engram hook-enable                      # Remove kill switch
 ```
 
+### Infrastructure (v0.4 — new)
+
+```bash
+engram watch [path]                     # Live file watcher — incremental re-index on save
+engram dashboard [path]                 # Live terminal dashboard (token savings, hit rate, top files)
+engram hud [path]                       # Alias for dashboard
+engram hud-label [path]                 # JSON label for Claude HUD --extra-cmd integration
+```
+
+**Claude HUD integration** — add `--extra-cmd="engram hud-label"` to your Claude HUD statusLine command and see live savings in your Claude Code status bar:
+
+```
+⚡engram 48.5K saved ▰▰▰▰▰▰▰▰▱▱ 75%
+```
+
+## Context Spine (v0.5 — new)
+
+The Context Spine assembles rich context from 6 providers into a single response per file read:
+
+| Provider | Tier | What it adds | Latency |
+|----------|------|-------------|---------|
+| `engram:structure` | Internal | Functions, classes, imports, edges | <50ms |
+| `engram:mistakes` | Internal | Known bugs and past failures | <10ms |
+| `engram:git` | Internal | Last modified, author, churn rate | <100ms |
+| `mempalace` | External (cached) | Decisions, learnings, project context | <5ms cached |
+| `context7` | External (cached) | Library API docs for imports | <5ms cached |
+| `obsidian` | External (cached) | Project notes, architecture docs | <5ms cached |
+
+External providers cache results in SQLite at SessionStart. Per-Read resolution is a cache lookup (<5ms), not a live query. If any provider is unavailable, it's silently skipped — you always get at least the structural summary.
+
+Configure providers in `.engram/providers.json` (optional — auto-detection works for most setups):
+
+```json
+{
+  "providers": {
+    "mempalace": { "enabled": true },
+    "context7": { "enabled": true },
+    "obsidian": { "enabled": true, "vault": "~/vault" }
+  }
+}
+```
+
 ## How the Sentinel Layer Works
 
-Seven hook handlers compose the interception stack:
+Nine hook handlers compose the interception stack:
 
 | Hook | Mechanism | What it does |
 |---|---|---|
@@ -188,9 +227,11 @@ Seven hook handlers compose the interception stack:
 | **`PreToolUse:Edit`** | `allow + additionalContext` | Never blocks writes. If the file has known past mistakes, injects them as a landmine warning alongside the edit. |
 | **`PreToolUse:Write`** | Same as Edit | Advisory landmine injection. |
 | **`PreToolUse:Bash`** | Parse + delegate | Detects `cat|head|tail|less|more <single-file>` invocations (strict parser, rejects any shell metacharacter) and delegates to the Read handler. Closes the Bash workaround loophole. |
-| **`SessionStart`** | `additionalContext` | Injects a compact project brief (god nodes + graph stats + top landmines + git branch) on source=startup/clear/compact. Passes through on resume. |
+| **`SessionStart`** | `additionalContext` | Injects a compact project brief (god nodes + graph stats + top landmines + git branch) on source=startup/clear/compact. Bundles mempalace semantic context in parallel if available. Passes through on resume. |
 | **`UserPromptSubmit`** | `additionalContext` | Extracts keywords from the user's message, runs a ≤500-token pre-query, injects results. Skipped for short or generic prompts. Raw prompt content is never logged. |
-| **`PostToolUse`** | Observer | Pure logger. Writes tool/path/outputSize/success/decision to `.engram/hook-log.jsonl` for `hook-stats` and v0.3.1 self-tuning. |
+| **`PostToolUse`** | Observer | Pure logger. Writes tool/path/outputSize/success/decision to `.engram/hook-log.jsonl` for `hook-stats`. |
+| **`PreCompact`** | `additionalContext` | Re-injects god nodes + active landmines right before Claude compresses the conversation. First tool in the ecosystem whose context survives compaction. |
+| **`CwdChanged`** | `additionalContext` | Auto-switches project context when the user navigates to a different repo mid-session. Injects a compact brief for the new project. |
 
 ### Ten safety invariants, enforced at runtime
 
@@ -215,7 +256,7 @@ If anything goes wrong, `engram hook-disable` flips the kill switch without unin
 
 engram runs three miners on your codebase. None of them use an LLM.
 
-**AST Miner** — Extracts code structure (classes, functions, imports, exports, call patterns) using pattern matching across 10 languages: TypeScript, JavaScript, Python, Go, Rust, Java, C, C++, Ruby, PHP. Zero tokens, deterministic, cached.
+**Heuristic Code Miner** — Extracts code structure (classes, functions, imports, exports, call patterns) using regex heuristics across 10 languages: TypeScript, JavaScript, Python, Go, Rust, Java, C, C++, Ruby, PHP. Confidence-scored (0.85 for regex extraction, 1.0 reserved for future tree-sitter). Zero tokens, deterministic, cached.
 
 **Git Miner** — Reads `git log` for co-change patterns (files that change together), hot files (most frequently modified), and authorship. Creates INFERRED edges between structurally coupled files.
 

package/dist/{chunk-ESPAWLH6.js → chunk-LH2ZID5Z.js}

@@ -310,7 +310,7 @@ function writeToFile(filePath, summary) {
   writeFileSync2(filePath, newContent);
 }
 async function autogen(projectRoot, target, task) {
-  const { getStore } = await import("./core-WTKXDUDO.js");
+  const { getStore } = await import("./core-VUVXLXZN.js");
   const store = await getStore(projectRoot);
   try {
     let view = VIEWS.general;

package/dist/{chunk-R46DNLNR.js → chunk-V5VQQ3SF.js}

@@ -59,6 +59,16 @@ var GraphStore = class _GraphStore {
         key TEXT PRIMARY KEY,
         value TEXT NOT NULL
       );
+
+      CREATE TABLE IF NOT EXISTS provider_cache (
+        provider TEXT NOT NULL,
+        file_path TEXT NOT NULL,
+        content TEXT NOT NULL,
+        query_used TEXT NOT NULL DEFAULT '',
+        cached_at INTEGER NOT NULL,
+        ttl INTEGER NOT NULL DEFAULT 3600,
+        PRIMARY KEY (provider, file_path)
+      );
     `);
     const indexes = [
       "CREATE INDEX IF NOT EXISTS idx_nodes_kind ON nodes(kind)",
@@ -66,7 +76,9 @@ var GraphStore = class _GraphStore {
       "CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source)",
       "CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target)",
       "CREATE INDEX IF NOT EXISTS idx_edges_relation ON edges(relation)",
-      "CREATE INDEX IF NOT EXISTS idx_edges_source_file ON edges(source_file)"
+      "CREATE INDEX IF NOT EXISTS idx_edges_source_file ON edges(source_file)",
+      "CREATE INDEX IF NOT EXISTS idx_cache_file ON provider_cache(file_path)",
+      "CREATE INDEX IF NOT EXISTS idx_cache_stale ON provider_cache(cached_at)"
     ];
     for (const sql of indexes) {
       try {
@@ -149,10 +161,11 @@ var GraphStore = class _GraphStore {
     return null;
   }
   searchNodes(query2, limit = 20) {
-    const pattern = `%${query2}%`;
+    const escaped = query2.replace(/%/g, "\\%").replace(/_/g, "\\_");
+    const pattern = `%${escaped}%`;
     const results = [];
     const stmt = this.db.prepare(
-      "SELECT * FROM nodes WHERE label LIKE ? OR id LIKE ? ORDER BY query_count DESC LIMIT ?"
+      "SELECT * FROM nodes WHERE label LIKE ? ESCAPE '\\' OR id LIKE ? ESCAPE '\\' ORDER BY query_count DESC LIMIT ?"
     );
     stmt.bind([pattern, pattern, limit]);
     while (stmt.step()) {
@@ -198,6 +211,41 @@ var GraphStore = class _GraphStore {
     stmt.free();
     return results;
   }
+  getNodesByFile(sourceFile, limit = 500) {
+    const results = [];
+    const stmt = this.db.prepare(
+      "SELECT * FROM nodes WHERE source_file = ? LIMIT ?"
+    );
+    stmt.bind([sourceFile, limit]);
+    while (stmt.step()) {
+      results.push(this.rowToNode(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+  }
+  getEdgesForNodes(nodeIds) {
+    if (nodeIds.length === 0) return [];
+    const CHUNK = 400;
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (let i = 0; i < nodeIds.length; i += CHUNK) {
+      const chunk = nodeIds.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => "?").join(",");
+      const sql = `SELECT * FROM edges WHERE source IN (${placeholders}) OR target IN (${placeholders})`;
+      const stmt = this.db.prepare(sql);
+      stmt.bind([...chunk, ...chunk]);
+      while (stmt.step()) {
+        const edge = this.rowToEdge(stmt.getAsObject());
+        const key = `${edge.source}|${edge.target}|${edge.relation}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          results.push(edge);
+        }
+      }
+      stmt.free();
+    }
+    return results;
+  }
   getAllNodes() {
     const results = [];
     const stmt = this.db.prepare("SELECT * FROM nodes");
@@ -277,7 +325,135 @@ var GraphStore = class _GraphStore {
     this.db.run("DELETE FROM nodes");
     this.db.run("DELETE FROM edges");
     this.db.run("DELETE FROM stats");
+    this.db.run("DELETE FROM provider_cache");
+  }
+  // ─── Provider Cache ─────────────────────────────────────────────
+  /**
+   * Get all cached provider results for a file. Returns only non-stale
+   * entries (cached_at + ttl > now).
+   */
+  getCachedContext(filePath) {
+    const now = Date.now();
+    const results = [];
+    const stmt = this.db.prepare(
+      `SELECT * FROM provider_cache
+       WHERE file_path = ? AND (cached_at + ttl * 1000) > ?`
+    );
+    stmt.bind([filePath, now]);
+    while (stmt.step()) {
+      results.push(this.rowToCachedContext(stmt.getAsObject()));
+    }
+    stmt.free();
+    return results;
+  }
+  /**
+   * Get cached context for a specific provider + file. Returns null if
+   * missing or stale.
+   */
+  getCachedContextForProvider(provider, filePath) {
+    const now = Date.now();
+    const stmt = this.db.prepare(
+      `SELECT * FROM provider_cache
+       WHERE provider = ? AND file_path = ? AND (cached_at + ttl * 1000) > ?`
+    );
+    stmt.bind([provider, filePath, now]);
+    if (stmt.step()) {
+      const row = stmt.getAsObject();
+      stmt.free();
+      return this.rowToCachedContext(row);
+    }
+    stmt.free();
+    return null;
+  }
+  /**
+   * Upsert a single cached provider result.
+   */
+  setCachedContext(provider, filePath, content, ttl, queryUsed = "") {
+    this.db.run(
+      `INSERT OR REPLACE INTO provider_cache
+       (provider, file_path, content, query_used, cached_at, ttl)
+       VALUES (?, ?, ?, ?, ?, ?)`,
+      [provider, filePath, content, queryUsed, Date.now(), ttl]
+    );
+  }
+  /**
+   * Bulk insert/replace cache entries for a provider. Uses a transaction
+   * for performance. Called by provider warmup at SessionStart.
+   */
+  warmCache(provider, entries, ttl, queryUsed = "") {
+    if (entries.length === 0) return;
+    this.db.run("BEGIN TRANSACTION");
+    try {
+      for (const entry of entries) {
+        this.db.run(
+          `INSERT OR REPLACE INTO provider_cache
+           (provider, file_path, content, query_used, cached_at, ttl)
+           VALUES (?, ?, ?, ?, ?, ?)`,
+          [provider, entry.filePath, entry.content, queryUsed, Date.now(), ttl]
+        );
+      }
+      this.db.run("COMMIT");
+      this.save();
+    } catch (e) {
+      this.db.run("ROLLBACK");
+      throw e;
+    }
+  }
+  /**
+   * Remove all stale cache entries. Called at SessionStart before warmup.
+   */
+  pruneStaleCache() {
+    const now = Date.now();
+    this.db.run(
+      "DELETE FROM provider_cache WHERE (cached_at + ttl * 1000) <= ?",
+      [now]
+    );
+    const changes = this.db.getRowsModified();
+    return changes;
+  }
+  /**
+   * Remove all cache entries for a provider. Used when a provider is
+   * disabled or its configuration changes.
+   */
+  clearProviderCache(provider) {
+    this.db.run("DELETE FROM provider_cache WHERE provider = ?", [provider]);
+  }
+  /**
+   * Get count of cached entries per provider.
+   */
+  getCacheStats() {
+    const now = Date.now();
+    const results = [];
+    const stmt = this.db.prepare(
+      `SELECT provider,
+              COUNT(*) as total,
+              SUM(CASE WHEN (cached_at + ttl * 1000) <= ? THEN 1 ELSE 0 END) as stale
+       FROM provider_cache
+       GROUP BY provider`
+    );
+    stmt.bind([now]);
+    while (stmt.step()) {
+      const row = stmt.getAsObject();
+      results.push({
+        provider: row.provider,
+        count: row.total,
+        stale: row.stale
+      });
+    }
+    stmt.free();
+    return results;
   }
+  rowToCachedContext(row) {
+    return {
+      provider: row.provider ?? "",
+      filePath: row.file_path ?? "",
+      content: row.content ?? "",
+      queryUsed: row.query_used ?? "",
+      cachedAt: row.cached_at ?? 0,
+      ttl: row.ttl ?? 3600
+    };
+  }
+  // ─── Lifecycle ────────────────────────────────────────────────
   close() {
     this.save();
     this.db.close();
@@ -341,9 +517,28 @@ function isHiddenKeyword(node) {
 }
 var CHARS_PER_TOKEN = 4;
 function scoreNodes(store, terms) {
-  const allNodes = store.getAllNodes();
+  const seen = /* @__PURE__ */ new Set();
+  const seedNodes = [];
+  for (const t of terms) {
+    for (const node of store.searchNodes(t, 200)) {
+      if (!seen.has(node.id)) {
+        seen.add(node.id);
+        seedNodes.push(node);
+      }
+    }
+  }
+  const neighborNodes = [];
+  for (const node of seedNodes) {
+    for (const { node: neighbor } of store.getNeighbors(node.id)) {
+      if (!seen.has(neighbor.id)) {
+        seen.add(neighbor.id);
+        neighborNodes.push(neighbor);
+      }
+    }
+  }
+  const allCandidates = [...seedNodes, ...neighborNodes];
   const scored = [];
-  for (const node of allNodes) {
+  for (const node of allCandidates) {
     const label = node.label.toLowerCase();
     const file = node.sourceFile.toLowerCase();
     let score = 0;
@@ -544,10 +739,8 @@ function renderPath(nodes, edges) {
   return `Path (${edges.length} hops): ${segments.join(" ")}`;
 }
 function renderFileStructure(store, relativeFilePath, tokenBudget = 600) {
-  const allNodes = store.getAllNodes();
-  const fileNodes = allNodes.filter(
-    (n) => n.sourceFile === relativeFilePath && !isHiddenKeyword(n)
-  );
+  const allFileNodes = store.getNodesByFile(relativeFilePath);
+  const fileNodes = allFileNodes.filter((n) => !isHiddenKeyword(n));
   if (fileNodes.length === 0) {
     return {
       text: "",
@@ -561,10 +754,10 @@ function renderFileStructure(store, relativeFilePath, tokenBudget = 600) {
     (n) => n.kind !== "file" && n.kind !== "module"
   ).length;
   const avgConfidence = fileNodes.reduce((s, n) => s + n.confidenceScore, 0) / fileNodes.length;
-  const allEdges = store.getAllEdges();
   const fileNodeIds = new Set(fileNodes.map((n) => n.id));
+  const fileEdges = store.getEdgesForNodes([...fileNodeIds]);
   const degreeMap = /* @__PURE__ */ new Map();
-  for (const e of allEdges) {
+  for (const e of fileEdges) {
     if (fileNodeIds.has(e.source)) {
       degreeMap.set(e.source, (degreeMap.get(e.source) ?? 0) + 1);
     }
@@ -612,15 +805,31 @@ function renderFileStructure(store, relativeFilePath, tokenBudget = 600) {
       lines.push(`NODE ${n.label} [${n.kind}] ${loc}`.trim());
     }
   }
-  const relevantEdges = allEdges.filter(
+  const relevantEdges = fileEdges.filter(
     (e) => fileNodeIds.has(e.source) || fileNodeIds.has(e.target)
-  ).slice(0, 10);
+  ).sort((a, b) => {
+    const degA = (degreeMap.get(a.source) ?? 0) + (degreeMap.get(a.target) ?? 0);
+    const degB = (degreeMap.get(b.source) ?? 0) + (degreeMap.get(b.target) ?? 0);
+    return degB - degA;
+  }).slice(0, 10);
+  const nodeById = /* @__PURE__ */ new Map();
+  for (const n of fileNodes) nodeById.set(n.id, n);
+  for (const e of relevantEdges) {
+    if (!nodeById.has(e.source)) {
+      const n = store.getNode(e.source);
+      if (n) nodeById.set(n.id, n);
+    }
+    if (!nodeById.has(e.target)) {
+      const n = store.getNode(e.target);
+      if (n) nodeById.set(n.id, n);
+    }
+  }
   if (relevantEdges.length > 0) {
     lines.push("");
     lines.push("Key relationships:");
     for (const e of relevantEdges) {
-      const src = allNodes.find((n) => n.id === e.source);
-      const tgt = allNodes.find((n) => n.id === e.target);
+      const src = nodeById.get(e.source);
+      const tgt = nodeById.get(e.target);
       if (src && tgt) {
         lines.push(`EDGE ${src.label} --${e.relation}--> ${tgt.label}`);
       }
@@ -755,7 +964,8 @@ function extractFile(filePath, rootDir) {
       sourceFile: relPath,
       sourceLocation: line ? `L${line}` : null,
       confidence: "EXTRACTED",
-      confidenceScore: 1,
+      confidenceScore: 0.85,
+      // Regex heuristic — reserve 1.0 for tree-sitter
       lastVerified: now,
       queryCount: 0,
       metadata: { lang }
@@ -767,7 +977,8 @@ function extractFile(filePath, rootDir) {
       target,
       relation,
       confidence: "EXTRACTED",
-      confidenceScore: 1,
+      confidenceScore: 0.85,
+      // Regex heuristic — reserve 1.0 for tree-sitter
       sourceFile: relPath,
       sourceLocation: line ? `L${line}` : null,
       lastVerified: now,
@@ -810,6 +1021,8 @@ function extractWithPatterns(content, lines, lang, fileId, stem, relPath, addNod
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     const lineNum = i + 1;
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
     for (const pat of patterns.classes) {
       const match = line.match(pat);
       if (match?.[1]) {
@@ -822,6 +1035,7 @@ function extractWithPatterns(content, lines, lang, fileId, stem, relPath, addNod
     for (const pat of patterns.functions) {
       const match = line.match(pat);
       if (match?.[1]) {
+        if (pat.source.includes("const|let") && !line.includes("=>")) continue;
         const name = match[1];
         const id = makeId(stem, name);
         addNode(id, `${name}()`, "function", lineNum);
@@ -849,9 +1063,26 @@ function extractWithPatterns(content, lines, lang, fileId, stem, relPath, addNod
   }
 }
 function extractGo(content, lines, fileId, stem, relPath, addNode, addEdge) {
+  let inImportBlock = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
     const lineNum = i + 1;
+    const trimmed = line.trimStart();
+    if (trimmed.startsWith("//") || trimmed.startsWith("*")) continue;
+    if (/^import\s*\(/.test(line)) {
+      inImportBlock = true;
+      continue;
+    }
+    if (inImportBlock && trimmed === ")") {
+      inImportBlock = false;
+      continue;
+    }
+    const singleImport = line.match(/^import\s+"([^"]+)"/);
+    if (singleImport?.[1]) {
+      const module = singleImport[1].split("/").pop();
+      addEdge(fileId, makeId(module), "imports", lineNum);
+      continue;
+    }
     const funcMatch = line.match(
       /^func\s+(?:\([\w\s*]+\)\s+)?(\w+)\s*\(/
     );
@@ -869,10 +1100,12 @@ function extractGo(content, lines, fileId, stem, relPath, addNode, addEdge) {
       addNode(id, name, kind, lineNum);
       addEdge(fileId, id, "contains", lineNum);
     }
-    const importMatch = line.match(/^\s*"([^"]+)"/);
-    if (importMatch?.[1] && i > 0 && content.includes("import")) {
-      const module = importMatch[1].split("/").pop();
-      addEdge(fileId, makeId(module), "imports", lineNum);
+    if (inImportBlock) {
+      const importMatch = line.match(/^\s*"([^"]+)"/);
+      if (importMatch?.[1]) {
+        const module = importMatch[1].split("/").pop();
+        addEdge(fileId, makeId(module), "imports", lineNum);
+      }
     }
   }
 }
@@ -1824,6 +2057,7 @@ export {
   MAX_MISTAKE_LABEL_CHARS,
   queryGraph,
   shortestPath,
+  renderFileStructure,
   toPosixPath,
   SUPPORTED_EXTENSIONS,
   extractFile,