@kage-core/kage-graph-mcp 1.1.25 → 1.1.26

package/README.md

@@ -36,10 +36,18 @@ Restart your agent once after setup so MCP tools reload.
 
 - repo-local memory for decisions, runbooks, bug fixes, gotchas, conventions,
   and code explanations
-- a code graph for files, symbols, imports, calls, routes, tests, and packages
+- a code graph for files, symbols, imports, calls, routes, tests, and packages,
+  including generic call/test signals for non-TypeScript repos
 - memory-code links so project knowledge points at the code it affects
+- decision intelligence for why-memory coverage, stale/weak packets, and
+  important files that still lack linked repo knowledge
+- lightweight workspace recall across sibling repos, including package and
+  route-contract links when existing code graphs expose them
+- local git intelligence for risk, reviewers, contributor profiles, co-change
+  warnings, ownership silos, and module health
 - `AGENTS.md` bootstrap instructions so agents recall context automatically
-- a local viewer for memory, code graph, metrics, evidence, and review state
+- a local viewer for memory, code graph, decision memory, risk, module health,
+  workspace reports, metrics, evidence, and review state
 - review and validation commands for stale or risky memory
 
 No hosted service, external database, or API key is required.
@@ -52,6 +60,16 @@ kage init --project .
 kage recall "how do I run tests" --project .
 kage recall "how do I run tests" --project . --json --explain
 kage code-graph "auth routes tests" --project .
+kage cleanup-candidates --project . --json
+kage dependency-path --project . --from src/app.ts --to src/auth.ts --json
+kage module-health --project . --json
+kage graph-insights --project . --json
+kage workspace --project .. --json
+kage workspace recall "auth header contract" --project .. --json
+kage contributors --project . --json
+kage decisions --project . --json
+kage reviewers --project . --changed-files src/auth.ts,src/session.ts --json
+kage risk --project . --targets src/auth.ts --json
 kage learn --project . --learning "Use npm test after parser changes."
 kage refresh --project .
 kage pr check --project .
@@ -61,6 +79,10 @@ kage inbox --project . --json
 kage viewer --project .
 ```
 
+MCP agents should start with `kage_context`. When the query or target list
+mentions file paths, it includes risk and dependency-path context alongside
+memory recall.
+
 For stale or wrong memory:
 
 ```bash
@@ -99,6 +121,7 @@ Kage keeps learned memory separate from generated code facts.
 | Structural map | `.agent_memory/structural/` | files, symbols, imports |
 | Code graph | `.agent_memory/code_graph/` | source-derived code facts |
 | Metrics | `.agent_memory/metrics.json` | readiness, quality, coverage |
+| Reports | `.agent_memory/reports/` | risk, contributors, decisions, module health, graph insights, workspace, quality, benchmark |
 
 Repo-local packets are git-visible and reviewable. Generated indexes and graphs
 are rebuildable.
@@ -114,6 +137,17 @@ Kage is optimized so repeat work scales with changed files, not the whole repo:
 - huge files are represented safely instead of deeply expanded
 - recall builds lookup maps once per query instead of repeatedly scanning graph
   edges for every memory packet
+- local risk reports include hidden co-change warnings and ownership-silo
+  signals from git history
+- contributor reports show commits, recent activity, touched files/modules,
+  primary ownership, ownership silos, hotspot ownership, and commit category mix
+- decision reports show why-memory coverage, weak/stale decision packets, and
+  high-signal source paths with no linked decision memory
+- graph insights include language parser coverage and edge mix so large-repo
+  index gaps are visible instead of hidden
+- the generic non-TypeScript indexer extracts bounded call edges and test
+  function coverage, while SCIP/LSP/LSIF/tree-sitter artifacts override it when
+  available
 
 ## Viewer
 
