@kage-core/kage-graph-mcp 1.1.13 → 1.1.15

package/README.md

@@ -9,6 +9,31 @@ This package exposes two surfaces:
 
 ## Latest Release
 
+`1.1.15` hardens the npm release path and memory-only review flow:
+
+- `npm run release:npm:dry-run` runs the guarded release checks without
+  publishing.
+- `npm run release:npm` builds the release helper, requires a clean worktree,
+  fetches the remote branch, verifies local `HEAD` contains `origin/<branch>`,
+  runs tests and `npm pack --dry-run`, pushes the branch before publishing,
+  publishes with `--access public`, verifies npm registry metadata, and performs
+  a smoke install.
+- all git steps run with `GIT_EDITOR=true` so agent sessions cannot get stuck in
+  an interactive commit or rebase editor.
+- `kage propose --from-diff` now includes repo memory packet-only changes from
+  `.agent_memory/packets/*.json` and `.agent_memory/pending/*.json`.
+
+`1.1.14` publishes the memory/code graph trust and retrieval pass:
+
+- recall now uses vectorless BM25 lexical ranking with graph, path/type/tag,
+  intent, freshness, quality, and feedback boosts.
+- `kage audit`, `kage inbox`, `kage code-index`, and `kage graph-registry`
+  are documented as first-class CLI and MCP surfaces.
+- the viewer coalesces memory graph code entities with code graph nodes and
+  highlights memory-code links.
+- README and the website now report the current 79-test proof state and BM25
+  retrieval behavior.
+
 `1.1.13` switches future Kage releases to GPL-3.0-only:
 
 - package metadata now advertises `GPL-3.0-only`.
@@ -21,16 +46,28 @@ This package exposes two surfaces:
 - npm README now includes this explicit release note.
 - Root README leads with the animated Kage demo GIF.
 - README links clearly to the website and live viewer.
-- Hosted viewer publishes Kage repo graph, code graph, and metrics from GitHub
-  Pages while local repos still use `kage viewer --project .`.
+- Hosted viewer publishes Kage repo graph, code graph, metrics, and inbox from
+  GitHub Pages while local repos still use `kage viewer --project .`.
 
 ## Build
 
 ```bash
 npm install
 npm run build
+npm run release:npm:dry-run
+```
+
+Publishing from the repo should use the guarded release script after the release
+commit is ready:
+
+```bash
+npm run release:npm
 ```
 
