@syke1/mcp-server 1.4.17 → 1.4.19

package/dist/tools/analyze-impact.js

@@ -34,14 +34,198 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeImpact = analyzeImpact;
+exports.getImpactMemoCache = getImpactMemoCache;
 exports.classifyRisk = classifyRisk;
 exports.getHubFiles = getHubFiles;
 const path = __importStar(require("path"));
+const risk_scorer_1 = require("../scoring/risk-scorer");
+const change_coupling_1 = require("../git/change-coupling");
+const memo_cache_1 = require("../graph/memo-cache");
 /**
  * BFS reverse traversal to find all files impacted by modifying `filePath`.
+ * When SCC data is available, uses the condensed DAG for more accurate
+ * cascade-level analysis and circular dependency detection.
+ *
+ * Optionally computes a composite risk score when `includeRiskScore` is true.
+ * Optionally computes historical change coupling when `includeCoupling` is true.
  */
-function analyzeImpact(filePath, graph) {
+async function analyzeImpact(filePath, graph, options) {
     const normalized = path.normalize(filePath);
+    const toRelative = (f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/");
+    // Check memo cache for a cached BFS result (fast path)
+    const memoCache = (0, memo_cache_1.getMemoCache)();
+    const cached = memoCache.get(normalized);
+    if (cached) {
+        // Reconstruct ImpactResult from cached MemoEntry
+        const directDependents = (graph.reverse.get(normalized) || []).map(toRelative);
+        const directSet = new Set(directDependents);
+        const transitiveDependents = cached.impactSet
+            .map(f => toRelative(f))
+            .filter(rel => !directSet.has(rel));
+        let result = {
+            filePath: normalized,
+            relativePath: toRelative(normalized),
+            riskLevel: cached.riskLevel,
+            directDependents,
+            transitiveDependents,
+            totalImpacted: cached.directCount + cached.transitiveCount,
+            cascadeLevels: cached.cascadeLevels,
+            fromCache: true,
+        };
+        // Still compute risk score and coupling on top of cached BFS result
+        if (options?.includeRiskScore && graph.files.has(normalized)) {
+            try {
+                (0, risk_scorer_1.computeProjectMetrics)(graph);
+                const riskScore = (0, risk_scorer_1.getRiskScore)(normalized, graph, options.fileContent ?? null);
+                result.riskScore = riskScore;
+                const compositeLevel = riskScore.riskLevel;
+                if (isHigherRisk(compositeLevel, result.riskLevel)) {
+                    result.riskLevel = mapCompositeToLegacy(compositeLevel);
+                }
+            }
+            catch (err) {
+                console.error(`[syke:scoring] Failed to compute risk score for ${filePath}: ${err}`);
+            }
+        }
+        if (options?.includeCoupling) {
+            try {
+                const coupledFiles = await computeCoupledFiles(normalized, graph, toRelative);
+                if (coupledFiles.length > 0) {
+                    result.coupledFiles = coupledFiles;
+                }
+            }
+            catch (err) {
+                console.error(`[syke:coupling] Failed to compute change coupling for ${filePath}: ${err}`);
+            }
+        }
+        return result;
+    }
+    // Cache miss: run full BFS analysis
+    let result;
+    if (graph.scc) {
+        result = analyzeImpactWithSCC(normalized, graph, toRelative);
+    }
+    else {
+        // Fallback: original BFS on raw graph (backward compatible)
+        result = analyzeImpactBFS(normalized, graph, toRelative);
+    }
+    // Store BFS result in memo cache for future queries
+    const allImpactedAbsPaths = [
+        ...result.directDependents,
+        ...result.transitiveDependents,
+    ].map(rel => path.normalize(path.join(graph.sourceDir, rel)));
+    memoCache.set(normalized, {
+        impactSet: allImpactedAbsPaths,
+        directCount: result.directDependents.length,
+        transitiveCount: result.transitiveDependents.length,
+        riskLevel: result.riskLevel,
+        cascadeLevels: result.cascadeLevels,
+        computedAt: Date.now(),
+    });
+    // Compute composite risk score if requested
+    if (options?.includeRiskScore && graph.files.has(normalized)) {
+        try {
+            // Ensure project metrics are computed for accurate normalization
+            (0, risk_scorer_1.computeProjectMetrics)(graph);
+            const riskScore = (0, risk_scorer_1.getRiskScore)(normalized, graph, options.fileContent ?? null);
+            result.riskScore = riskScore;
+            // Upgrade riskLevel if composite score yields a higher severity
+            const compositeLevel = riskScore.riskLevel;
+            if (isHigherRisk(compositeLevel, result.riskLevel)) {
+                result.riskLevel = mapCompositeToLegacy(compositeLevel);
+            }
+        }
+        catch (err) {
+            // Non-critical: if scoring fails, the result is still valid without it
+            console.error(`[syke:scoring] Failed to compute risk score for ${filePath}: ${err}`);
+        }
+    }
+    // Compute historical change coupling if requested
+    if (options?.includeCoupling) {
+        try {
+            const coupledFiles = await computeCoupledFiles(normalized, graph, toRelative);
+            if (coupledFiles.length > 0) {
+                result.coupledFiles = coupledFiles;
+            }
+        }
+        catch (err) {
+            // Non-critical: coupling analysis failure should not break impact analysis
+            console.error(`[syke:coupling] Failed to compute change coupling for ${filePath}: ${err}`);
+        }
+    }
+    return result;
+}
+/**
+ * Compute historical change coupling for a file, filtering to only show
+ * couplings that are NOT already in the dependency graph ("hidden" dependencies).
+ * Returns at most 5 coupled files, sorted by confidence.
+ */
+async function computeCoupledFiles(normalizedPath, graph, toRelative) {
+    const couplingResult = await (0, change_coupling_1.mineGitHistory)(graph.projectRoot);
+    if (couplingResult.totalCommitsAnalyzed === 0) {
+        return [];
+    }
+    // Convert file path to git-relative format (forward slashes, relative to project root)
+    const gitRelPath = path.relative(graph.projectRoot, normalizedPath).replace(/\\/g, "/");
+    const couplings = (0, change_coupling_1.getCoupledFiles)(gitRelPath, couplingResult);
+    if (couplings.length === 0) {
+        return [];
+    }
+    // Build a set of all files in the dependency graph (both direct and transitive)
+    const graphDeps = new Set();
+    // Forward dependencies of this file
+    const forwardDeps = graph.forward.get(normalizedPath) || [];
+    for (const d of forwardDeps) {
+        graphDeps.add(path.relative(graph.projectRoot, d).replace(/\\/g, "/"));
+    }
+    // Reverse dependents of this file
+    const reverseDeps = graph.reverse.get(normalizedPath) || [];
+    for (const d of reverseDeps) {
+        graphDeps.add(path.relative(graph.projectRoot, d).replace(/\\/g, "/"));
+    }
+    const results = [];
+    for (const coupling of couplings) {
+        // Determine which file is the "other" file in the pair
+        const otherFile = coupling.file1 === gitRelPath ? coupling.file2 : coupling.file1;
+        const inGraph = graphDeps.has(otherFile);
+        // Convert to source-dir-relative path for display
+        const otherAbsolute = path.normalize(path.join(graph.projectRoot, otherFile));
+        const displayPath = toRelative(otherAbsolute);
+        results.push({
+            relativePath: displayPath,
+            confidence: coupling.confidence,
+            coChangeCount: coupling.coChangeCount,
+            inDependencyGraph: inGraph,
+        });
+    }
+    // Filter to only hidden dependencies (not in graph) and limit to top 5
+    const hidden = results.filter((r) => !r.inDependencyGraph);
+    return hidden.slice(0, 5);
+}
+/**
+ * Check if a composite risk level is higher than a legacy risk level.
+ */
+function isHigherRisk(composite, legacy) {
+    const compositeRank = { CRITICAL: 4, HIGH: 3, MEDIUM: 2, LOW: 1, SAFE: 0 };
+    const legacyRank = { HIGH: 3, MEDIUM: 2, LOW: 1, NONE: 0 };
+    return (compositeRank[composite] || 0) > (legacyRank[legacy] || 0);
+}
+/**
+ * Map a composite risk level to the legacy RiskLevel type.
+ */
+function mapCompositeToLegacy(composite) {
+    switch (composite) {
+        case "CRITICAL": return "HIGH"; // Legacy type has no CRITICAL, map to HIGH
+        case "HIGH": return "HIGH";
+        case "MEDIUM": return "MEDIUM";
+        case "LOW": return "LOW";
+        case "SAFE": return "NONE";
+    }
+}
+/**
+ * Original BFS-based impact analysis (no SCC data).
+ */
+function analyzeImpactBFS(normalized, graph, toRelative) {
     // Direct dependents (depth 1)
     const directDependents = graph.reverse.get(normalized) || [];
     // BFS for transitive dependents (all depths)
@@ -65,7 +249,6 @@ function analyzeImpact(filePath, graph) {
     const directSet = new Set(directDependents);
     const transitiveDependents = [...visited].filter((f) => !directSet.has(f));
     const riskLevel = classifyRisk(totalImpacted);
-    const toRelative = (f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/");
     return {
         filePath: normalized,
         relativePath: toRelative(normalized),
@@ -75,6 +258,99 @@ function analyzeImpact(filePath, graph) {
         totalImpacted,
     };
 }
+/**
+ * SCC-enhanced impact analysis using the condensed DAG.
+ *
+ * 1. If the changed file is in a cyclic SCC (size > 1), ALL files in that SCC
+ *    are immediately marked as affected at cascade level 0.
+ * 2. BFS on the condensed DAG (using reverse edges = dependents) to find
+ *    all impacted SCCs with correct cascade levels.
+ * 3. Each file inherits the cascade level of its SCC.
+ */
+function analyzeImpactWithSCC(normalized, graph, toRelative) {
+    const scc = graph.scc;
+    const { nodeToComponent, condensed } = scc;
+    const sccIndex = nodeToComponent.get(normalized);
+    // File not found in SCC mapping — fall back to BFS
+    if (sccIndex === undefined) {
+        return analyzeImpactBFS(normalized, graph, toRelative);
+    }
+    const startNode = condensed.nodes[sccIndex];
+    // Collect circular cluster info
+    const circularCluster = startNode.isCyclic
+        ? startNode.files.filter(f => f !== normalized).map(toRelative)
+        : undefined;
+    // BFS on condensed DAG reverse edges to find all impacted SCCs
+    // Level 0 = the SCC containing the changed file
+    // Level 1 = SCCs that directly depend on the changed SCC
+    // Level N = SCCs at distance N in the condensed DAG
+    const visitedSCCs = new Map(); // SCC index -> cascade level
+    visitedSCCs.set(sccIndex, 0);
+    const queue = [
+        { sccIdx: sccIndex, level: 0 },
+    ];
+    while (queue.length > 0) {
+        const { sccIdx, level } = queue.shift();
+        // Get SCCs that depend on this SCC (reverse edges in condensed DAG)
+        const dependentSCCs = condensed.reverse.get(sccIdx) || [];
+        for (const depSCC of dependentSCCs) {
+            if (!visitedSCCs.has(depSCC)) {
+                visitedSCCs.set(depSCC, level + 1);
+                queue.push({ sccIdx: depSCC, level: level + 1 });
+            }
+        }
+    }
+    // Expand SCC indices back to individual files
+    const cascadeLevels = new Map();
+    const allImpactedFiles = new Set();
+    for (const [sccIdx, level] of visitedSCCs) {
+        const node = condensed.nodes[sccIdx];
+        for (const file of node.files) {
+            if (file === normalized)
+                continue; // Exclude the changed file itself
+            allImpactedFiles.add(file);
+            cascadeLevels.set(file, level);
+        }
+    }
+    // Separate into direct (level 1 from raw graph) and transitive
+    const rawDirectDependents = graph.reverse.get(normalized) || [];
+    const directSet = new Set(rawDirectDependents);
+    // Files in the same cyclic SCC are also considered "direct" dependents
+    if (startNode.isCyclic) {
+        for (const f of startNode.files) {
+            if (f !== normalized) {
+                directSet.add(f);
+            }
+        }
+    }
+    const directDependents = [...allImpactedFiles].filter(f => directSet.has(f));
+    const transitiveDependents = [...allImpactedFiles].filter(f => !directSet.has(f));
+    const totalImpacted = allImpactedFiles.size;
+    const riskLevel = classifyRisk(totalImpacted);
+    // Convert cascade levels keys to relative paths
+    const relativeCascadeLevels = new Map();
+    for (const [file, level] of cascadeLevels) {
+        relativeCascadeLevels.set(toRelative(file), level);
+    }
+    return {
+        filePath: normalized,
+        relativePath: toRelative(normalized),
+        riskLevel,
+        directDependents: directDependents.map(toRelative),
+        transitiveDependents: transitiveDependents.map(toRelative),
+        totalImpacted,
+        cascadeLevels: relativeCascadeLevels,
+        circularCluster,
+        sccCount: condensed.nodes.length,
+        cyclicSCCs: condensed.nodes.filter(n => n.isCyclic).length,
+    };
+}
+/**
+ * Get the memo cache instance for diagnostics (cache stats, etc.).
+ */
+function getImpactMemoCache() {
+    return (0, memo_cache_1.getMemoCache)();
+}
 function classifyRisk(count) {
     if (count >= 10)
         return "HIGH";

package/dist/tools/gate-build.d.ts

@@ -1,4 +1,5 @@
 import { DependencyGraph } from "../graph";
+import { RiskScore } from "../scoring/risk-scorer";
 export type GateVerdict = "PASS" | "WARN" | "FAIL";
 export interface GateIssue {
     file: string;
@@ -13,13 +14,17 @@ export interface GateResult {
     stats: {
         filesInGraph: number;
         unresolvedWarnings: number;
+        sccCount?: number;
+        cyclicSCCs?: number;
     };
     autoAcknowledged: number;
+    /** Composite risk scores for specified files (when available) */
+    riskScores?: Map<string, RiskScore>;
 }
 /**
  * Run the build gate check.
  * If `specifiedFiles` is provided, only warnings for those files are considered.
- * Cycle detection also starts from those files.
+ * Cycle detection uses SCC data when available (faster and more complete).
  */
-export declare function gateCheck(graph: DependencyGraph, specifiedFiles?: string[]): GateResult;
+export declare function gateCheck(graph: DependencyGraph, specifiedFiles?: string[]): Promise<GateResult>;
 export declare function formatGateResult(result: GateResult): string;

package/dist/tools/gate-build.js

@@ -38,11 +38,69 @@ exports.formatGateResult = formatGateResult;
 const path = __importStar(require("path"));
 const server_1 = require("../web/server");
 const analyze_impact_1 = require("./analyze-impact");
+const risk_scorer_1 = require("../scoring/risk-scorer");
+const change_coupling_1 = require("../git/change-coupling");
 /**
- * DFS forward traversal from specified files to detect circular dependencies.
- * Returns at most `maxCycles` cycles for performance.
+ * Detect circular dependencies using SCC data.
+ * Much faster and more complete than DFS-based cycle detection.
+ * Returns all cyclic SCCs that contain any of the specified files.
  */
-function detectCyclesForFiles(files, graph, maxCycles = 10) {
+function detectCyclesWithSCC(files, graph) {
+    const scc = graph.scc;
+    if (!scc) {
+        // Fallback to old DFS if SCC data not available
+        return detectCyclesForFilesDFS(files, graph, 10);
+    }
+    const cycles = [];
+    const reportedSCCs = new Set();
+    for (const file of files) {
+        if (!graph.files.has(file))
+            continue;
+        const sccIndex = scc.nodeToComponent.get(file);
+        if (sccIndex === undefined)
+            continue;
+        const node = scc.condensed.nodes[sccIndex];
+        if (!node.isCyclic)
+            continue;
+        // Only report each cyclic SCC once
+        if (reportedSCCs.has(sccIndex))
+            continue;
+        reportedSCCs.add(sccIndex);
+        // Build a cycle representation: all files in the SCC form a cycle
+        // For display, show the circular path by appending the first file at the end
+        const cyclePath = [...node.files, node.files[0]];
+        cycles.push({
+            cycle: cyclePath,
+            file,
+        });
+    }
+    return cycles;
+}
+/**
+ * Also scan the entire graph for cyclic SCCs (not just specified files).
+ * Returns summary info about all cycles in the project.
+ */
+function detectAllCycles(graph) {
+    const scc = graph.scc;
+    if (!scc)
+        return [];
+    const cycles = [];
+    for (const node of scc.condensed.nodes) {
+        if (!node.isCyclic)
+            continue;
+        const cyclePath = [...node.files, node.files[0]];
+        cycles.push({
+            cycle: cyclePath,
+            file: node.files[0],
+        });
+    }
+    return cycles;
+}
+/**
+ * Legacy DFS forward traversal from specified files to detect circular dependencies.
+ * Used as fallback when SCC data is not available.
+ */
+function detectCyclesForFilesDFS(files, graph, maxCycles = 10) {
     const cycles = [];
     const globalVisited = new Set();
     for (const startFile of files) {
@@ -62,7 +120,7 @@ function detectCyclesForFiles(files, graph, maxCycles = 10) {
                 if (cycles.length >= maxCycles)
                     break;
                 if (stack.has(dep)) {
-                    // Back-edge found → cycle
+                    // Back-edge found: cycle
                     const idx = pathStack.indexOf(dep);
                     if (idx >= 0) {
                         cycles.push({
@@ -79,7 +137,6 @@ function detectCyclesForFiles(files, graph, maxCycles = 10) {
             pathStack.pop();
         }
         dfs(startFile);
-        // Mark all visited from this start as globally visited
         for (const f of stack)
             globalVisited.add(f);
     }
@@ -89,13 +146,17 @@ function detectCyclesForFiles(files, graph, maxCycles = 10) {
 /**
  * Run the build gate check.
  * If `specifiedFiles` is provided, only warnings for those files are considered.
- * Cycle detection also starts from those files.
+ * Cycle detection uses SCC data when available (faster and more complete).
  */
-function gateCheck(graph, specifiedFiles) {
+async function gateCheck(graph, specifiedFiles) {
     const allWarnings = (0, server_1.getUnacknowledgedWarnings)();
+    const sccCount = graph.scc?.condensed.nodes.length;
+    const cyclicSCCs = graph.scc?.condensed.nodes.filter(n => n.isCyclic).length;
     const stats = {
         filesInGraph: graph.files.size,
         unresolvedWarnings: allWarnings.length,
+        sccCount,
+        cyclicSCCs,
     };
     // Filter warnings to specified files if provided
     const warnings = specifiedFiles
@@ -118,26 +179,60 @@ function gateCheck(graph, specifiedFiles) {
             });
         }
     }
-    // 2. Detect cycles for specified files (or skip full-graph scan for perf)
+    // 2. Detect cycles using SCC (or fallback to DFS)
     const filesToCheck = specifiedFiles || [];
-    const cycles = detectCyclesForFiles(filesToCheck, graph, 10);
+    const cycles = detectCyclesWithSCC(filesToCheck, graph);
     for (const c of cycles) {
         const cyclePath = c.cycle
             .map((f) => path.relative(graph.sourceDir, f).replace(/\\/g, "/"))
-            .join(" → ");
+            .join(" -> ");
         issues.push({
             file: path.relative(graph.sourceDir, c.file).replace(/\\/g, "/"),
             severity: "CRITICAL",
-            description: `Circular dependency: ${cyclePath}`,
+            description: `Circular dependency detected (${c.cycle.length - 1} files): ${cyclePath}`,
         });
     }
-    // 3. Check if hub files were modified
+    // 3. Check if hub files were modified and compute composite risk scores
+    const riskScores = new Map();
     if (specifiedFiles) {
+        // Compute project metrics for accurate normalization
+        try {
+            (0, risk_scorer_1.computeProjectMetrics)(graph);
+        }
+        catch {
+            // Non-critical: proceed without project-wide normalization
+        }
         const hubs = (0, analyze_impact_1.getHubFiles)(graph, 5);
         const hubPaths = new Set(hubs.map((h) => h.relativePath));
         for (const f of specifiedFiles) {
+            if (!graph.files.has(f))
+                continue;
             const rel = path.relative(graph.sourceDir, f).replace(/\\/g, "/");
-            if (hubPaths.has(rel)) {
+            // Compute composite risk score for each specified file
+            try {
+                const score = (0, risk_scorer_1.getRiskScore)(f, graph);
+                riskScores.set(rel, score);
+                // CRITICAL: composite score >= 0.8 is critical regardless of dependent count
+                if (score.riskLevel === "CRITICAL") {
+                    issues.push({
+                        file: rel,
+                        severity: "CRITICAL",
+                        description: `Critical risk score ${score.composite.toFixed(2)} (fan-in: ${score.transitiveFanIn}, cascade: ${score.cascadeDepth} levels, complexity: ${score.complexity})`,
+                    });
+                }
+                else if (score.riskLevel === "HIGH") {
+                    issues.push({
+                        file: rel,
+                        severity: "HIGH",
+                        description: `High risk score ${score.composite.toFixed(2)} (fan-in: ${score.transitiveFanIn}, cascade: ${score.cascadeDepth} levels, complexity: ${score.complexity})`,
+                    });
+                }
+            }
+            catch {
+                // Fall through to hub check below
+            }
+            // Legacy hub file check (only if not already flagged by composite score)
+            if (hubPaths.has(rel) && !riskScores.has(rel)) {
                 const hub = hubs.find((h) => h.relativePath === rel);
                 issues.push({
                     file: rel,
@@ -145,6 +240,61 @@ function gateCheck(graph, specifiedFiles) {
                     description: `Hub file modified (${hub.dependentCount} dependents, ${hub.riskLevel} risk)`,
                 });
             }
+            else if (hubPaths.has(rel)) {
+                // Hub file already scored by composite — only add hub note if severity was LOW/MEDIUM
+                const score = riskScores.get(rel);
+                if (score && (score.riskLevel === "LOW" || score.riskLevel === "MEDIUM" || score.riskLevel === "SAFE")) {
+                    const hub = hubs.find((h) => h.relativePath === rel);
+                    issues.push({
+                        file: rel,
+                        severity: "MEDIUM",
+                        description: `Hub file modified (${hub.dependentCount} dependents), composite score: ${score.composite.toFixed(2)}`,
+                    });
+                }
+            }
+        }
+        // 4. Check historical change coupling for modified files
+        try {
+            const couplingResult = await (0, change_coupling_1.mineGitHistory)(graph.projectRoot);
+            if (couplingResult.totalCommitsAnalyzed > 0) {
+                const modifiedSet = new Set(specifiedFiles.map((f) => path.relative(graph.projectRoot, f).replace(/\\/g, "/")));
+                for (const f of specifiedFiles) {
+                    if (!graph.files.has(f))
+                        continue;
+                    const gitRelPath = path
+                        .relative(graph.projectRoot, f)
+                        .replace(/\\/g, "/");
+                    const couplings = (0, change_coupling_1.getCoupledFiles)(gitRelPath, couplingResult);
+                    for (const coupling of couplings) {
+                        const otherFile = coupling.file1 === gitRelPath ? coupling.file2 : coupling.file1;
+                        // Skip if the coupled file is already in the modified files list
+                        if (modifiedSet.has(otherFile))
+                            continue;
+                        // Skip if the coupled file is already a known dependency
+                        const otherAbsolute = path.normalize(path.join(graph.projectRoot, otherFile));
+                        const forwardDeps = graph.forward.get(f) || [];
+                        const reverseDeps = graph.reverse.get(f) || [];
+                        const isInGraph = forwardDeps.includes(otherAbsolute) ||
+                            reverseDeps.includes(otherAbsolute);
+                        if (isInGraph)
+                            continue;
+                        // Only flag couplings with confidence >= 0.3
+                        if (coupling.confidence < 0.3)
+                            continue;
+                        const severity = coupling.confidence >= 0.5 ? "MEDIUM" : "LOW";
+                        const pct = Math.round(coupling.confidence * 100);
+                        const rel = path.relative(graph.sourceDir, f).replace(/\\/g, "/");
+                        issues.push({
+                            file: rel,
+                            severity,
+                            description: `Historical coupling: ${otherFile} changes with this file in ${pct}% of commits (${coupling.coChangeCount} times) -- consider reviewing`,
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Non-critical: coupling analysis failure should not block build gate
         }
     }
     // ── Determine verdict ──
@@ -191,6 +341,7 @@ function gateCheck(graph, specifiedFiles) {
         recommendation,
         stats,
         autoAcknowledged,
+        riskScores: riskScores.size > 0 ? riskScores : undefined,
     };
 }
 // ── Formatting ──
@@ -221,9 +372,24 @@ function formatGateResult(result) {
     }
     lines.push("", "### Recommendation", result.recommendation);
     lines.push("", "### Stats", `- Files in graph: ${result.stats.filesInGraph}`, `- Unresolved warnings: ${result.stats.unresolvedWarnings}`);
+    if (result.stats.sccCount !== undefined) {
+        lines.push(`- Strongly Connected Components: ${result.stats.sccCount}`);
+    }
+    if (result.stats.cyclicSCCs !== undefined && result.stats.cyclicSCCs > 0) {
+        lines.push(`- Circular dependency clusters: ${result.stats.cyclicSCCs}`);
+    }
     if (result.autoAcknowledged > 0) {
         lines.push(`- Auto-acknowledged: ${result.autoAcknowledged} warning(s)`);
     }
+    // Show composite risk scores for specified files
+    if (result.riskScores && result.riskScores.size > 0) {
+        lines.push("", "### Risk Scores");
+        for (const [file, score] of result.riskScores) {
+            lines.push(`**${file}:**`);
+            lines.push((0, risk_scorer_1.formatRiskScore)(score));
+            lines.push("");
+        }
+    }
     return lines.join("\n");
 }
 // ── Helpers ──

package/dist/watcher/file-cache.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "events";
+import { DependencyGraph } from "../graph";
 export interface FileChange {
     filePath: string;
     relativePath: string;
@@ -27,9 +28,17 @@ export declare class FileCache extends EventEmitter {
     private watcher;
     private debounceTimers;
     private readonly DEBOUNCE_MS;
+    private graph;
     constructor(projectRoot: string);
     /** Primary source directory (backward compat) */
     get sourceDir(): string;
+    /**
+     * Set the dependency graph reference for incremental updates.
+     * When a graph is set, file changes will trigger incremental
+     * edge updates and memo cache invalidation instead of requiring
+     * a full graph rebuild.
+     */
+    setGraph(graph: DependencyGraph): void;
     /** Load ALL source files into memory on startup */
     initialize(): {
         fileCount: number;