@@ -123,6 +157,11 @@ Open a local viewer for the current repo:
 kage viewer --project .
 ```
 
+The local viewer loads graph artifacts plus `.agent_memory/reports/*.json` and
+shows a repo-intelligence cockpit for memory-code links, decision memory, risk,
+contributors, module health, graph insights, workspace coverage, quality, and
+benchmark proof.
+
 Hosted demo:
 
 ```text

package/dist/cli.js

@@ -31,6 +31,12 @@ Usage:
   kage upgrade [--dry-run]
   kage branch --project <dir> [--json]
   kage metrics --project <dir> [--json]
+  kage contributors --project <dir> [--json]
+  kage decisions --project <dir> [--json]
+  kage module-health --project <dir> [--json]
+  kage graph-insights --project <dir> [--json]
+  kage workspace --project <workspace-dir> [--json]
+  kage workspace recall "<query>" --project <workspace-dir> [--json]
   kage audit --project <dir> [--json]
   kage inbox --project <dir> [--json]
   kage quality --project <dir> [--json]
@@ -38,6 +44,10 @@ Usage:
   kage benchmark --project <dir> --compare --task <task> [--json]
   kage code-graph --project <dir> [--json]
   kage code-graph "<query>" --project <dir> [--json]
+  kage cleanup-candidates --project <dir> [--json]
+  kage dependency-path --project <dir> --from <path> --to <path> [--json]
+  kage reviewers --project <dir> [--targets a,b] [--changed-files a,b] [--json]
+  kage risk --project <dir> [--targets a,b] [--changed-files a,b] [--json]
   kage code-index --project <dir> [--json]
   kage structural-index --project <dir> [--json]
   kage graph --project <dir> [--json]
@@ -506,6 +516,123 @@ async function main() {
             console.log(`- ${symbol.kind} ${symbol.name} (${symbol.path}:${symbol.line})`);
         return;
     }
+    if (command === "risk") {
+        const result = (0, kernel_js_1.kageRisk)(projectArg(args), listArg(takeArg(args, "--targets")), listArg(takeArg(args, "--changed-files")));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log("Kage risk assessment");
+        for (const item of Object.values(result.targets)) {
+            console.log(`- ${item.risk_summary}`);
+            if (item.dependents.length)
+                console.log(`  Dependents: ${item.dependents.slice(0, 5).join(", ")}`);
+            if (item.git.co_change_partners.length)
+                console.log(`  Co-change: ${item.git.co_change_partners.map((p) => `${p.file_path} (${p.count})`).join(", ")}`);
+        }
+        if (result.global_hotspots.length) {
+            console.log("Global hotspots:");
+            for (const hotspot of result.global_hotspots)
+                console.log(`- ${hotspot.file_path}: ${hotspot.commit_count_90d} commits in 90d`);
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
+    if (command === "dependency-path") {
+        const from = takeArg(args, "--from");
+        const to = takeArg(args, "--to");
+        if (!from || !to)
+            usage();
+        const result = (0, kernel_js_1.kageDependencyPath)(projectArg(args), from, to);
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(result.summary);
+        if (result.path.length)
+            console.log(`Path: ${result.path.join(" -> ")}`);
+        for (const edge of result.edges) {
+            console.log(`- ${edge.from_path}:${edge.line} ${edge.kind} ${edge.specifier} -> ${edge.to_path}`);
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
+    if (command === "cleanup-candidates") {
+        const result = (0, kernel_js_1.kageCleanupCandidates)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage cleanup candidates: ${result.summary}`);
+        for (const candidate of result.candidates.slice(0, 20)) {
+            console.log(`- ${candidate.path}: ${candidate.confidence} (${Math.round(candidate.score * 100)}%)`);
+            console.log(`  ${candidate.reasons.join("; ")}`);
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
+    if (command === "reviewers") {
+        const result = (0, kernel_js_1.kageReviewerSuggestions)(projectArg(args), listArg(takeArg(args, "--targets")), listArg(takeArg(args, "--changed-files")));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage reviewer suggestions: ${result.summary}`);
+        for (const suggestion of result.suggestions) {
+            console.log(`- ${suggestion.reviewer}: ${Math.round(suggestion.score)}%`);
+            console.log(`  ${suggestion.reasons.slice(0, 3).join("; ")}`);
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
+    if (command === "contributors") {
+        const result = (0, kernel_js_1.kageContributors)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage contributors: ${result.summary}`);
+        for (const profile of result.contributors.slice(0, 10)) {
+            console.log(`- ${profile.contributor}: ${profile.commits_total} commits, ${profile.commits_90d} in 90d, ${profile.primary_owned_files} owned files`);
+            if (profile.files_touched.length)
+                console.log(`  Top files: ${profile.files_touched.slice(0, 3).map((file) => `${file.path} (${file.commits})`).join(", ")}`);
+            if (profile.silo_files.length)
+                console.log(`  Silo files: ${profile.silo_files.slice(0, 3).map((file) => `${file.path} (${Math.round(file.ownership_pct * 100)}%)`).join(", ")}`);
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
+    if (command === "decisions") {
+        const result = (0, kernel_js_1.kageDecisionIntelligence)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage decision intelligence: ${result.summary}`);
+        if (result.top_decisions.length) {
+            console.log("Top why-memory:");
+            for (const item of result.top_decisions.slice(0, 10)) {
+                console.log(`- ${item.title} (${item.type})`);
+                if (item.paths.length)
+                    console.log(`  Paths: ${item.paths.slice(0, 3).join(", ")}`);
+                if (item.why)
+                    console.log(`  Why: ${item.why}`);
+            }
+        }
+        if (result.coverage_gaps.length) {
+            console.log("Uncovered important paths:");
+            for (const gap of result.coverage_gaps.slice(0, 10))
+                console.log(`- ${gap.path}: ${gap.reason}`);
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
     if (command === "code-index") {
         const result = (0, kernel_js_1.writeCodeIndex)(projectArg(args));
         if (args.includes("--json")) {
@@ -616,6 +743,82 @@ async function main() {
         }
         return;
     }
+    if (command === "module-health") {
+        const result = (0, kernel_js_1.kageModuleHealth)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage module health: ${result.summary}`);
+        for (const item of result.modules.slice(0, 20)) {
+            console.log(`- ${item.module}: ${item.grade} (${item.score}) - ${item.reasons.join("; ")}`);
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
+    if (command === "graph-insights") {
+        const result = (0, kernel_js_1.kageGraphInsights)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage graph insights: ${result.summary}`);
+        if (result.central_files.length) {
+            console.log("Central files:");
+            for (const file of result.central_files.slice(0, 10))
+                console.log(`- ${file.path}: pagerank ${file.pagerank}, ${file.dependents} dependent(s)`);
+        }
+        if (result.dependency_cycles.length) {
+            console.log("Dependency cycles:");
+            for (const cycle of result.dependency_cycles.slice(0, 5))
+                console.log(`- ${cycle.files.join(" -> ")}`);
+        }
+        if (result.entry_flows.length) {
+            console.log("Entry flows:");
+            for (const flow of result.entry_flows.slice(0, 5))
+                console.log(`- ${flow.path.join(" -> ")}`);
+        }
+        return;
+    }
+    if (command === "workspace") {
+        const subcommand = args[1];
+        if (subcommand === "recall") {
+            const query = args.find((arg, index) => index > 1 && !arg.startsWith("--") && !args[index - 1]?.startsWith("--"));
+            if (!query)
+                usage();
+            const result = (0, kernel_js_1.kageWorkspaceRecall)(projectArg(args), query, numberArg(args, "--limit", 8));
+            if (args.includes("--json")) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log(result.context_block);
+            if (result.warnings.length)
+                console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+            return;
+        }
+        const result = (0, kernel_js_1.kageWorkspace)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage workspace: ${result.summary}`);
+        for (const repo of result.repos) {
+            const deps = repo.dependencies_on_workspace_repos.length
+                ? ` depends on ${repo.dependencies_on_workspace_repos.map((dep) => dep.alias).join(", ")}`
+                : "";
+            console.log(`- ${repo.alias}: ${repo.path} (${repo.approved_packets} packets, ${repo.code_files} files)${deps}`);
+        }
+        if (result.route_contracts.length) {
+            console.log("Route contracts:");
+            for (const contract of result.route_contracts.slice(0, 10)) {
+                console.log(`- ${contract.provider_repo} ${contract.method} ${contract.path} -> ${contract.consumer_repo}/${contract.consumer_file}`);
+            }
+        }
+        if (result.warnings.length)
+            console.log(`Warnings:\n${result.warnings.map((warning) => `  - ${warning}`).join("\n")}`);
+        return;
+    }
     if (command === "audit") {
         const result = (0, kernel_js_1.auditProject)(projectArg(args));
         if (args.includes("--json")) {

package/dist/daemon.js

@@ -240,17 +240,35 @@ async function startViewer(projectDir, options = {}) {
     const inboxPath = (0, node_path_1.join)(projectRoot, ".agent_memory", "inbox.json");
     const reviewPath = (0, node_path_1.join)(projectRoot, ".agent_memory", "review", "memory-review.md");
     const pendingDir = (0, node_path_1.join)(projectRoot, ".agent_memory", "pending");
+    const reportsDir = (0, node_path_1.join)(projectRoot, ".agent_memory", "reports");
+    const qualityPath = (0, node_path_1.join)(reportsDir, "quality.json");
+    const benchmarkPath = (0, node_path_1.join)(reportsDir, "benchmark.json");
+    const contributorsPath = (0, node_path_1.join)(reportsDir, "contributors.json");
+    const decisionsPath = (0, node_path_1.join)(reportsDir, "decisions.json");
+    const riskPath = (0, node_path_1.join)(reportsDir, "risk.json");
+    const moduleHealthPath = (0, node_path_1.join)(reportsDir, "module-health.json");
+    const graphInsightsPath = (0, node_path_1.join)(reportsDir, "graph-insights.json");
+    const workspacePath = (0, node_path_1.join)(reportsDir, "workspace.json");
     // Pre-generate lightweight JSON reports so the viewer can load them directly.
     try {
+        (0, node_fs_1.mkdirSync)(reportsDir, { recursive: true });
         const metrics = (0, kernel_js_1.kageMetrics)(projectDir);
         (0, node_fs_1.writeFileSync)(metricsPath, JSON.stringify(metrics, null, 2));
         const inbox = (0, kernel_js_1.memoryInbox)(projectDir);
         (0, node_fs_1.writeFileSync)(inboxPath, JSON.stringify(inbox, null, 2));
+        (0, node_fs_1.writeFileSync)(qualityPath, JSON.stringify((0, kernel_js_1.qualityReport)(projectDir), null, 2));
+        (0, node_fs_1.writeFileSync)(benchmarkPath, JSON.stringify((0, kernel_js_1.benchmarkProject)(projectDir), null, 2));
+        (0, node_fs_1.writeFileSync)(contributorsPath, JSON.stringify((0, kernel_js_1.kageContributors)(projectDir), null, 2));
+        (0, node_fs_1.writeFileSync)(decisionsPath, JSON.stringify((0, kernel_js_1.kageDecisionIntelligence)(projectDir), null, 2));
+        (0, node_fs_1.writeFileSync)(riskPath, JSON.stringify((0, kernel_js_1.kageRisk)(projectDir), null, 2));
+        (0, node_fs_1.writeFileSync)(moduleHealthPath, JSON.stringify((0, kernel_js_1.kageModuleHealth)(projectDir), null, 2));
+        (0, node_fs_1.writeFileSync)(graphInsightsPath, JSON.stringify((0, kernel_js_1.kageGraphInsights)(projectDir), null, 2));
+        (0, node_fs_1.writeFileSync)(workspacePath, JSON.stringify((0, kernel_js_1.kageWorkspace)(projectDir), null, 2));
     }
     catch {
         // non-fatal: viewer will show 404 for reports if generation fails
     }
-    const url = `http://${host}:${port}/viewer/index.html?graph=${encodeURIComponent(graphPath)}&code=${encodeURIComponent(codePath)}&metrics=${encodeURIComponent(metricsPath)}&inbox=${encodeURIComponent(inboxPath)}&review=${encodeURIComponent(reviewPath)}&pending=${encodeURIComponent(pendingDir)}&view=code`;
+    const url = `http://${host}:${port}/viewer/index.html?graph=${encodeURIComponent(graphPath)}&code=${encodeURIComponent(codePath)}&metrics=${encodeURIComponent(metricsPath)}&inbox=${encodeURIComponent(inboxPath)}&review=${encodeURIComponent(reviewPath)}&pending=${encodeURIComponent(pendingDir)}&quality=${encodeURIComponent(qualityPath)}&benchmark=${encodeURIComponent(benchmarkPath)}&contributors=${encodeURIComponent(contributorsPath)}&decisions=${encodeURIComponent(decisionsPath)}&risk=${encodeURIComponent(riskPath)}&moduleHealth=${encodeURIComponent(moduleHealthPath)}&graphInsights=${encodeURIComponent(graphInsightsPath)}&workspace=${encodeURIComponent(workspacePath)}&view=code`;
     const server = (0, node_http_1.createServer)((req, res) => {
         const requestUrl = new URL(req.url ?? "/", `http://${host}:${port}`);
         let filePath = null;

package/dist/index.js

@@ -55,6 +55,25 @@ function arrayArg(value) {
         return value.split(",").map((item) => item.trim()).filter(Boolean);
     return [];
 }
+function filePathHints(query) {
+    const matches = query.match(/[A-Za-z0-9_./@-]+\.(?:ts|tsx|js|jsx|mjs|cjs|py|go|rs|java|kt|kts|rb|php|cs|c|h|cc|cpp|hpp|swift|json|md)\b/g) ?? [];
+    return [...new Set(matches.map((match) => match.replace(/^\.\//, "")).filter((match) => !/^https?:\/\//.test(match)))];
+}
+function wantsDependencyPath(query) {
+    return /\b(connect|connected|dependency|depend|depends|path|impact|flow|trace)\b/i.test(query);
+}
+function riskContextBlock(result) {
+    const targets = Object.values(result.targets);
+    if (!targets.length)
+        return "";
+    const lines = targets.slice(0, 5).map((item) => {
+        const coChange = item.git.co_change_partners.length
+            ? ` Co-change: ${item.git.co_change_partners.slice(0, 3).map((partner) => `${partner.file_path} (${partner.count})`).join(", ")}.`
+            : "";
+        return `- ${item.risk_summary}${coChange}`;
+    });
+    return `\n## Risk Signals\n${lines.join("\n")}`;
+}
 const server = new index_js_1.Server({ name: "kage-graph", version: "1.1.7" }, { capabilities: { tools: {} } });
 function listTools() {
     return [
@@ -70,6 +89,8 @@ function listTools() {
                     project_dir: { type: "string", description: "Absolute path to the project root" },
                     query: { type: "string", description: "The task or question — used for both memory recall and code graph search" },
                     limit: { type: "number", description: "Max memory packets to return (default 5)" },
+                    targets: { type: "array", items: { type: "string" }, description: "Optional files the agent may edit or explain; used for risk context" },
+                    changed_files: { type: "array", items: { type: "string" }, description: "Optional changed files for pre-edit or PR risk context" },
                 },
                 required: ["project_dir", "query"],
             },
@@ -172,6 +193,78 @@ function listTools() {
                 required: ["project_dir"],
             },
         },
+        {
+            name: "kage_risk",
+            description: "Assess modification risk for files using Kage's code graph plus local git history: dependents, impact surface, churn, ownership, co-change partners, and test gaps. Use before editing hotspot or shared files.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    targets: { type: "array", items: { type: "string" }, description: "File paths to assess" },
+                    changed_files: { type: "array", items: { type: "string" }, description: "Optional PR/branch changed files. If targets is omitted, these are assessed." },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_dependency_path",
+            description: "Find how two files are connected in Kage's source-derived code graph. Reports direct dependency direction, reverse impact direction, or undirected graph connection.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    from: { type: "string", description: "Source file path or unique suffix" },
+                    to: { type: "string", description: "Target file path or unique suffix" },
+                },
+                required: ["project_dir", "from", "to"],
+            },
+        },
+        {
+            name: "kage_cleanup_candidates",
+            description: "Find conservative cleanup candidates from Kage's code graph. Reports unreferenced source files with confidence and reasons; never auto-deletes.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_reviewers",
+            description: "Suggest reviewers for target or changed files from local git authorship, recent edits, and code-graph co-change ownership. Does not contact GitHub or external services.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                    targets: { type: "array", items: { type: "string" }, description: "File paths to review" },
+                    changed_files: { type: "array", items: { type: "string" }, description: "Optional PR/branch changed files. If targets is omitted, these are used." },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_contributors",
+            description: "Build local contributor profiles from git history: commits, recent activity, touched files, modules, ownership silos, hotspot ownership, and commit category mix.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_decisions",
+            description: "Summarize Kage why-memory for a repo: decisions, gotchas, runbooks, conventions, code explanations, path coverage, weak/stale memory, and important code paths that still lack decision memory.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
         {
             name: "kage_code_index",
             description: "Write external code index artifacts consumed by the code graph. Prefers SCIP when scip-typescript and scip are installed, then falls back to the built-in LSP-compatible symbol index.",
@@ -205,6 +298,52 @@ function listTools() {
                 required: ["project_dir"],
             },
         },
+        {
+            name: "kage_module_health",
+            description: "Return local module health scorecards from Kage's code graph, test signals, cleanup candidates, git churn, and ownership concentration.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_graph_insights",
+            description: "Return deterministic code graph intelligence: central files, dependency cycles, import communities, and short entry flows. Use to orient agents before broad architectural edits.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string", description: "Absolute path to the project root" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_workspace",
+            description: "Summarize a local multi-repo workspace: discovered git repos, Kage memory coverage, code graph counts, and package dependencies between repos. Use when a task spans multiple sibling repos.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string", description: "Workspace root directory to scan for git repos" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_workspace_recall",
+            description: "Recall Kage memory across every indexed repo in a local workspace and rank the combined hits. Use for cross-repo teammate knowledge and shared context.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string", description: "Workspace root directory to scan for git repos" },
+                    query: { type: "string", description: "Question or task to recall across repos" },
+                    limit: { type: "number", description: "Max combined hits to return (default 8)" },
+                },
+                required: ["project_dir", "query"],
+            },
+        },
         {
             name: "kage_audit",
             description: "Audit whether repo memory and code intelligence are trustworthy: validation, memory inbox, structured context coverage, code graph precision, graph links, and concrete recommendations.",
@@ -694,9 +833,18 @@ async function callTool(name, args) {
         const recallResult = (0, kernel_js_1.recall)(projectDir, query, limit, false);
         // graph facts on top of recall
         const graphResult = (0, kernel_js_1.queryGraph)(projectDir, query, 5);
+        const explicitTargets = [...arrayArg(args?.targets), ...filePathHints(query)];
+        const changedFiles = arrayArg(args?.changed_files);
+        const riskResult = explicitTargets.length || changedFiles.length ? (0, kernel_js_1.kageRisk)(projectDir, explicitTargets, changedFiles) : null;
+        const pathHints = filePathHints(query);
+        const dependencyResult = wantsDependencyPath(query) && pathHints.length >= 2
+            ? (0, kernel_js_1.kageDependencyPath)(projectDir, pathHints[0], pathHints[1])
+            : null;
         const sections = [
             recallResult.context_block,
             graphResult.context_block ? `\n## Graph Facts\n${graphResult.context_block}` : "",
+            riskResult ? riskContextBlock(riskResult) : "",
+            dependencyResult ? `\n## Dependency Path\n${dependencyResult.summary}${dependencyResult.path.length ? `\nPath: ${dependencyResult.path.join(" -> ")}` : ""}` : "",
             `\n_${validationText}_`,
         ].filter(Boolean).join("");
         return {
@@ -736,6 +884,42 @@ async function callTool(name, args) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
     }
+    if (name === "kage_risk") {
+        const result = (0, kernel_js_1.kageRisk)(String(args?.project_dir ?? ""), arrayArg(args?.targets), arrayArg(args?.changed_files));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_dependency_path") {
+        const result = (0, kernel_js_1.kageDependencyPath)(String(args?.project_dir ?? ""), String(args?.from ?? ""), String(args?.to ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_cleanup_candidates") {
+        const result = (0, kernel_js_1.kageCleanupCandidates)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_reviewers") {
+        const result = (0, kernel_js_1.kageReviewerSuggestions)(String(args?.project_dir ?? ""), arrayArg(args?.targets), arrayArg(args?.changed_files));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_contributors") {
+        const result = (0, kernel_js_1.kageContributors)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_decisions") {
+        const result = (0, kernel_js_1.kageDecisionIntelligence)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
     if (name === "kage_code_index") {
         const result = (0, kernel_js_1.writeCodeIndex)(String(args?.project_dir ?? ""));
         return {
@@ -755,6 +939,30 @@ async function callTool(name, args) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
     }
+    if (name === "kage_module_health") {
+        const result = (0, kernel_js_1.kageModuleHealth)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_graph_insights") {
+        const result = (0, kernel_js_1.kageGraphInsights)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_workspace") {
+        const result = (0, kernel_js_1.kageWorkspace)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    if (name === "kage_workspace_recall") {
+        const result = (0, kernel_js_1.kageWorkspaceRecall)(String(args?.project_dir ?? ""), String(args?.query ?? ""), Number(args?.limit ?? 8));
+        return {
+            content: [{ type: "text", text: args?.json ? JSON.stringify(result, null, 2) : result.context_block }],
+        };
+    }
     if (name === "kage_audit") {
         const result = (0, kernel_js_1.auditProject)(String(args?.project_dir ?? ""));
         return {