+The script fetches the current branch and blocks if the remote branch is not an
+ancestor of local `HEAD`, which prevents publishing an npm version from a branch
+that cannot be pushed cleanly.
+
 ## CLI
 
 ```bash
@@ -46,14 +83,18 @@ kage doctor --project /path/to/repo
 kage index --project /path/to/repo
 kage refresh --project /path/to/repo
 kage branch --project /path/to/repo
+kage code-index --project /path/to/repo
 kage code-graph --project /path/to/repo
 kage code-graph "createApp routes tests" --project /path/to/repo
 kage graph --project /path/to/repo
 kage graph --project /path/to/repo --mermaid
 kage graph "test command" --project /path/to/repo
+kage graph-registry --project /path/to/repo
 kage recall "how do I run tests" --project /path/to/repo
 kage recall "how do I run tests" --project /path/to/repo --explain --json
 kage quality --project /path/to/repo
+kage audit --project /path/to/repo
+kage inbox --project /path/to/repo
 kage benchmark --project /path/to/repo
 kage benchmark --project /path/to/repo --compare --task "how do I run tests"
 kage viewer --project /path/to/repo
@@ -131,6 +172,12 @@ generic extraction in metrics and file parser coverage. This keeps installation
 light while allowing teams to plug in the strongest indexer available for their
 language stack.
 
+`kage code-index --project <repo>` writes `.agent_memory/code_index/lsp-symbols.json`
+in an LSP document-symbol-compatible shape using Kage's local parser. The CI,
+PR, and sync workflows run it before refresh so the code graph has a committed
+precise-index slot while teams can still replace or augment it with SCIP/LSIF
+artifacts from their preferred toolchain.
+
 The memory graph follows the same product direction as temporal context graph
 systems such as Graphiti: immutable ingestion episodes, derived entities and
 facts, evidence/provenance on every edge, confidence, branch/commit context, and
@@ -143,12 +190,36 @@ and parser coverage, code graph counts, evidence coverage, approved vs pending
 memory, validation status, estimated tokens saved per recall, duplicate
 candidates, average memory quality, and a readiness score.
 
+Use `kage audit --project <repo>` or the `kage_audit` MCP tool before relying
+on repo memory for agent work. Audit reports validation, pending memory inbox
+size, structured context coverage, stale/duplicate risk, memory-to-code graph
+links, precise code index coverage, and concrete recommendations such as
+extending SCIP/LSIF/LSP coverage or adding structured
+`why`/`verification`/`risk_if_forgotten` fields to high-value packets.
+
+Use `kage inbox --project <repo>` or the `kage_inbox` MCP tool for the
+actionable review queue. It consolidates pending packets, stale packets,
+duplicates, missing structured context, validation warnings/errors, and concrete
+actions into one report that the viewer also loads.
+
 Use `kage benchmark --compare --task "<task>" --project <repo>` or
 `kage_benchmark_compare` to compare the same task on the same repo with and
 without Kage. It estimates manual full-file rediscovery tokens/steps, compares
 them to compact Kage recall plus code graph context, and returns evidence plus
 caveats for honest marketing proof.
 
+Plain `kage benchmark --project <repo>` now includes explicit gates and an
+overall score for recall hit rate, evidence coverage, useful memory ratio, and
+code-flow coverage, so benchmark output has pass/fail criteria instead of loose
+claims.
+
+Use `kage graph-registry --project <repo>` or `kage_graph_registry` to write
+`.agent_memory/graph_registry/manifest.json`. The manifest is signed with the
+same canonical JSON scheme as registry bundles and records memory/code graph
+artifact hashes, generated index/report paths, source packet IDs and packet
+hashes, git state, audit trust, inbox counts, and metrics readiness. CI, PR, and
+sync workflows build it after refresh.
+
 Use `kage refresh --project <repo>` or the `kage_refresh` MCP tool after
 meaningful file changes. Refresh rebuilds indexes, code graph, memory graph,
 metrics, and stale-memory metadata. Memory is marked stale when status or
@@ -172,13 +243,15 @@ review.
 clients. It accepts session, prompt, tool, file-change, command, test, and
 session-end events; deduplicates them; scans for secrets and PII; and stores raw
 observations locally only. `kage distill` turns useful observations into
-repo-local packets with observation session source refs. It never publishes
-memory.
+repo-local packets with observation session source refs. Distillation is not
+limited to action-changing instructions: durable rationale, bug causes, issue
+state, decisions, and code explanations are valid memory when source-backed. It
+never publishes memory.
 
 `kage recall --explain --json` exposes the hybrid scoring explanation used for
-ranking: text, graph, path/type/tag, freshness, quality, feedback, and a vector
-placeholder for future local or external embedding providers. Current fallback
-is deterministic text plus graph retrieval.
+ranking: BM25 lexical score, graph, path/type/tag, intent, freshness, quality,
+feedback, and a vector placeholder for future local or external embedding providers.
+Current fallback is vectorless BM25 plus graph retrieval.
 
 `kage_context` is the primary MCP entrypoint for agents. It validates repo
 memory, recalls relevant packets, and returns code/knowledge graph context in
@@ -192,6 +265,7 @@ one call. Agents should use it at task start instead of loading separate
 - `GET /kage/status`
 - `GET /kage/metrics`
 - `GET /kage/quality`
+- `GET /kage/inbox`
 - `GET /kage/benchmark`
 - `POST /kage/recall`
 - `POST /kage/observe`
@@ -207,13 +281,13 @@ and refreshes generated graph/index artifacts after a short debounce.
 Run `kage viewer --project <repo>` to start the local terminal console. It
 serves the viewer and the selected repo's `.agent_memory/` files from the same
 localhost server, then prints a URL that auto-loads memory graph, code graph,
-metrics, review artifact, and pending packets when present. Manual JSON selection remains as
-a fallback, not the main workflow.
+metrics, memory inbox, review artifact, and pending packets when present.
+Manual JSON selection remains as a fallback, not the main workflow.
 
 The viewer renders nodes and relations in SVG, supports memory/code/combined
 modes, filters by type and relation, displays metrics, shows packets and pending
-quarantine items when present, and marks risks such as low-confidence or
-missing-evidence edges.
+quarantine items when present, surfaces the memory inbox, and marks risks such
+as low-confidence or missing-evidence edges.
 
 For demos or local docs, the viewer also accepts URL params:
 
@@ -232,8 +306,12 @@ Local repo tools:
 
 - `kage_context`
 - `kage_recall`
+- `kage_graph_registry`
 - `kage_code_graph`
+- `kage_code_index`
 - `kage_metrics`
+- `kage_audit`
+- `kage_inbox`
 - `kage_refresh`
 - `kage_pr_summarize`
 - `kage_pr_check`

package/dist/cli.js

@@ -6,6 +6,7 @@ const promises_1 = require("node:readline/promises");
 const node_process_1 = require("node:process");
 const daemon_js_1 = require("./daemon.js");
 const kernel_js_1 = require("./kernel.js");
+const graph_registry_js_1 = require("./graph-registry.js");
 function usage() {
     console.log(`Kage repo memory and code graph
 
