diff --git a/gitnexus/src/App.tsx b/gitnexus/src/App.tsx
index 2b8c22de2..c305a18a4 100644
--- a/gitnexus/src/App.tsx
+++ b/gitnexus/src/App.tsx
@@ -41,12 +41,12 @@ const AppContent = () => {
     const projectName = file.name.replace('.zip', '');
     setProjectName(projectName);
     setViewMode('loading');
-    
+
     try {
       const result = await runPipeline(file, (progress) => {
         setProgress(progress);
       });
-      
+
       setGraph(result.graph);
       setFileContents(result.fileContents);
       setViewMode('exploring');
@@ -54,9 +54,9 @@ const AppContent = () => {
       // Initialize (or re-initialize) the agent AFTER a repo loads so it captures
       // the current codebase context (file contents + graph tools) in the worker.
       if (getActiveProviderConfig()) {
-        initializeAgent();
+        initializeAgent(projectName);
       }
-      
+
       // Auto-start embeddings pipeline in background
       // Uses WebGPU if available, falls back to WASM
       startEmbeddings().catch((err) => {
@@ -86,15 +86,15 @@ const AppContent = () => {
     // Extract project name from first file path (e.g., "owner-repo-123/src/..." -> "owner-repo")
     const firstPath = files[0]?.path || 'repository';
     const projectName = firstPath.split('/')[0].replace(/-\d+$/, '') || 'repository';
-    
+
     setProjectName(projectName);
     setViewMode('loading');
-    
+
     try {
       const result = await runPipelineFromFiles(files, (progress) => {
         setProgress(progress);
       });
-      
+
       setGraph(result.graph);
       setFileContents(result.fileContents);
       setViewMode('exploring');
@@ -102,9 +102,9 @@ const AppContent = () => {
       // Initialize (or re-initialize) the agent AFTER a repo loads so it captures
       // the current codebase context (file contents + graph tools) in the worker.
       if (getActiveProviderConfig()) {
-        initializeAgent();
+        initializeAgent(projectName);
       }
-      
+
       // Auto-start embeddings pipeline in background
       // Uses WebGPU if available, falls back to WASM
       startEmbeddings().catch((err) => {
@@ -154,11 +154,11 @@ const AppContent = () => {
   return (
     <div className="flex flex-col h-screen bg-void overflow-hidden">
       <Header onFocusNode={handleFocusNode} />
-      
+
       <main className="flex-1 flex min-h-0">
         {/* Left Panel - File Tree */}
         <FileTreePanel onFocusNode={handleFocusNode} />
-        
+
         {/* Graph area - takes remaining space */}
         <div className="flex-1 relative min-w-0">
           <GraphCanvas ref={graphCanvasRef} />
@@ -170,13 +170,13 @@ const AppContent = () => {
             </div>
           )}
         </div>
-        
+
         {/* Right Panel - Code & Chat (tabbed) */}
         {isRightPanelOpen && <RightPanel />}
       </main>
-      
+
       <StatusBar />
-      
+
       {/* Settings Panel (modal) */}
       <SettingsPanel
         isOpen={isSettingsPanelOpen}
diff --git a/gitnexus/src/components/MCPToggle.tsx b/gitnexus/src/components/MCPToggle.tsx
index 14b40d057..2e08085ab 100644
--- a/gitnexus/src/components/MCPToggle.tsx
+++ b/gitnexus/src/components/MCPToggle.tsx
@@ -5,7 +5,7 @@
  * Shows connection status and setup instructions if bridge not found.
  */
 
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 import { Copy, Check, AlertCircle, X, Sparkles } from 'lucide-react';
 import { getMCPClient, type CodebaseContext } from '../core/mcp/mcp-client';
 
@@ -45,6 +45,8 @@ export function MCPToggle({
     const [status, setStatus] = useState<ConnectionState>('disconnected');
     const [copied, setCopied] = useState(false);
     const [showSetup, setShowSetup] = useState(false);
+    const [hasConnectionError, setHasConnectionError] = useState(false);
+    const setupPopupRef = useRef<HTMLDivElement | null>(null);
     const [showTip, setShowTip] = useState(false);
 
     const isConnected = status === 'connected';
@@ -62,6 +64,21 @@ export function MCPToggle({
         }
     }, [showOnboardingTip]);
 
+    // Close setup popup when clicking outside
+    useEffect(() => {
+        if (!showSetup) return;
+
+        const handleClickOutside = (event: MouseEvent) => {
+            if (!setupPopupRef.current) return;
+            if (!setupPopupRef.current.contains(event.target as Node)) {
+                setShowSetup(false);
+            }
+        };
+
+        document.addEventListener('mousedown', handleClickOutside);
+        return () => document.removeEventListener('mousedown', handleClickOutside);
+    }, [showSetup]);
+
     const dismissTip = () => {
         setShowTip(false);
         localStorage.setItem(MCP_TIP_DISMISSED_KEY, 'true');
@@ -71,6 +88,7 @@ export function MCPToggle({
         const client = getMCPClient();
         setStatus('connecting');
         setShowTip(false);
+        setHasConnectionError(false);
 
         try {
             await client.connect();
@@ -125,6 +143,7 @@ export function MCPToggle({
 
             setStatus('connected');
             setShowSetup(false);
+            setHasConnectionError(false);
             localStorage.setItem(MCP_TIP_DISMISSED_KEY, 'true');
 
             // Send codebase context after connecting
@@ -141,6 +160,7 @@ export function MCPToggle({
         } catch {
             setStatus('error');
             setShowSetup(true);
+            setHasConnectionError(true);
         }
     }, [onSearch, onCypher, onBlastRadius, onHighlight, onGrep, onRead, getContext]);
 
@@ -148,6 +168,7 @@ export function MCPToggle({
         const client = getMCPClient();
         client.disconnect();
         setStatus('disconnected');
+        setHasConnectionError(false);
     }, []);
 
     const toggle = useCallback(() => {
@@ -158,8 +179,8 @@ export function MCPToggle({
         }
     }, [isConnected, isConnecting, connect, disconnect]);
 
-    const copyCommand = () => {
-        navigator.clipboard.writeText('npx gitnexus-mcp setup');
+    const copyCommand = (command: string) => {
+        navigator.clipboard.writeText(command);
         setCopied(true);
         setTimeout(() => setCopied(false), 2000);
     };
@@ -168,13 +189,19 @@ export function MCPToggle({
     useEffect(() => {
         const client = getMCPClient();
         const unsubscribe = client.onConnectionChange((connected) => {
-            setStatus(connected ? 'connected' : 'disconnected');
+            if (connected) {
+                setStatus('connected');
+                setShowSetup(false);
+                setHasConnectionError(false);
+            } else {
+                setStatus('disconnected');
+            }
         });
         return () => { unsubscribe(); };
     }, []);
 
     // Error state - show setup popup
-    if (status === 'error' && showSetup) {
+    if (hasConnectionError && showSetup) {
         return (
             <div className="relative flex items-center gap-2">
                 <span className="text-xs text-text-primary font-medium">MCP</span>
@@ -183,30 +210,74 @@ export function MCPToggle({
                     className="flex items-center gap-1.5 px-2 py-1 text-xs text-amber-400 hover:bg-amber-400/10 rounded transition-colors"
                 >
                     <AlertCircle className="w-3.5 h-3.5" />
-                    <span>Setup</span>
+                    <span>Daemon</span>
                 </button>
 
-                <div className="absolute top-full right-0 mt-2 p-4 bg-surface border border-border rounded-lg shadow-xl z-50 w-80">
-                    <p className="text-sm text-text-secondary mb-3">
-                        Run this command to enable external AI agents:
+                <div
+                    ref={setupPopupRef}
+                    className="absolute top-full right-0 mt-2 p-5 bg-surface border border-border rounded-lg shadow-xl z-50 w-[28rem]"
+                >
+                    <p className="text-sm text-text-primary mb-4">
+                        MCP daemon isn't running. Follow the steps below:
                     </p>
-                    <div className="flex items-center gap-2 bg-background p-2 rounded font-mono text-sm">
-                        <code className="flex-1 text-green-400">npx gitnexus-mcp setup</code>
-                        <button
-                            onClick={copyCommand}
-                            className="p-1 hover:bg-surface-hover rounded"
-                            title="Copy command"
-                        >
-                            {copied ? (
-                                <Check className="w-4 h-4 text-green-400" />
-                            ) : (
-                                <Copy className="w-4 h-4 text-text-secondary" />
-                            )}
-                        </button>
+
+                    <div className="mb-3">
+                        <p className="text-sm text-text-secondary mb-2">1) Install/configure your IDE:</p>
+                        <div className="flex items-center gap-2 bg-background/60 border border-border/60 px-3 py-2 rounded font-mono text-sm">
+                            <code className="flex-1 text-text-primary">npx gitnexus-mcp setup</code>
+                            <button
+                                onClick={() => copyCommand('npx gitnexus-mcp setup')}
+                                className="p-1.5 hover:bg-surface-hover rounded"
+                                title="Copy command"
+                            >
+                                {copied ? (
+                                    <Check className="w-4 h-4 text-green-400" />
+                                ) : (
+                                    <Copy className="w-4 h-4 text-text-secondary" />
+                                )}
+                            </button>
+                        </div>
                     </div>
+
+                    <div className="mb-3">
+                        <p className="text-sm text-text-secondary mb-2">2) Start the daemon (recommended):</p>
+                        <div className="flex items-center gap-2 bg-background/60 border border-border/60 px-3 py-2 rounded font-mono text-sm">
+                            <code className="flex-1 text-text-primary">npx gitnexus-mcp daemon</code>
+                            <button
+                                onClick={() => copyCommand('npx gitnexus-mcp daemon')}
+                                className="p-1.5 hover:bg-surface-hover rounded"
+                                title="Copy command"
+                            >
+                                {copied ? (
+                                    <Check className="w-4 h-4 text-green-400" />
+                                ) : (
+                                    <Copy className="w-4 h-4 text-text-secondary" />
+                                )}
+                            </button>
+                        </div>
+                    </div>
+
+                    <div className="mb-3">
+                        <p className="text-sm text-text-secondary mb-2">Dev mode (from `gitnexus-mcp` dir):</p>
+                        <div className="flex items-center gap-2 bg-background/60 border border-border/60 px-3 py-2 rounded font-mono text-sm">
+                            <code className="flex-1 text-text-primary">npm run build &amp;&amp; node dist/cli.js daemon</code>
+                            <button
+                                onClick={() => copyCommand('npm run build && node dist/cli.js daemon')}
+                                className="p-1.5 hover:bg-surface-hover rounded"
+                                title="Copy command"
+                            >
+                                {copied ? (
+                                    <Check className="w-4 h-4 text-green-400" />
+                                ) : (
+                                    <Copy className="w-4 h-4 text-text-secondary" />
+                                )}
+                            </button>
+                        </div>
+                    </div>
+
                     <button
                         onClick={() => { setShowSetup(false); connect(); }}
-                        className="mt-3 w-full px-3 py-1.5 text-sm bg-green-500/20 text-green-400 rounded hover:bg-green-500/30 transition-colors"
+                        className="mt-2 w-full px-3 py-1.5 text-sm bg-green-500/20 text-green-400 rounded hover:bg-green-500/30 transition-colors"
                     >
                         Retry Connection
                     </button>
@@ -282,7 +353,7 @@ export function MCPToggle({
                         <div className="flex items-center gap-2 bg-background p-2 rounded font-mono text-sm">
                             <code className="flex-1 text-green-400">npx gitnexus-mcp setup</code>
                             <button
-                                onClick={copyCommand}
+                        onClick={() => copyCommand('npx gitnexus-mcp setup')}
                                 className="p-1 hover:bg-surface-hover rounded"
                                 title="Copy command"
                             >
diff --git a/gitnexus/src/core/graph/types.ts b/gitnexus/src/core/graph/types.ts
index 109957700..eb4e81c2a 100644
--- a/gitnexus/src/core/graph/types.ts
+++ b/gitnexus/src/core/graph/types.ts
@@ -48,6 +48,10 @@ export interface GraphRelationship {
   sourceId: string,
   targetId: string,
   type: RelationshipType,
+  /** Confidence score 0-1 (1.0 = certain, lower = uncertain resolution) */
+  confidence: number,
+  /** Resolution reason: 'import-resolved', 'same-file', 'fuzzy-global', or empty for non-CALLS */
+  reason: string,
 }
 
 export interface KnowledgeGraph {
diff --git a/gitnexus/src/core/ingestion/call-processor.ts b/gitnexus/src/core/ingestion/call-processor.ts
index 2f866d842..77a7ef747 100644
--- a/gitnexus/src/core/ingestion/call-processor.ts
+++ b/gitnexus/src/core/ingestion/call-processor.ts
@@ -71,7 +71,8 @@ const findEnclosingFunction = (
         if (nodeId) return nodeId;
         
         // Fallback: generate ID based on name and file
-        return generateId('Function', `${filePath}:${funcName}`);
+        const fallbackLabel = current.type === 'method_definition' ? 'Method' : 'Function';
+        return generateId(fallbackLabel, `${filePath}:${funcName}`);
       }
       
       // Couldn't determine function name - try parent (might be nested)
@@ -143,15 +144,15 @@ export const processCalls = async (
       // Skip common built-ins and noise
       if (isBuiltInOrNoise(calledName)) return;
 
-      // 4. Resolve the target using priority strategy
-      const targetNodeId = resolveCallTarget(
+      // 4. Resolve the target using priority strategy (returns confidence)
+      const resolved = resolveCallTarget(
         calledName,
         file.path,
         symbolTable,
         importMap
       );
 
-      if (!targetNodeId) return;
+      if (!resolved) return;
 
       // 5. Find the enclosing function (caller)
       const callNode = captureMap['call'];
@@ -160,13 +161,15 @@ export const processCalls = async (
       // Use enclosing function as source, fallback to file for top-level calls
       const sourceId = enclosingFuncId || generateId('File', file.path);
       
-      const relId = generateId('CALLS', `${sourceId}:${calledName}->${targetNodeId}`);
+      const relId = generateId('CALLS', `${sourceId}:${calledName}->${resolved.nodeId}`);
 
       graph.addRelationship({
         id: relId,
         sourceId,
-        targetId: targetNodeId,
-        type: 'CALLS'
+        targetId: resolved.nodeId,
+        type: 'CALLS',
+        confidence: resolved.confidence,
+        reason: resolved.reason,
       });
     });
 
@@ -177,35 +180,52 @@ export const processCalls = async (
   }
 };
 
+/**
+ * Resolution result with confidence scoring
+ */
+interface ResolveResult {
+  nodeId: string;
+  confidence: number;  // 0-1: how sure are we?
+  reason: string;      // 'import-resolved' | 'same-file' | 'fuzzy-global'
+}
+
 /**
  * Resolve a function call to its target node ID using priority strategy:
  * A. Check imported files first (highest confidence)
  * B. Check local file definitions
  * C. Fuzzy global search (lowest confidence)
+ * 
+ * Returns confidence score so agents know what to trust.
  */
 const resolveCallTarget = (
   calledName: string,
   currentFile: string,
   symbolTable: SymbolTable,
   importMap: ImportMap
-): string | null => {
-  // Strategy A: Check imported files
+): ResolveResult | null => {
+  // Strategy A: Check imported files (HIGH confidence - we know the import chain)
   const importedFiles = importMap.get(currentFile);
   if (importedFiles) {
     for (const importedFile of importedFiles) {
       const nodeId = symbolTable.lookupExact(importedFile, calledName);
-      if (nodeId) return nodeId;
+      if (nodeId) {
+        return { nodeId, confidence: 0.9, reason: 'import-resolved' };
+      }
     }
   }
 
-  // Strategy B: Check local file (same file definition)
+  // Strategy B: Check local file (HIGH confidence - same file definition)
   const localNodeId = symbolTable.lookupExact(currentFile, calledName);
-  if (localNodeId) return localNodeId;
+  if (localNodeId) {
+    return { nodeId: localNodeId, confidence: 0.85, reason: 'same-file' };
+  }
 
-  // Strategy C: Fuzzy global search (pick first match)
+  // Strategy C: Fuzzy global search (LOW confidence - just matching by name)
   const fuzzyMatches = symbolTable.lookupFuzzy(calledName);
   if (fuzzyMatches.length > 0) {
-    return fuzzyMatches[0].nodeId;
+    // Lower confidence if multiple matches exist (more ambiguous)
+    const confidence = fuzzyMatches.length === 1 ? 0.5 : 0.3;
+    return { nodeId: fuzzyMatches[0].nodeId, confidence, reason: 'fuzzy-global' };
   }
 
   return null;
diff --git a/gitnexus/src/core/ingestion/heritage-processor.ts b/gitnexus/src/core/ingestion/heritage-processor.ts
index 04bf6e532..1abdece66 100644
--- a/gitnexus/src/core/ingestion/heritage-processor.ts
+++ b/gitnexus/src/core/ingestion/heritage-processor.ts
@@ -84,7 +84,9 @@ export const processHeritage = async (
             id: relId,
             sourceId: childId,
             targetId: parentId,
-            type: 'EXTENDS'
+            type: 'EXTENDS',
+            confidence: 1.0,
+            reason: '',
           });
         }
       }
@@ -109,7 +111,9 @@ export const processHeritage = async (
             id: relId,
             sourceId: classId,
             targetId: interfaceId,
-            type: 'IMPLEMENTS'
+            type: 'IMPLEMENTS',
+            confidence: 1.0,
+            reason: '',
           });
         }
       }
diff --git a/gitnexus/src/core/ingestion/import-processor.ts b/gitnexus/src/core/ingestion/import-processor.ts
index e30bf34ac..9edc7d358 100644
--- a/gitnexus/src/core/ingestion/import-processor.ts
+++ b/gitnexus/src/core/ingestion/import-processor.ts
@@ -125,7 +125,9 @@ export const processImports = async (
             id: relId,
             sourceId,
             targetId,
-            type: 'IMPORTS'
+            type: 'IMPORTS',
+            confidence: 1.0,
+            reason: '',
           });
 
           // B. Update Import Map (For Pass 4)
diff --git a/gitnexus/src/core/ingestion/parsing-processor.ts b/gitnexus/src/core/ingestion/parsing-processor.ts
index c0a50cb74..0b5546ce9 100644
--- a/gitnexus/src/core/ingestion/parsing-processor.ts
+++ b/gitnexus/src/core/ingestion/parsing-processor.ts
@@ -113,7 +113,9 @@ export const processParsing = async (
         id: relId,
         sourceId: fileId,
         targetId: nodeId,
-        type: 'DEFINES'
+        type: 'DEFINES',
+        confidence: 1.0,
+        reason: '',
       };
 
       graph.addRelationship(relationship);
diff --git a/gitnexus/src/core/ingestion/structure-processor.ts b/gitnexus/src/core/ingestion/structure-processor.ts
index 0d3a67e0c..c73a5837c 100644
--- a/gitnexus/src/core/ingestion/structure-processor.ts
+++ b/gitnexus/src/core/ingestion/structure-processor.ts
@@ -32,7 +32,9 @@ export const processStructure = ( graph: KnowledgeGraph, paths: string[])=>{
                     id: relId,
                     type: 'CONTAINS',
                     sourceId: parentId,
-                    targetId: nodeId
+                    targetId: nodeId,
+                    confidence: 1.0,
+                    reason: '',
                 }
 
                 graph.addRelationship(relationship)
diff --git a/gitnexus/src/core/kuzu/csv-generator.ts b/gitnexus/src/core/kuzu/csv-generator.ts
index 3f988165b..be99f6688 100644
--- a/gitnexus/src/core/kuzu/csv-generator.ts
+++ b/gitnexus/src/core/kuzu/csv-generator.ts
@@ -119,7 +119,7 @@ const extractContent = (
 
 export interface CSVData {
   nodes: Map<NodeTableName, string>;
-  relCSV: string;  // Single relation CSV with from,to,type columns
+  relCSV: string;  // Single relation CSV with from,to,type,confidence,reason columns
 }
 
 // ============================================================================
@@ -202,10 +202,13 @@ const generateCodeElementCSV = (
 
 /**
  * Generate CSV for the single CodeRelation table
- * Headers: from,to,type
+ * Headers: from,to,type,confidence,reason
+ * 
+ * confidence: 0-1 score for CALLS edges (how sure are we about the target?)
+ * reason: 'import-resolved' | 'same-file' | 'fuzzy-global' (or empty for non-CALLS)
  */
 const generateRelationCSV = (graph: KnowledgeGraph): string => {
-  const headers = ['from', 'to', 'type'];
+  const headers = ['from', 'to', 'type', 'confidence', 'reason'];
   const rows: string[] = [headers.join(',')];
   
   for (const rel of graph.relationships) {
@@ -213,6 +216,8 @@ const generateRelationCSV = (graph: KnowledgeGraph): string => {
       escapeCSVField(rel.sourceId),
       escapeCSVField(rel.targetId),
       escapeCSVField(rel.type),
+      escapeCSVNumber(rel.confidence, 1.0),
+      escapeCSVField(rel.reason),
     ].join(','));
   }
   
diff --git a/gitnexus/src/core/kuzu/kuzu-adapter.ts b/gitnexus/src/core/kuzu/kuzu-adapter.ts
index 0ee8c5e59..ea994d7f8 100644
--- a/gitnexus/src/core/kuzu/kuzu-adapter.ts
+++ b/gitnexus/src/core/kuzu/kuzu-adapter.ts
@@ -113,35 +113,56 @@ export const loadGraphToKuzu = async (
     }
     
     // 5. INSERT relations one by one (COPY doesn't work with multi-pair REL tables)
-    // Parse CSV format: "from","to","type"
+    // Parse CSV format: "from","to","type",confidence,"reason"
     let insertedRels = 0;
+    let skippedRels = 0;
+    const skippedRelStats = new Map<string, number>();
     for (const line of relLines) {
       try {
-        // Parse CSV - handle quoted fields
-        const match = line.match(/"([^"]*)","([^"]*)","([^"]*)"/);
+        // Parse CSV - handle quoted fields and numeric confidence
+        // Format: "from","to","type",confidence,"reason"
+        const match = line.match(/"([^"]*)","([^"]*)","([^"]*)",([0-9.]+),"([^"]*)"/);
         if (!match) continue;
         
-        const [, fromId, toId, relType] = match;
+        const [, fromId, toId, relType, confidenceStr, reason] = match;
+        const confidence = parseFloat(confidenceStr) || 1.0;
         
         // Extract labels from node IDs (format: Label:path:name)
         const fromLabel = fromId.split(':')[0];
         const toLabel = toId.split(':')[0];
         
-        // INSERT with explicit node matching
+        // INSERT with explicit node matching (including confidence and reason)
         const insertQuery = `
           MATCH (a:${fromLabel} {id: '${fromId.replace(/'/g, "''")}'})
           MATCH (b:${toLabel} {id: '${toId.replace(/'/g, "''")}'})
-          CREATE (a)-[:${REL_TABLE_NAME} {type: '${relType}'}]->(b)
+          CREATE (a)-[:${REL_TABLE_NAME} {type: '${relType}', confidence: ${confidence}, reason: '${reason.replace(/'/g, "''")}'}]->(b)
         `;
         await conn.query(insertQuery);
         insertedRels++;
       } catch {
-        // Skip failed insertions (nodes might not exist)
+        // Skip failed insertions (nodes might not exist, or relation pair not allowed by schema)
+        skippedRels++;
+        if (import.meta.env.DEV) {
+          const match = line.match(/"([^"]*)","([^"]*)","([^"]*)",([0-9.]+),"([^"]*)"/);
+          if (match) {
+            const [, fromId, toId, relType] = match;
+            const fromLabel = fromId.split(':')[0];
+            const toLabel = toId.split(':')[0];
+            const key = `${relType}:${fromLabel}->${toLabel}`;
+            skippedRelStats.set(key, (skippedRelStats.get(key) || 0) + 1);
+          }
+        }
       }
     }
     
     if (import.meta.env.DEV) {
       console.log(`KuzuDB: Inserted ${insertedRels}/${relCount} relations`);
+      if (skippedRels > 0) {
+        const topSkipped = Array.from(skippedRelStats.entries())
+          .sort((a, b) => b[1] - a[1])
+          .slice(0, 10);
+        console.warn(`KuzuDB: Skipped ${skippedRels}/${relCount} relations (top by kind/pair):`, topSkipped);
+      }
     }
     
     // 6. Verify results
@@ -189,6 +210,7 @@ const getCopyQuery = (table: NodeTableName, path: string): string => {
 
 /**
  * Execute a Cypher query against the database
+ * Returns results as named objects (not tuples) for better usability
  */
 export const executeQuery = async (cypher: string): Promise<any[]> => {
   if (!conn) {
@@ -198,11 +220,45 @@ export const executeQuery = async (cypher: string): Promise<any[]> => {
   try {
     const result = await conn.query(cypher);
     
+    // Extract column names from RETURN clause
+    const returnMatch = cypher.match(/RETURN\s+(.+?)(?:\s+ORDER|\s+LIMIT|\s+SKIP|\s*$)/is);
+    let columnNames: string[] = [];
+    if (returnMatch) {
+      // Parse RETURN clause to get column names/aliases
+      // Handles: "a.name, b.filePath AS path, count(x) AS cnt"
+      const returnClause = returnMatch[1];
+      columnNames = returnClause.split(',').map(col => {
+        col = col.trim();
+        // Check for AS alias
+        const asMatch = col.match(/\s+AS\s+(\w+)\s*$/i);
+        if (asMatch) return asMatch[1];
+        // Check for property access like n.name
+        const propMatch = col.match(/\.(\w+)\s*$/);
+        if (propMatch) return propMatch[1];
+        // Check for function call like count(x)
+        const funcMatch = col.match(/^(\w+)\s*\(/);
+        if (funcMatch) return funcMatch[1];
+        // Just use as-is if simple identifier
+        return col.replace(/[^a-zA-Z0-9_]/g, '_');
+      });
+    }
+    
     // Collect all rows
     const rows: any[] = [];
     while (await result.hasNext()) {
       const row = await result.getNext();
-      rows.push(row);
+      
+      // Convert tuple to named object if we have column names and row is array
+      if (Array.isArray(row) && columnNames.length === row.length) {
+        const namedRow: Record<string, any> = {};
+        for (let i = 0; i < row.length; i++) {
+          namedRow[columnNames[i]] = row[i];
+        }
+        rows.push(namedRow);
+      } else {
+        // Already an object or column count doesn't match
+        rows.push(row);
+      }
     }
     
     return rows;
diff --git a/gitnexus/src/core/kuzu/schema.ts b/gitnexus/src/core/kuzu/schema.ts
index cc14828ac..0be8b8576 100644
--- a/gitnexus/src/core/kuzu/schema.ts
+++ b/gitnexus/src/core/kuzu/schema.ts
@@ -123,11 +123,17 @@ CREATE REL TABLE ${REL_TABLE_NAME} (
   FROM Folder TO File,
   FROM Function TO Function,
   FROM Function TO Method,
+  FROM Function TO Class,
   FROM Class TO Method,
   FROM Class TO Function,
   FROM Class TO Class,
   FROM Class TO Interface,
-  type STRING
+  FROM Method TO Function,
+  FROM Method TO Method,
+  FROM Method TO Class,
+  type STRING,
+  confidence DOUBLE,
+  reason STRING
 )`;
 
 // ============================================================================
diff --git a/gitnexus/src/core/llm/agent.ts b/gitnexus/src/core/llm/agent.ts
index 27b403267..3584655c4 100644
--- a/gitnexus/src/core/llm/agent.ts
+++ b/gitnexus/src/core/llm/agent.ts
@@ -232,6 +232,11 @@ export const createGraphRAGAgent = (
     ? buildDynamicSystemPrompt(BASE_SYSTEM_PROMPT, codebaseContext)
     : BASE_SYSTEM_PROMPT;
   
+  // Log the full prompt for debugging
+  if (import.meta.env.DEV) {
+    console.log('🤖 AGENT SYSTEM PROMPT:\n', systemPrompt);
+  }
+  
   const agent = createReactAgent({
     llm: model as any,
     tools: tools as any,
diff --git a/gitnexus/src/core/llm/context-builder.ts b/gitnexus/src/core/llm/context-builder.ts
index 7a7def819..d5289e7df 100644
--- a/gitnexus/src/core/llm/context-builder.ts
+++ b/gitnexus/src/core/llm/context-builder.ts
@@ -145,11 +145,11 @@ export async function getHotspots(
 
 /**
  * Build folder tree structure from file paths
- * Returns TOON format for token efficiency (~50% reduction vs ASCII tree)
+ * Returns ASCII tree format with smart truncation for readability
  */
 export async function getFolderTree(
   executeQuery: (cypher: string) => Promise<any[]>,
-  maxDepth: number = 3
+  maxDepth: number = 10
 ): Promise<string> {
   try {
     // Get all file paths
@@ -163,8 +163,8 @@ export async function getFolderTree(
 
     if (paths.length === 0) return '';
 
-    // Use TOON format for token efficiency
-    return formatPathsAsTOON(paths, maxDepth);
+    // Use hybrid ASCII format: clear hierarchy with smart truncation
+    return formatAsHybridAscii(paths, maxDepth);
   } catch (error) {
     console.error('Failed to get folder tree:', error);
     return '';
@@ -172,75 +172,88 @@ export async function getFolderTree(
 }
 
 /**
- * Format paths as TOON (Token-Oriented Object Notation)
- * Much more token-efficient than ASCII trees
+ * Format paths as indented tree (TOON-style, no ASCII box chars)
+ * Uses indentation only for hierarchy - more token efficient than ASCII tree
+ * Shows complete structure with no truncation
  * 
  * Example output:
- * folders:5
- *   src,src/cli,src/core,src/utils,test
- * files:8
- *   path
- *   src/index.ts
- *   src/cli/main.ts
- *   ...
+ * src/
+ *   components/ (45 files)
+ *   hooks/
+ *     useAppState.tsx
+ *     useSigma.ts
+ *   core/ (15 files)
+ * test/ (12 files)
  */
-function formatPathsAsTOON(paths: string[], maxDepth: number): string {
-  const folders = new Set<string>();
-  const files: string[] = [];
+function formatAsHybridAscii(paths: string[], maxDepth: number): string {
+  // Build tree structure
+  interface TreeNode {
+    isFile: boolean;
+    children: Map<string, TreeNode>;
+    fileCount: number;
+  }
+  
+  const root: TreeNode = { isFile: false, children: new Map(), fileCount: 0 };
   
   for (const path of paths) {
-    // Normalize path
     const normalized = path.replace(/\\/g, '/');
     const parts = normalized.split('/').filter(Boolean);
     
-    // Add file (truncate to maxDepth)
-    if (parts.length <= maxDepth + 1) {
-      files.push(normalized);
-    } else {
-      // Show truncated path for deep files
-      files.push(parts.slice(0, maxDepth + 1).join('/') + '/...');
-    }
-    
-    // Add folders
-    for (let i = 0; i < Math.min(parts.length - 1, maxDepth); i++) {
-      const folderPath = parts.slice(0, i + 1).join('/');
-      folders.add(folderPath);
-    }
-  }
-  
-  // Sort folders and files
-  const sortedFolders = Array.from(folders).sort();
-  const sortedFiles = [...new Set(files)].sort();
-  
-  // Build TOON output
-  const lines: string[] = [];
-  
-  // Folders section
-  lines.push(`folders:${sortedFolders.length}`);
-  if (sortedFolders.length > 0) {
-    // Compact comma-separated for small lists
-    if (sortedFolders.length <= 10) {
-      lines.push(`  ${sortedFolders.join(',')}`);
-    } else {
-      // Chunked for larger lists
-      for (let i = 0; i < sortedFolders.length; i += 8) {
-        lines.push(`  ${sortedFolders.slice(i, i + 8).join(',')}`);
+    let current = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      const isFile = i === parts.length - 1;
+      
+      if (!current.children.has(part)) {
+        current.children.set(part, { isFile, children: new Map(), fileCount: 0 });
+      }
+      
+      current = current.children.get(part)!;
+      if (isFile) {
+        // Count files in parent directories
+        let parent = root;
+        for (let j = 0; j < i; j++) {
+          parent = parent.children.get(parts[j])!;
+          parent.fileCount++;
+        }
       }
     }
   }
   
-  // Files section
-  lines.push(`files:${sortedFiles.length}`);
-  lines.push('  path');
-  // Show first 30 files, then summarize
-  const maxFiles = 30;
-  for (let i = 0; i < Math.min(sortedFiles.length, maxFiles); i++) {
-    lines.push(`  ${sortedFiles[i]}`);
-  }
-  if (sortedFiles.length > maxFiles) {
-    lines.push(`  ...(${sortedFiles.length - maxFiles} more)`);
+  // Render tree with indentation only (no ASCII box chars)
+  const lines: string[] = [];
+  
+  function renderNode(node: TreeNode, indent: string, depth: number): void {
+    const entries = [...node.children.entries()];
+    // Sort: folders first (by file count desc), then files alphabetically
+    entries.sort(([aName, aNode], [bName, bNode]) => {
+      if (aNode.isFile !== bNode.isFile) return aNode.isFile ? 1 : -1;
+      if (!aNode.isFile && !bNode.isFile) return bNode.fileCount - aNode.fileCount;
+      return aName.localeCompare(bName);
+    });
+    
+    for (const [name, childNode] of entries) {
+      if (childNode.isFile) {
+        // File
+        lines.push(`${indent}${name}`);
+      } else {
+        // Directory
+        const childCount = childNode.children.size;
+        const fileCount = childNode.fileCount;
+        
+        // Only collapse if beyond maxDepth
+        if (depth >= maxDepth) {
+          lines.push(`${indent}${name}/ (${fileCount} files)`);
+        } else {
+          lines.push(`${indent}${name}/`);
+          renderNode(childNode, indent + '  ', depth + 1);
+        }
+      }
+    }
   }
   
+  renderNode(root, '', 0);
+  
   return lines.join('\n');
 }
 
diff --git a/gitnexus/src/core/llm/tools.ts b/gitnexus/src/core/llm/tools.ts
index efd661e7a..b86357ebe 100644
--- a/gitnexus/src/core/llm/tools.ts
+++ b/gitnexus/src/core/llm/tools.ts
@@ -85,8 +85,8 @@ export const createGraphRAGTools = (
               OPTIONAL MATCH (n)-[r1:CodeRelation]->(dst)
               OPTIONAL MATCH (src)-[r2:CodeRelation]->(n)
               RETURN 
-                collect(DISTINCT {name: dst.name, type: r1.type}) AS outgoing,
-                collect(DISTINCT {name: src.name, type: r2.type}) AS incoming
+                collect(DISTINCT {name: dst.name, type: r1.type, confidence: r1.confidence}) AS outgoing,
+                collect(DISTINCT {name: src.name, type: r2.type, confidence: r2.confidence}) AS incoming
               LIMIT 1
             `;
             const connRes = await executeQuery(connectionsQuery);
@@ -97,8 +97,16 @@ export const createGraphRAGTools = (
               const rawIncoming = Array.isArray(row) ? row[1] : (row.incoming || []);
               const outgoing = (rawOutgoing || []).filter((c: any) => c && c.name).slice(0, 3);
               const incoming = (rawIncoming || []).filter((c: any) => c && c.name).slice(0, 3);
-              const outList = outgoing.map((c: any) => `-[${c.type}]-> ${c.name}`);
-              const inList = incoming.map((c: any) => `<-[${c.type}]- ${c.name}`);
+              
+              const fmt = (c: any, dir: 'out' | 'in') => {
+                const conf = c.confidence ? Math.round(c.confidence * 100) : 100;
+                return dir === 'out' 
+                  ? `-[${c.type} ${conf}%]-> ${c.name}`
+                  : `<-[${c.type} ${conf}%]- ${c.name}`;
+              };
+              
+              const outList = outgoing.map((c: any) => fmt(c, 'out'));
+              const inList = incoming.map((c: any) => fmt(c, 'in'));
               if (outList.length || inList.length) {
                 connections = `\n    Connections: ${[...outList, ...inList].join(', ')}`;
               }
@@ -168,18 +176,39 @@ export const createGraphRAGTools = (
           return 'Query returned no results.';
         }
         
-        // Format results
+        // Get column names from first result (now objects from executeQuery)
+        const firstRow = results[0];
+        const columnNames = typeof firstRow === 'object' && !Array.isArray(firstRow)
+          ? Object.keys(firstRow)
+          : [];
+        
+        // Format as markdown table (more token efficient than JSON per row)
+        if (columnNames.length > 0) {
+          const header = `| ${columnNames.join(' | ')} |`;
+          const separator = `|${columnNames.map(() => '---').join('|')}|`;
+          
+          const rows = results.slice(0, 50).map(row => {
+            const values = columnNames.map(col => {
+              const val = row[col];
+              if (val === null || val === undefined) return '';
+              if (typeof val === 'object') return JSON.stringify(val);
+              // Truncate long values and escape pipe characters
+              const str = String(val).replace(/\|/g, '\\|');
+              return str.length > 60 ? str.slice(0, 57) + '...' : str;
+            });
+            return `| ${values.join(' | ')} |`;
+          }).join('\n');
+          
+          const truncated = results.length > 50 ? `\n\n_(${results.length - 50} more rows)_` : '';
+          return `**${results.length} results:**\n\n${header}\n${separator}\n${rows}${truncated}`;
+        }
+        
+        // Fallback for non-object results
         const formatted = results.slice(0, 50).map((row, i) => {
-          if (Array.isArray(row)) {
-            return `[${i + 1}] ${row.join(', ')}`;
-          }
           return `[${i + 1}] ${JSON.stringify(row)}`;
         });
-        
-        const resultText = formatted.join('\n');
-        const truncated = results.length > 50 ? `\n... (${results.length - 50} more results)` : '';
-        
-        return `Query returned ${results.length} results:\n${resultText}${truncated}`;
+        const truncated = results.length > 50 ? `\n... (${results.length - 50} more)` : '';
+        return `${results.length} results:\n${formatted.join('\n')}${truncated}`;
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return `Cypher error: ${message}\n\nCheck your query syntax. Node tables: File, Folder, Function, Class, Interface, Method, CodeElement. Relation: CodeRelation with type property (CONTAINS, DEFINES, IMPORTS, CALLS). Example: MATCH (f:File)-[:CodeRelation {type: 'IMPORTS'}]->(g:File) RETURN f, g`;
@@ -197,7 +226,8 @@ Example queries:
 - Class inheritance: MATCH (child:Class)-[:CodeRelation {type: 'EXTENDS'}]->(parent:Class) RETURN child.name, parent.name
 - Classes implementing interface: MATCH (c:Class)-[:CodeRelation {type: 'IMPLEMENTS'}]->(i:Interface) RETURN c.name, i.name
 - Files importing a file: MATCH (f:File)-[:CodeRelation {type: 'IMPORTS'}]->(target:File) WHERE target.name = 'utils.ts' RETURN f.name
-- All connections: MATCH (n)-[r:CodeRelation]-(m) WHERE n.name = 'MyClass' RETURN m.name, r.type
+- All connections (with confidence): MATCH (n)-[r:CodeRelation]-(m) WHERE n.name = 'MyClass' AND r.confidence > 0.8 RETURN m.name, r.type, r.confidence
+- Find fuzzy matches: MATCH (n)-[r:CodeRelation]-(m) WHERE r.confidence < 0.8 RETURN n.name, r.reason
 
 For semantic+graph queries, include {{QUERY_VECTOR}} placeholder and provide a 'query' parameter:
 CALL QUERY_VECTOR_INDEX('CodeEmbedding', 'code_embedding_idx', {{QUERY_VECTOR}}, 10) YIELD node AS emb, distance
@@ -388,23 +418,43 @@ MATCH (n:Function {id: emb.nodeId}) RETURN n`,
   // ============================================================================
   
   const blastRadiusTool = tool(
-    async ({ target, direction, maxDepth }: { 
+    async ({ target, direction, maxDepth, relationTypes, includeTests, minConfidence }: { 
       target: string; 
       direction: 'upstream' | 'downstream';
       maxDepth?: number;
+      relationTypes?: string[];
+      includeTests?: boolean;
+      minConfidence?: number;
     }) => {
       const depth = Math.min(maxDepth ?? 3, 10);
+      const showTests = includeTests ?? false; // Default: exclude test files
+      const minConf = minConfidence ?? 0.7; // Default: exclude fuzzy matches (<70% confidence)
+      
+      // Test file patterns
+      const isTestFile = (path: string): boolean => {
+        if (!path) return false;
+        const p = path.toLowerCase();
+        return p.includes('.test.') || p.includes('.spec.') || 
+               p.includes('__tests__') || p.includes('__mocks__') ||
+               p.endsWith('.test.ts') || p.endsWith('.test.tsx') ||
+               p.endsWith('.spec.ts') || p.endsWith('.spec.tsx');
+      };
+      
+      // Default to usage-based relation types (exclude CONTAINS, DEFINES for impact analysis)
+      const defaultRelTypes = ['CALLS', 'IMPORTS', 'EXTENDS', 'IMPLEMENTS'];
+      const activeRelTypes = relationTypes && relationTypes.length > 0 
+        ? relationTypes 
+        : defaultRelTypes;
+      const relTypeFilter = activeRelTypes.map(t => `'${t}'`).join(', ');
       
-      // Determine the traversal direction
-      const directionArrow = direction === 'upstream' ? '<-' : '->';
       const directionLabel = direction === 'upstream' 
-        ? 'what depends on this (callers, importers, child classes)'
-        : 'what this depends on (callees, imports, parent classes)';
+        ? 'Files that DEPEND ON this (breakage risk)'
+        : 'Dependencies this RELIES ON';
       
       // Try to find the target node first
       const findTargetQuery = `
         MATCH (n) 
-        WHERE n.name = '${target.replace(/'/g, "''")}' 
+        WHERE n.name = '${target.replace(/'/g, "''")}'
         RETURN n.id AS id, label(n) AS nodeType, n.filePath AS filePath
         LIMIT 5
       `;
@@ -424,34 +474,214 @@ MATCH (n:Function {id: emb.nodeId}) RETURN n`,
       const targetNode = targetResults[0];
       const targetId = Array.isArray(targetNode) ? targetNode[0] : targetNode.id;
       const targetType = Array.isArray(targetNode) ? targetNode[1] : targetNode.nodeType;
+      const targetFilePath = Array.isArray(targetNode) ? targetNode[2] : targetNode.filePath;
       
-      // Note: KuzuDB doesn't support [r IN relationships(path) | r.type] list comprehension
-      // So we query each depth level separately for accurate depth tracking
+      // For File targets, find what calls code INSIDE the file (by filePath)
+      // For code elements (Function, Class, etc.), use the direct id
+      const isFileTarget = targetType === 'File';
       
-      // Get depth info with separate simpler queries for each depth level
+      // Query each depth level separately (KuzuDB doesn't support list comprehensions on paths)
+      // For depth 1: direct connections only
+      // For depth 2+: chain multiple single-hop queries
       const depthQueries: Promise<any[]>[] = [];
-      for (let d = 1; d <= Math.min(depth, 3); d++) {
-        const dQuery = direction === 'upstream'
+      
+      // Depth 1 query - direct connections with edge metadata
+      // For File targets: find callers of any code element with matching filePath
+      const d1Query = direction === 'upstream'
+        ? isFileTarget
           ? `
-            MATCH (target {id: '${targetId.replace(/'/g, "''")}'})
-            MATCH (affected)-[:CodeRelation*${d}]->(target)
-            RETURN DISTINCT affected.id AS id, affected.name AS name, label(affected) AS nodeType, affected.filePath AS filePath, ${d} AS depth
+            MATCH (affected)-[r:CodeRelation]->(callee)
+            WHERE callee.filePath = '${(targetFilePath || target).replace(/'/g, "''")}'
+              AND r.type IN [${relTypeFilter}]
+              AND affected.filePath <> callee.filePath
+              AND (r.confidence IS NULL OR r.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              1 AS depth,
+              r.type AS edgeType,
+              r.confidence AS confidence,
+              r.reason AS reason
             LIMIT 100
           `
           : `
             MATCH (target {id: '${targetId.replace(/'/g, "''")}'})
-            MATCH (target)-[:CodeRelation*${d}]->(affected)
-            RETURN DISTINCT affected.id AS id, affected.name AS name, label(affected) AS nodeType, affected.filePath AS filePath, ${d} AS depth
+            MATCH (affected)-[r:CodeRelation]->(target)
+            WHERE r.type IN [${relTypeFilter}]
+              AND (r.confidence IS NULL OR r.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              1 AS depth,
+              r.type AS edgeType,
+              r.confidence AS confidence,
+              r.reason AS reason
+            LIMIT 100
+          `
+        : isFileTarget
+          ? `
+            MATCH (caller)-[r:CodeRelation]->(affected)
+            WHERE caller.filePath = '${(targetFilePath || target).replace(/'/g, "''")}'
+              AND r.type IN [${relTypeFilter}]
+              AND caller.filePath <> affected.filePath
+              AND (r.confidence IS NULL OR r.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              1 AS depth,
+              r.type AS edgeType,
+              r.confidence AS confidence,
+              r.reason AS reason
+            LIMIT 100
+          `
+          : `
+            MATCH (target {id: '${targetId.replace(/'/g, "''")}'})
+            MATCH (target)-[r:CodeRelation]->(affected)
+            WHERE r.type IN [${relTypeFilter}]
+              AND (r.confidence IS NULL OR r.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              1 AS depth,
+              r.type AS edgeType,
+              r.confidence AS confidence,
+              r.reason AS reason
             LIMIT 100
           `;
-        depthQueries.push(executeQuery(dQuery).catch(() => []));
+      depthQueries.push(executeQuery(d1Query).catch(err => {
+        if (import.meta.env.DEV) console.warn('Blast radius d=1 query failed:', err);
+        return [];
+      }));
+      
+      // Depth 2 query - 2 hops
+      if (depth >= 2) {
+        const d2Query = direction === 'upstream'
+          ? `
+            MATCH (target {id: '${targetId.replace(/'/g, "''")}'})
+            MATCH (a)-[r1:CodeRelation]->(target)
+            MATCH (affected)-[r2:CodeRelation]->(a)
+            WHERE r1.type IN [${relTypeFilter}] AND r2.type IN [${relTypeFilter}]
+              AND affected.id <> target.id
+              AND (r1.confidence IS NULL OR r1.confidence >= ${minConf})
+              AND (r2.confidence IS NULL OR r2.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              2 AS depth,
+              r2.type AS edgeType,
+              r2.confidence AS confidence,
+              r2.reason AS reason
+            LIMIT 100
+          `
+          : `
+            MATCH (target {id: '${targetId.replace(/'/g, "''")}'})
+            MATCH (target)-[r1:CodeRelation]->(a)
+            MATCH (a)-[r2:CodeRelation]->(affected)
+            WHERE r1.type IN [${relTypeFilter}] AND r2.type IN [${relTypeFilter}]
+              AND affected.id <> target.id
+              AND (r1.confidence IS NULL OR r1.confidence >= ${minConf})
+              AND (r2.confidence IS NULL OR r2.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              2 AS depth,
+              r2.type AS edgeType,
+              r2.confidence AS confidence,
+              r2.reason AS reason
+            LIMIT 100
+          `;
+        depthQueries.push(executeQuery(d2Query).catch(err => {
+          if (import.meta.env.DEV) console.warn('Blast radius d=2 query failed:', err);
+          return [];
+        }));
+      }
+      
+      // Depth 3 query - 3 hops
+      if (depth >= 3) {
+        const d3Query = direction === 'upstream'
+          ? `
+            MATCH (target {id: '${targetId.replace(/'/g, "''")}'})
+            MATCH (a)-[r1:CodeRelation]->(target)
+            MATCH (b)-[r2:CodeRelation]->(a)
+            MATCH (affected)-[r3:CodeRelation]->(b)
+            WHERE r1.type IN [${relTypeFilter}] AND r2.type IN [${relTypeFilter}] AND r3.type IN [${relTypeFilter}]
+              AND affected.id <> target.id AND affected.id <> a.id
+              AND (r1.confidence IS NULL OR r1.confidence >= ${minConf})
+              AND (r2.confidence IS NULL OR r2.confidence >= ${minConf})
+              AND (r3.confidence IS NULL OR r3.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              3 AS depth,
+              r3.type AS edgeType,
+              r3.confidence AS confidence,
+              r3.reason AS reason
+            LIMIT 50
+          `
+          : `
+            MATCH (target {id: '${targetId.replace(/'/g, "''")}'})
+            MATCH (target)-[r1:CodeRelation]->(a)
+            MATCH (a)-[r2:CodeRelation]->(b)
+            MATCH (b)-[r3:CodeRelation]->(affected)
+            WHERE r1.type IN [${relTypeFilter}] AND r2.type IN [${relTypeFilter}] AND r3.type IN [${relTypeFilter}]
+              AND affected.id <> target.id AND affected.id <> a.id
+              AND (r1.confidence IS NULL OR r1.confidence >= ${minConf})
+              AND (r2.confidence IS NULL OR r2.confidence >= ${minConf})
+              AND (r3.confidence IS NULL OR r3.confidence >= ${minConf})
+            RETURN DISTINCT 
+              affected.id AS id, 
+              affected.name AS name, 
+              label(affected) AS nodeType, 
+              affected.filePath AS filePath,
+              affected.startLine AS startLine,
+              3 AS depth,
+              r3.type AS edgeType,
+              r3.confidence AS confidence,
+              r3.reason AS reason
+            LIMIT 50
+          `;
+        depthQueries.push(executeQuery(d3Query).catch(err => {
+          if (import.meta.env.DEV) console.warn('Blast radius d=3 query failed:', err);
+          return [];
+        }));
       }
       
       // Wait for all depth queries
       const depthResults = await Promise.all(depthQueries);
       
       // Combine results by depth
-      const byDepth: Map<number, any[]> = new Map();
+      interface NodeInfo {
+        id: string;
+        name: string;
+        nodeType: string;
+        filePath: string;
+        startLine?: number;
+        edgeType: string;
+        confidence: number;
+        reason: string;
+      }
+      const byDepth: Map<number, NodeInfo[]> = new Map();
       const allNodeIds: string[] = [];
       const seenIds = new Set<string>();
       
@@ -459,11 +689,27 @@ MATCH (n:Function {id: emb.nodeId}) RETURN n`,
         const d = idx + 1;
         results.forEach((row: any) => {
           const nodeId = Array.isArray(row) ? row[0] : row.id;
+          const filePath = Array.isArray(row) ? row[3] : row.filePath;
+          
+          // Skip test files if includeTests is false
+          if (!showTests && isTestFile(filePath)) return;
+          
           // Avoid duplicates (a node might appear at multiple depths)
           if (nodeId && !seenIds.has(nodeId)) {
             seenIds.add(nodeId);
             if (!byDepth.has(d)) byDepth.set(d, []);
-            byDepth.get(d)!.push(row);
+            
+            const info: NodeInfo = {
+              id: nodeId,
+              name: Array.isArray(row) ? row[1] : row.name,
+              nodeType: Array.isArray(row) ? row[2] : row.nodeType,
+              filePath: filePath,
+              startLine: Array.isArray(row) ? row[4] : row.startLine,
+              edgeType: Array.isArray(row) ? row[5] : row.edgeType || 'CALLS',
+              confidence: Array.isArray(row) ? row[6] : row.confidence ?? 1.0,
+              reason: Array.isArray(row) ? row[7] : row.reason || '',
+            };
+            byDepth.get(d)!.push(info);
             allNodeIds.push(nodeId);
           }
         });
@@ -472,83 +718,97 @@ MATCH (n:Function {id: emb.nodeId}) RETURN n`,
       const totalAffected = allNodeIds.length;
       
       if (totalAffected === 0) {
-        return `No ${direction} dependencies found for "${target}". This code appears to be ${direction === 'upstream' ? 'unused (not called by anything)' : 'self-contained (no outgoing dependencies)'}.`;
+        return `No ${direction} dependencies found for "${target}" (types: ${activeRelTypes.join(', ')}). This code appears to be ${direction === 'upstream' ? 'unused (not called by anything)' : 'self-contained (no outgoing dependencies)'}.`;
       }
       
-      // Build tiered output
+      // ===== COMPACT TABULAR OUTPUT =====
       const lines: string[] = [
-        `🔴 BLAST RADIUS: ${target}`,
-        ``,
-        `Direction: ${direction} (${directionLabel})`,
-        `Total affected: ${totalAffected} components`,
+        `🔴 BLAST RADIUS: ${target} | ${direction} | ${totalAffected} affected`,
         ``,
       ];
       
-      // Depth 1 - Critical
+      // Format helper: Type|Name|File:Line|EdgeType|Confidence
+      const formatNode = (n: NodeInfo): string => {
+        const fileName = n.filePath?.split('/').pop() || '';
+        const loc = n.startLine ? `${fileName}:${n.startLine}` : fileName;
+        const confPct = Math.round((n.confidence ?? 1) * 100);
+        const fuzzyMarker = confPct < 80 ? '[fuzzy]' : '';
+        return `  ${n.nodeType}|${n.name}|${loc}|${n.edgeType}|${confPct}%${fuzzyMarker}`;
+      };
+      
+      // Helper to get code snippet for a node (call site context)
+      const getCallSiteSnippet = (n: NodeInfo): string | null => {
+        if (!n.filePath || !n.startLine) return null;
+        
+        // Find the file in fileContents (try multiple path formats)
+        let content: string | undefined;
+        const normalizedPath = n.filePath.replace(/\\/g, '/');
+        
+        for (const [path, c] of fileContents.entries()) {
+          const normalizedKey = path.replace(/\\/g, '/');
+          if (normalizedKey === normalizedPath || 
+              normalizedKey.endsWith(normalizedPath) || 
+              normalizedPath.endsWith(normalizedKey)) {
+            content = c;
+            break;
+          }
+        }
+        
+        if (!content) return null;
+        
+        const lines = content.split('\n');
+        const lineIdx = n.startLine - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length) return null;
+        
+        // Get the line and trim it, max 80 chars
+        let snippet = lines[lineIdx].trim();
+        if (snippet.length > 80) snippet = snippet.slice(0, 77) + '...';
+        return snippet;
+      };
+      
+      // Depth 1 - Critical (with call site snippets)
       const depth1 = byDepth.get(1) || [];
       if (depth1.length > 0) {
-        lines.push(`═══════════════════════════════════════════════`);
-        lines.push(`DEPTH 1 — WILL BREAK (${depth1.length} components):`);
-        lines.push(`═══════════════════════════════════════════════`);
-        depth1.slice(0, 20).forEach((r: any) => {
-          const name = Array.isArray(r) ? r[1] : r.name;
-          const nodeType = Array.isArray(r) ? r[2] : r.nodeType;
-          const filePath = Array.isArray(r) ? r[3] : r.filePath;
-          const fileName = filePath?.split('/').pop() || '';
-          lines.push(`• ${name} (${nodeType}) at ${fileName}`);
+        const header = direction === 'upstream'
+          ? `d=1 (Directly DEPEND ON ${target}):`
+          : `d=1 (${target} USES these):`;
+        lines.push(header);
+        depth1.slice(0, 15).forEach(n => {
+          lines.push(formatNode(n));
+          // Add call site snippet for d=1 results
+          const snippet = getCallSiteSnippet(n);
+          if (snippet) {
+            lines.push(`    ↳ "${snippet}"`);
+          }
         });
-        if (depth1.length > 20) lines.push(`  ... and ${depth1.length - 20} more`);
+        if (depth1.length > 15) lines.push(`  ... +${depth1.length - 15} more`);
         lines.push(``);
       }
       
       // Depth 2 - High impact
       const depth2 = byDepth.get(2) || [];
       if (depth2.length > 0) {
-        lines.push(`═══════════════════════════════════════════════`);
-        lines.push(`DEPTH 2 — LIKELY AFFECTED (${depth2.length} components):`);
-        lines.push(`═══════════════════════════════════════════════`);
-        depth2.slice(0, 15).forEach((r: any) => {
-          const name = Array.isArray(r) ? r[1] : r.name;
-          const nodeType = Array.isArray(r) ? r[2] : r.nodeType;
-          const filePath = Array.isArray(r) ? r[3] : r.filePath;
-          const fileName = filePath?.split('/').pop() || '';
-          lines.push(`• ${name} (${nodeType}) at ${fileName}`);
-        });
-        if (depth2.length > 15) lines.push(`  ... and ${depth2.length - 15} more`);
+        const header = direction === 'upstream'
+          ? `d=2 (Indirectly DEPEND ON ${target}):`
+          : `d=2 (${target} USES these indirectly):`;
+        lines.push(header);
+        depth2.slice(0, 15).forEach(n => lines.push(formatNode(n)));
+        if (depth2.length > 15) lines.push(`  ... +${depth2.length - 15} more`);
         lines.push(``);
       }
       
       // Depth 3 - Transitive
       const depth3 = byDepth.get(3) || [];
       if (depth3.length > 0) {
-        lines.push(`═══════════════════════════════════════════════`);
-        lines.push(`DEPTH 3 — MAY NEED TESTING (${depth3.length} components):`);
-        lines.push(`═══════════════════════════════════════════════`);
-        depth3.slice(0, 5).forEach((r: any) => {
-          const name = Array.isArray(r) ? r[1] : r.name;
-          const nodeType = Array.isArray(r) ? r[2] : r.nodeType;
-          lines.push(`• ${name} (${nodeType})`);
-        });
-        if (depth3.length > 5) lines.push(`  ... and ${depth3.length - 5} more`);
+        lines.push(`d=3 (Deep impact/dependency):`);
+        depth3.slice(0, 5).forEach(n => lines.push(formatNode(n)));
+        if (depth3.length > 5) lines.push(`  ... +${depth3.length - 5} more`);
         lines.push(``);
       }
       
-      // Trusted analysis marker
-      lines.push(`═══════════════════════════════════════════════`);
+      // Compact footer
       lines.push(`✅ GRAPH ANALYSIS COMPLETE (trusted)`);
-      lines.push(`═══════════════════════════════════════════════`);
-      lines.push(`The above results are verified from code graph traversal.`);
-      lines.push(`No additional validation needed for static dependencies.`);
-      lines.push(``);
-      
-      // Optional dynamic detection
-      lines.push(`═══════════════════════════════════════════════`);
-      lines.push(`⚠️ OPTIONAL: Dynamic Pattern Check`);
-      lines.push(`═══════════════════════════════════════════════`);
-      lines.push(`The graph cannot track: event listeners, DI, dynamic imports.`);
-      lines.push(`If thoroughness is needed, run:`);
-      lines.push(`• grep({ pattern: "${target}", fileFilter: "*.ts" })`);
-      lines.push(`• grep({ pattern: "${target}", fileFilter: "*.json" })`);
+      lines.push(`⚠️ Optional: grep("${target}") for dynamic patterns`);
       lines.push(``);
       
       // Add the marker for UI highlighting
@@ -561,24 +821,31 @@ MATCH (n:Function {id: emb.nodeId}) RETURN n`,
       name: 'blastRadius',
       description: `Analyze the blast radius (impact) of changing a function, class, or file.
 
-Use this when users ask:
+Use when users ask:
 - "What would break if I changed X?"
 - "What depends on X?"
 - "Impact analysis for X"
-- "Blast radius of X"
 
 Direction:
 - upstream: Find what CALLS/IMPORTS/EXTENDS this target (what would break)
 - downstream: Find what this target CALLS/IMPORTS/EXTENDS (dependencies)
 
-Results are grouped by depth:
-- Depth 1: Direct dependencies (will definitely break)
-- Depth 2: Indirect (likely affected)
-- Depth 3+: Transitive (may need testing)`,
+Output format (compact tabular):
+  Type|Name|File:Line|EdgeType|Confidence%
+  
+EdgeType: CALLS, IMPORTS, EXTENDS, IMPLEMENTS
+Confidence: 100% = certain, <80% = fuzzy match (may be false positive)
+
+relationTypes filter (optional):
+- Default: CALLS, IMPORTS, EXTENDS, IMPLEMENTS (usage-based)
+- Can add CONTAINS, DEFINES for structural analysis`,
       schema: z.object({
         target: z.string().describe('Name of the function, class, or file to analyze'),
         direction: z.enum(['upstream', 'downstream']).describe('upstream = what depends on this; downstream = what this depends on'),
         maxDepth: z.number().optional().nullable().describe('Max traversal depth (default: 3, max: 10)'),
+        relationTypes: z.array(z.string()).optional().nullable().describe('Filter by relation types: CALLS, IMPORTS, EXTENDS, IMPLEMENTS, CONTAINS, DEFINES (default: usage-based)'),
+        includeTests: z.boolean().optional().nullable().describe('Include test files in results (default: false, excludes .test.ts, .spec.ts, __tests__)'),
+        minConfidence: z.number().optional().nullable().describe('Minimum edge confidence 0-1 (default: 0.7, excludes fuzzy/inferred matches)'),
       }),
     }
   );
diff --git a/gitnexus/src/hooks/useAppState.tsx b/gitnexus/src/hooks/useAppState.tsx
index e99c64d59..28bffef81 100644
--- a/gitnexus/src/hooks/useAppState.tsx
+++ b/gitnexus/src/hooks/useAppState.tsx
@@ -145,7 +145,7 @@ interface AppState {
 
   // LLM methods
   refreshLLMSettings: () => void;
-  initializeAgent: () => Promise<void>;
+  initializeAgent: (overrideProjectName?: string) => Promise<void>;
   sendChatMessage: (message: string) => Promise<void>;
   clearChat: () => void;
 
@@ -540,7 +540,7 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => {
     setLLMSettings(loadSettings());
   }, []);
 
-  const initializeAgent = useCallback(async (): Promise<void> => {
+  const initializeAgent = useCallback(async (overrideProjectName?: string): Promise<void> => {
     const api = apiRef.current;
     if (!api) {
       setAgentError('Worker not initialized');
@@ -557,7 +557,9 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => {
     setAgentError(null);
 
     try {
-      const result = await api.initializeAgent(config);
+      // Use override if provided (for fresh loads), fallback to state (for re-init)
+      const effectiveProjectName = overrideProjectName || projectName || 'project';
+      const result = await api.initializeAgent(config, effectiveProjectName);
       if (result.success) {
         setIsAgentReady(true);
         setAgentError(null);
@@ -575,7 +577,7 @@ export const AppStateProvider = ({ children }: { children: ReactNode }) => {
     } finally {
       setIsAgentInitializing(false);
     }
-  }, []);
+  }, [projectName]);
 
   const sendChatMessage = useCallback(async (message: string): Promise<void> => {
     const api = apiRef.current;
diff --git a/gitnexus/src/hooks/useSigma.ts b/gitnexus/src/hooks/useSigma.ts
index e3df1d196..a832aa221 100644
--- a/gitnexus/src/hooks/useSigma.ts
+++ b/gitnexus/src/hooks/useSigma.ts
@@ -396,17 +396,28 @@ export const useSigma = (options: UseSigmaOptions = {}): UseSigmaReturn => {
         
         const currentSelected = selectedNodeRef.current;
         const highlighted = highlightedRef.current;
-        const hasHighlights = highlighted.size > 0;
+        const blastRadius = blastRadiusRef.current;
+        const hasHighlights = highlighted.size > 0 || blastRadius.size > 0; // Check BOTH sets
         
         if (hasHighlights && !currentSelected) {
           const graph = graphRef.current;
           if (graph) {
             const [source, target] = graph.extremities(edge);
-            const bothHighlighted = highlighted.has(source) && highlighted.has(target);
-            const oneHighlighted = highlighted.has(source) || highlighted.has(target);
+            
+            // Check if nodes are in EITHER set
+            const isSourceActive = highlighted.has(source) || blastRadius.has(source);
+            const isTargetActive = highlighted.has(target) || blastRadius.has(target);
+            
+            const bothHighlighted = isSourceActive && isTargetActive;
+            const oneHighlighted = isSourceActive || isTargetActive;
             
             if (bothHighlighted) {
-              res.color = '#06b6d4';
+              // If both nodes are in blast radius, use red edge
+              if (blastRadius.has(source) && blastRadius.has(target)) {
+                res.color = '#ef4444';
+              } else {
+                res.color = '#06b6d4';
+              }
               res.size = Math.max(2, (data.size || 1) * 3);
               res.zIndex = 2;
             } else if (oneHighlighted) {
diff --git a/gitnexus/src/workers/ingestion.worker.ts b/gitnexus/src/workers/ingestion.worker.ts
index d78667ed1..c1406fb4b 100644
--- a/gitnexus/src/workers/ingestion.worker.ts
+++ b/gitnexus/src/workers/ingestion.worker.ts
@@ -382,8 +382,9 @@ const workerApi = {
    * Initialize the Graph RAG agent with a provider configuration
    * Must be called before using chat methods
    * @param config - Provider configuration (Azure OpenAI or Gemini)
+   * @param projectName - Name of the loaded project/repository
    */
-  async initializeAgent(config: ProviderConfig): Promise<{ success: boolean; error?: string }> {
+  async initializeAgent(config: ProviderConfig, projectName?: string): Promise<{ success: boolean; error?: string }> {
     try {
       const kuzu = await getKuzuAdapter();
       if (!kuzu.isKuzuReady()) {
@@ -424,14 +425,15 @@ const workerApi = {
         return mergeWithRRF(bm25Results, semanticResults, k ?? 10);
       };
 
-      // Build codebase context for dynamic prompt injection
-      // Extract project name from first file path
-      const firstPath = storedFileContents.keys().next().value || '';
-      const projectName = firstPath.split('/')[0] || firstPath.split('\\')[0] || 'project';
+      // Use provided projectName, or fallback to 'project' if not provided
+      const resolvedProjectName = projectName || 'project';
+      if (import.meta.env.DEV) {
+        console.log('📛 Project name received:', { provided: projectName, resolved: resolvedProjectName });
+      }
       
       let codebaseContext;
       try {
-        codebaseContext = await buildCodebaseContext(kuzu.executeQuery, projectName);
+        codebaseContext = await buildCodebaseContext(kuzu.executeQuery, resolvedProjectName);
         if (import.meta.env.DEV) {
           console.log('📊 Codebase context built:', {
             files: codebaseContext.stats.fileCount,