@@ -30,14 +31,18 @@ Usage:
   kage upgrade [--dry-run]
   kage branch --project <dir> [--json]
   kage metrics --project <dir> [--json]
+  kage audit --project <dir> [--json]
+  kage inbox --project <dir> [--json]
   kage quality --project <dir> [--json]
   kage benchmark --project <dir> [--json]
   kage benchmark --project <dir> --compare --task <task> [--json]
   kage code-graph --project <dir> [--json]
   kage code-graph "<query>" --project <dir> [--json]
+  kage code-index --project <dir> [--json]
   kage graph --project <dir> [--json]
   kage graph --project <dir> --mermaid
   kage graph "<query>" --project <dir> [--json]
+  kage graph-registry --project <dir> [--json]
   kage recall "<query>" --project <dir> [--json] [--explain]
   kage observe --project <dir> --event <json>
   kage distill --project <dir> --session <id>
@@ -452,6 +457,25 @@ async function main() {
             console.log(`- ${edge.fact}`);
         return;
     }
+    if (command === "graph-registry") {
+        const result = (0, graph_registry_js_1.buildGraphRegistryManifest)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Graph Registry: ${result.project_dir}`);
+        console.log(`Manifest: ${result.path}`);
+        console.log(`Artifacts: ${result.artifacts.length}`);
+        console.log(`Packets: ${result.manifest.payload.sources.packet_count}`);
+        console.log(`Signature: ${result.manifest.signature.payload_sha256}`);
+        if (result.errors.length) {
+            console.log("\nErrors:");
+            for (const error of result.errors)
+                console.log(`  - ${error}`);
+            process.exitCode = 2;
+        }
+        return;
+    }
     if (command === "code-graph") {
         const query = firstPositional(args);
         if (query) {
@@ -481,6 +505,25 @@ async function main() {
             console.log(`- ${symbol.kind} ${symbol.name} (${symbol.path}:${symbol.line})`);
         return;
     }
+    if (command === "code-index") {
+        const result = (0, kernel_js_1.writeLspSymbolIndex)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Code Index: ${result.project_dir}`);
+        console.log(`Parser: ${result.parser}`);
+        console.log(`Path: ${result.path}`);
+        console.log(`Documents: ${result.documents}`);
+        console.log(`Symbols: ${result.symbols}`);
+        if (result.errors.length) {
+            console.log("\nErrors:");
+            for (const error of result.errors)
+                console.log(`  - ${error}`);
+            process.exitCode = 2;
+        }
+        return;
+    }
     if (command === "branch") {
         const result = (0, kernel_js_1.buildBranchOverlay)(projectArg(args));
         if (args.includes("--json"))
@@ -544,6 +587,59 @@ async function main() {
         }
         return;
     }
+    if (command === "audit") {
+        const result = (0, kernel_js_1.auditProject)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Audit: ${result.project_dir}`);
+        console.log(`Trust score: ${result.trust_score}/100`);
+        console.log(`Validation: ${result.checks.validation.ok ? "passed" : "failed"}`);
+        console.log(`Memory inbox: ${result.checks.memory_inbox.approved_packets} approved, ${result.checks.memory_inbox.pending_packets} pending, ${result.checks.memory_inbox.stale_packets} stale`);
+        console.log(`Structured memory: ${result.checks.structured_memory.structured_packets}/${result.checks.structured_memory.total_packets} (${result.checks.structured_memory.coverage_percent}%)`);
+        console.log(`Code graph precision: ${result.checks.code_graph.precise_files}/${result.checks.code_graph.files} precise (${result.checks.code_graph.precise_coverage_percent}%), ${result.checks.code_graph.ast_files} AST, ${result.checks.code_graph.fallback_files} fallback`);
+        console.log(`Memory-code graph edges: ${result.checks.graph_links.memory_code_edges}`);
+        if (result.recommendations.length) {
+            console.log("\nRecommendations:");
+            for (const recommendation of result.recommendations)
+                console.log(`  - ${recommendation}`);
+        }
+        if (!result.ok)
+            process.exitCode = 2;
+        return;
+    }
+    if (command === "inbox") {
+        const result = (0, kernel_js_1.memoryInbox)(projectArg(args));
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`Kage Memory Inbox: ${result.project_dir}`);
+        console.log(`Approved: ${result.counts.approved}`);
+        console.log(`Pending: ${result.counts.pending}`);
+        console.log(`Stale: ${result.counts.stale}`);
+        console.log(`Duplicates: ${result.counts.duplicates}`);
+        console.log(`Missing structured context: ${result.counts.missing_context}`);
+        console.log(`Validation: ${result.counts.validation_errors} errors, ${result.counts.validation_warnings} warnings`);
+        if (result.items.length) {
+            console.log("\nInbox items:");
+            for (const item of result.items.slice(0, 30)) {
+                console.log(`  - [${item.severity}] ${item.kind}: ${item.title ?? item.summary}`);
+                console.log(`    Action: ${item.action}`);
+            }
+            if (result.items.length > 30)
+                console.log(`  ... ${result.items.length - 30} more item(s)`);
+        }
+        if (result.recommendations.length) {
+            console.log("\nRecommendations:");
+            for (const recommendation of result.recommendations)
+                console.log(`  - ${recommendation}`);
+        }
+        if (!result.ok)
+            process.exitCode = 2;
+        return;
+    }
     if (command === "quality") {
         const result = (0, kernel_js_1.qualityReport)(projectArg(args));
         if (args.includes("--json")) {
@@ -607,6 +703,12 @@ async function main() {
             return;
         }
         console.log(`Kage Benchmark: ${result.project_dir}`);
+        console.log(`OK: ${result.ok ? "yes" : "no"}`);
+        console.log(`Overall score: ${result.overall_score}/100`);
+        console.log("Gates:");
+        for (const gate of result.gates)
+            console.log(`  - ${gate.name}: ${gate.actual}${gate.unit === "percent" ? "%" : ""} / target ${gate.target}${gate.unit === "percent" ? "%" : ""} (${gate.pass ? "pass" : "fail"})`);
+        console.log("Pain metrics:");
         for (const [name, value] of Object.entries(result.pain_metrics))
             console.log(`${name}: ${value}`);
         return;

package/dist/daemon.js

@@ -98,6 +98,7 @@ function daemonDoctor(projectDir) {
             `POST http://${DEFAULT_HOST}:${restPort}/kage/distill`,
             `GET http://${DEFAULT_HOST}:${restPort}/kage/metrics`,
             `GET http://${DEFAULT_HOST}:${restPort}/kage/quality`,
+            `GET http://${DEFAULT_HOST}:${restPort}/kage/inbox`,
             `GET http://${DEFAULT_HOST}:${restPort}/kage/benchmark`,
         ],
         warnings,
@@ -186,6 +187,10 @@ async function startDaemon(projectDir, options = {}) {
                 json(res, 200, (0, kernel_js_1.qualityReport)(projectDir));
                 return;
             }
+            if (req.method === "GET" && url.pathname === "/kage/inbox") {
+                json(res, 200, (0, kernel_js_1.memoryInbox)(projectDir));
+                return;
+            }
             if (req.method === "GET" && url.pathname === "/kage/benchmark") {
                 json(res, 200, (0, kernel_js_1.benchmarkProject)(projectDir));
                 return;
@@ -231,17 +236,20 @@ async function startViewer(projectDir, options = {}) {
     const graphPath = (0, node_path_1.join)(projectRoot, ".agent_memory", "graph", "graph.json");
     const codePath = (0, node_path_1.join)(projectRoot, ".agent_memory", "code_graph", "graph.json");
     const metricsPath = (0, node_path_1.join)(projectRoot, ".agent_memory", "metrics.json");
+    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");
-    // Pre-generate metrics.json so the viewer can load it
+    // Pre-generate lightweight JSON reports so the viewer can load them directly.
     try {
         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));
     }
     catch {
-        // non-fatal: viewer will show 404 for metrics if generation fails
+        // 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)}&review=${encodeURIComponent(reviewPath)}&pending=${encodeURIComponent(pendingDir)}`;
+    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)}`;
     const server = (0, node_http_1.createServer)((req, res) => {
         const requestUrl = new URL(req.url ?? "/", `http://${host}:${port}`);
         let filePath = null;

package/dist/graph-registry.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGraphRegistryManifest = buildGraphRegistryManifest;
+const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const index_js_1 = require("./registry/index.js");
+const kernel_js_1 = require("./kernel.js");
+function nowIso() {
+    return new Date().toISOString();
+}
+function ensureDir(path) {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        (0, node_fs_1.mkdirSync)(path, { recursive: true });
+    }
+}
+function writeJson(path, value) {
+    const dir = (0, node_path_1.dirname)(path);
+    if (!(0, node_fs_1.existsSync)(dir)) {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    (0, node_fs_1.writeFileSync)(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+function readGit(projectDir, args) {
+    try {
+        return (0, node_child_process_1.execFileSync)("git", args, { cwd: projectDir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+function gitBranch(projectDir) {
+    return readGit(projectDir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+}
+function gitHead(projectDir) {
+    return readGit(projectDir, ["rev-parse", "HEAD"]);
+}
+function gitMergeBase(projectDir) {
+    return readGit(projectDir, ["merge-base", "HEAD", "origin/HEAD"]) ?? gitHead(projectDir);
+}
+function repoKey(projectDir) {
+    return (readGit(projectDir, ["config", "--get", "remote.origin.url"]) ?? projectDir)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 120) || "local-repo";
+}
+function canonicalPacketText(packet) {
+    return JSON.stringify({
+        title: packet.title,
+        summary: packet.summary,
+        body: packet.body,
+        type: packet.type,
+        tags: packet.tags,
+        paths: packet.paths,
+    });
+}
+function graphRegistryArtifact(projectDir, path, name, kind) {
+    const absolute = (0, node_path_1.join)(projectDir, path);
+    if (!(0, node_fs_1.existsSync)(absolute))
+        return null;
+    const bytes = (0, node_fs_1.readFileSync)(absolute);
+    let schemaVersion = null;
+    try {
+        const parsed = JSON.parse(bytes.toString("utf8"));
+        schemaVersion = typeof parsed.schema_version === "number" ? parsed.schema_version : null;
+    }
+    catch {
+        schemaVersion = null;
+    }
+    return {
+        name,
+        kind,
+        path,
+        schema_version: schemaVersion,
+        sha256: (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex"),
+        bytes: (0, node_fs_1.statSync)(absolute).size,
+    };
+}
+function buildGraphRegistryManifest(projectDir) {
+    (0, kernel_js_1.ensureMemoryDirs)(projectDir);
+    ensureDir((0, kernel_js_1.graphRegistryDir)(projectDir));
+    (0, kernel_js_1.buildIndexes)(projectDir);
+    (0, kernel_js_1.buildCodeGraph)(projectDir);
+    (0, kernel_js_1.buildKnowledgeGraph)(projectDir);
+    const metrics = (0, kernel_js_1.kageMetrics)(projectDir);
+    const audit = (0, kernel_js_1.auditProject)(projectDir);
+    const inbox = (0, kernel_js_1.memoryInbox)(projectDir);
+    const metricsPath = ".agent_memory/metrics.json";
+    const auditPath = ".agent_memory/audit.json";
+    const inboxPath = ".agent_memory/inbox.json";
+    writeJson((0, node_path_1.join)(projectDir, metricsPath), metrics);
+    writeJson((0, node_path_1.join)(projectDir, auditPath), audit);
+    writeJson((0, node_path_1.join)(projectDir, inboxPath), inbox);
+    const artifacts = [
+        graphRegistryArtifact(projectDir, ".agent_memory/graph/graph.json", "memory graph", "memory_graph"),
+        graphRegistryArtifact(projectDir, ".agent_memory/code_graph/graph.json", "code graph", "code_graph"),
+        graphRegistryArtifact(projectDir, ".agent_memory/indexes/catalog.json", "packet catalog", "indexes"),
+        graphRegistryArtifact(projectDir, ".agent_memory/indexes/graph.json", "memory graph index", "indexes"),
+        graphRegistryArtifact(projectDir, ".agent_memory/indexes/code-graph.json", "code graph index", "indexes"),
+        graphRegistryArtifact(projectDir, metricsPath, "metrics report", "metrics"),
+        graphRegistryArtifact(projectDir, auditPath, "audit report", "audit"),
+        graphRegistryArtifact(projectDir, inboxPath, "memory inbox report", "inbox"),
+    ].filter((artifact) => Boolean(artifact));
+    const packets = (0, kernel_js_1.loadApprovedPackets)(projectDir).sort((a, b) => a.id.localeCompare(b.id));
+    const payload = {
+        schema_version: 1,
+        repo_key: repoKey(projectDir),
+        project_dir: projectDir,
+        generated_at: nowIso(),
+        repo_state: {
+            branch: gitBranch(projectDir),
+            head: gitHead(projectDir),
+            merge_base: gitMergeBase(projectDir),
+        },
+        artifacts,
+        sources: {
+            packet_schema_version: kernel_js_1.PACKET_SCHEMA_VERSION,
+            packet_count: packets.length,
+            packets: packets.map((packet) => ({
+                id: packet.id,
+                title: packet.title,
+                type: packet.type,
+                status: packet.status,
+                updated_at: packet.updated_at,
+                content_sha256: (0, node_crypto_1.createHash)("sha256").update(canonicalPacketText(packet)).digest("hex"),
+            })),
+        },
+        reports: {
+            metrics: {
+                path: metricsPath,
+                readiness_score: metrics.harness.readiness_score,
+                evidence_coverage_percent: metrics.memory_graph.evidence_coverage_percent,
+            },
+            audit: {
+                path: auditPath,
+                ok: audit.ok,
+                trust_score: audit.trust_score,
+                structured_coverage_percent: audit.checks.structured_memory.coverage_percent,
+                precise_coverage_percent: audit.checks.code_graph.precise_coverage_percent,
+            },
+            inbox: {
+                path: inboxPath,
+                ok: inbox.ok,
+                pending: inbox.counts.pending,
+                stale: inbox.counts.stale,
+                duplicates: inbox.counts.duplicates,
+                missing_context: inbox.counts.missing_context,
+            },
+        },
+    };
+    const manifest = (0, index_js_1.createSignedManifest)({
+        kind: "graph_registry",
+        name: `${repoKey(projectDir)} graph registry`,
+        version: payload.repo_state.head?.slice(0, 12) ?? payload.generated_at.slice(0, 10),
+        keyId: `${repoKey(projectDir)}-local`,
+        payload,
+    });
+    const path = (0, node_path_1.join)((0, kernel_js_1.graphRegistryDir)(projectDir), "manifest.json");
+    writeJson(path, manifest);
+    const errors = [
+        ...(!artifacts.some((artifact) => artifact.kind === "memory_graph") ? ["memory graph artifact missing"] : []),
+        ...(!artifacts.some((artifact) => artifact.kind === "code_graph") ? ["code graph artifact missing"] : []),
+    ];
+    return { ok: errors.length === 0, project_dir: projectDir, path, manifest, artifacts, errors };
+}

package/dist/index.js

@@ -7,6 +7,7 @@ const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
 const kernel_js_1 = require("./kernel.js");
+const graph_registry_js_1 = require("./graph-registry.js");
 const BASE_URL = "https://raw.githubusercontent.com/kage-core/kage-graph/master";
 async function fetchText(url) {
     const res = await fetch(url);
@@ -145,6 +146,17 @@ function listTools() {
                 required: ["project_dir", "query"],
             },
         },
+        {
+            name: "kage_graph_registry",
+            description: "Build a signed graph-registry manifest for generated memory graph, code graph, indexes, metrics, audit, inbox, source packet IDs, packet hashes, and repo git state.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
         {
             name: "kage_code_graph",
             description: "Query the source-derived codebase graph: files, symbols, imports, calls, routes, tests, package scripts. This is generated from code, not learned memory.",
@@ -159,6 +171,17 @@ function listTools() {
                 required: ["project_dir"],
             },
         },
+        {
+            name: "kage_code_index",
+            description: "Write .agent_memory/code_index/lsp-symbols.json, an LSP-compatible symbol artifact consumed by the code graph for higher parser coverage.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
         {
             name: "kage_metrics",
             description: "Return concise Kage adoption and quality metrics: code graph counts, language/parser coverage, memory graph evidence coverage, pending/approved packets, validation state, and readiness score.",
@@ -170,6 +193,28 @@ function listTools() {
                 required: ["project_dir"],
             },
         },
+        {
+            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.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
+        {
+            name: "kage_inbox",
+            description: "Return an actionable memory review inbox: pending packets, stale packets, duplicates, missing structured context, validation issues, and recommended actions.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    project_dir: { type: "string" },
+                },
+                required: ["project_dir"],
+            },
+        },
         {
             name: "kage_refresh",
             description: "Rebuild repo indexes, code graph, memory graph, metrics, and stale-memory metadata. Agents should run this after meaningful file changes and before PR checks.",
@@ -658,6 +703,13 @@ async function callTool(name, args) {
             content: [{ type: "text", text: result.context_block }],
         };
     }
+    if (name === "kage_graph_registry") {
+        const result = (0, graph_registry_js_1.buildGraphRegistryManifest)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
     if (name === "kage_code_graph") {
         const projectDir = String(args?.project_dir ?? "");
         const query = typeof args?.query === "string" ? args.query : "";
@@ -672,12 +724,33 @@ async function callTool(name, args) {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
     }
+    if (name === "kage_code_index") {
+        const result = (0, kernel_js_1.writeLspSymbolIndex)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
     if (name === "kage_metrics") {
         const result = (0, kernel_js_1.kageMetrics)(String(args?.project_dir ?? ""));
         return {
             content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
     }
+    if (name === "kage_audit") {
+        const result = (0, kernel_js_1.auditProject)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
+    if (name === "kage_inbox") {
+        const result = (0, kernel_js_1.memoryInbox)(String(args?.project_dir ?? ""));
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.ok,
+        };
+    }
     if (name === "kage_refresh") {
         const result = (0, kernel_js_1.refreshProject)(String(args?.project_dir ?? ""));
         return {