@kage-core/kage-graph-mcp 2.2.0 → 2.2.2

package/dist/cli.js

@@ -72,6 +72,7 @@ Usage:
   kage slots delete --project <dir> --label <label> [--json]
   kage handoff --project <dir> [--json]
   kage lifecycle --project <dir> [--json]
+  kage reverify --project <dir> --packet <id> [--json]
   kage reconcile --project <dir> [--session <id>] [--json]
   kage timeline --project <dir> [--days <n>] [--json]
   kage lineage --project <dir> [--json]
@@ -338,24 +339,46 @@ async function main() {
             console.log(JSON.stringify(result, null, 2));
             return;
         }
-        console.log("Kage demo — can you trust your agent's memory?\n");
-        console.log(`Seeded ${result.captured.length} grounded memories in a throwaway project (${result.project_dir})\n`);
-        console.log("1. Hallucinated citation — REJECTED on write:");
+        console.log("Kage demo — a live experiment in a sandbox repo. Nothing here is canned:");
+        console.log(`every step below ran for real, just now, in ${result.project_dir}\n`);
+        console.log("  Created a small repo: src/auth.ts, src/payments.ts, src/legacy-retry.ts");
+        console.log(`  Captured ${result.captured.length} memories, each citing real files — accepted and fingerprinted.\n`);
+        console.log("1. Then we tried to save a memory citing a file that does NOT exist:");
         if (result.rejected_hallucination) {
-            console.log(`   ✗ "${result.rejected_hallucination.title}"`);
+            console.log(`   ✗ "${result.rejected_hallucination.title}" — REFUSED at write time:`);
             console.log(`     ${result.rejected_hallucination.error}\n`);
         }
-        console.log("2. Stale memory (cited file deleted) — WITHHELD from recall:");
+        console.log("2. Then we DELETED src/legacy-retry.ts and asked for recall again:");
         for (const w of result.withheld)
-            console.log(`   ⊘ ${w.title}\n     ${w.reason}`);
-        console.log("\n3. Recall returns only grounded, current memory:");
+            console.log(`   ⊘ "${w.title}" — WITHHELD\n     ${w.reason}`);
+        console.log("\n3. What recall actually returns now — only memory that still checks out:");
         for (const t of result.recalled)
             console.log(`   ✓ ${t}`);
-        console.log(`\nTrust score: ${result.trust_score}/100`);
-        console.log("\nNext, in your own repo:");
-        console.log("  kage init --project .                         create repo memory");
-        console.log("  kage setup <agent> --project . --write        wire your agent (claude-code, codex, cursor, ...)");
-        console.log("  kage viewer --project .                       see the dashboard");
+        console.log("\n  Checks: write-time rejection ✓ · stale withholding ✓ · grounded recall ✓");
+        // The sandbox proves the mechanism; the runner's own repo makes it matter.
+        const here = process.cwd();
+        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(here, ".git")) && !takeArg(args, "--project")) {
+            console.log("\nThat was a sandbox. This is YOUR repo — scanning (read-only, ~a minute)...\n");
+            try {
+                const report = (0, kernel_js_1.truthReport)(here);
+                console.log(`  ${report.headline}`);
+                for (const finding of report.findings.slice(0, 3)) {
+                    console.log(`  • ${finding.title}`);
+                }
+                if (report.findings.length > 3)
+                    console.log(`  …and ${report.findings.length - 3} more.`);
+                console.log("\n  Full report:  npx -y @kage-core/kage-graph-mcp scan --project .");
+            }
+            catch {
+                console.log("  (scan skipped — run it yourself: npx -y @kage-core/kage-graph-mcp scan --project .)");
+            }
+        }
+        else {
+            console.log("\nNow point it at a real repo:");
+            console.log("  npx -y @kage-core/kage-graph-mcp scan --project .     the Truth Report — what your repo is hiding");
+        }
+        console.log("\nWire it in (one command, auto-detects your agents):");
+        console.log("  npx -y @kage-core/kage-graph-mcp install");
         return;
     }
     if (command === "init") {
@@ -1342,6 +1365,27 @@ async function main() {
         }
         return;
     }
+    if (command === "reverify") {
+        const packetId = takeArg(args, "--packet");
+        if (!packetId)
+            usage();
+        const result = (0, kernel_js_1.reverifyMemory)(projectArg(args), packetId);
+        if (args.includes("--json")) {
+            console.log(JSON.stringify(result, null, 2));
+        }
+        else if (result.ok) {
+            console.log(`Reverified ${result.packet_id}`);
+            console.log(`  grounding refreshed for ${result.refreshed_paths.length} path(s)${result.was_stale ? " · stale flag cleared" : ""}`);
+            if (result.missing_paths.length)
+                console.log(`  dropped missing path(s): ${result.missing_paths.join(", ")}`);
+        }
+        else {
+            console.log(`Reverify failed: ${result.errors.join("; ")}`);
+        }
+        if (!result.ok)
+            process.exit(2);
+        return;
+    }
     if (command === "reconcile" || command === "memory-reconcile" || command === "memory-reconciliation") {
         const result = (0, kernel_js_1.kageMemoryReconciliation)(projectArg(args), {
             sessionId: takeArg(args, "--session"),

package/dist/kernel.js

@@ -175,6 +175,7 @@ exports.remediationFor = remediationFor;
 exports.approvePending = approvePending;
 exports.rejectPending = rejectPending;
 exports.changelog = changelog;
+exports.reverifyMemory = reverifyMemory;
 exports.supersedeMemory = supersedeMemory;
 exports.kageMemoryLineage = kageMemoryLineage;
 exports.kageMemoryTimeline = kageMemoryTimeline;
@@ -1554,7 +1555,7 @@ function reconciliationInstruction(items) {
     return [
         "Memory reconciliation required before final response.",
         "You changed code that is linked to existing repo memory. Update the memory yourself; do not push this to the user as a manual inbox chore.",
-        "For each item, call kage_learn to save the new behavior and kage_supersede when replacing the old packet, or mark stale only if the memory is no longer trusted.",
+        "If the memory's claim is unchanged and only the cited code moved, run kage reverify --packet <id> to refresh its grounding in place. Otherwise call kage_learn to save the new behavior and kage_supersede when replacing the old packet, or mark stale only if the memory is no longer trusted.",
         ...lines,
     ].join("\n");
 }
@@ -8801,7 +8802,10 @@ function truthReport(projectDir) {
             // Path claims only count in prose; fenced content is sample output.
             for (const candidate of entry.fence === null ? truthDocPathCandidates(entry.text) : []) {
                 const key = `path:${candidate}`;
-                if (seenLies.has(key) || (0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, candidate)))
+                // A cited path is a lie only if it resolves nowhere: docs use both
+                // repo-root-relative paths and links relative to the doc's own dir.
+                const resolves = (0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, candidate)) || (0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, (0, node_path_1.dirname)(entry.doc), candidate));
+                if (seenLies.has(key) || resolves)
                     continue;
                 seenLies.add(key);
                 docLieFindings.push({
@@ -15675,6 +15679,57 @@ function packetSupersessionReason(packet) {
     const evidence = edge ? packetEdgeValue(edge, "evidence") : "";
     return evidence || "This memory was superseded by newer repo knowledge.";
 }
+// Re-verify a still-true packet in place: re-check cited paths, refresh
+// fingerprints and last_verified_at, and clear stale flags. The alternative to
+// supersede churn when code changed but the memory's claim did not. Refuses
+// when ALL cited evidence is gone — that memory needs supersede or stale, not
+// a rubber stamp.
+function reverifyMemory(projectDir, packetId) {
+    ensureMemoryDirs(projectDir);
+    const result = {
+        ok: false,
+        project_dir: projectDir,
+        packet_id: packetId,
+        refreshed_paths: [],
+        missing_paths: [],
+        was_stale: false,
+        errors: [],
+    };
+    const entries = loadPacketEntriesFromDir(packetsDir(projectDir));
+    const entry = entries.find((item) => item.packet.id === packetId);
+    if (!entry) {
+        result.errors.push(`Packet not found: ${packetId}`);
+        return result;
+    }
+    const packet = entry.packet;
+    const quality = (packet.quality ?? {});
+    result.was_stale = quality.stale === true;
+    const citedPaths = unique([
+        ...packet.paths,
+        ...packetStoredPathFingerprints(packet).map((fingerprint) => fingerprint.path),
+    ]).filter(fingerprintableMemoryPath);
+    result.missing_paths = citedPaths.filter((path) => !(0, node_fs_1.existsSync)((0, node_path_1.join)(projectDir, path)));
+    if (citedPaths.length && result.missing_paths.length === citedPaths.length) {
+        result.errors.push("All cited paths are gone — reverify would rubber-stamp dead evidence. Use kage supersede with a replacement, or mark the packet stale.");
+        return result;
+    }
+    const presentPaths = citedPaths.filter((path) => !result.missing_paths.includes(path));
+    const now = nowIso();
+    const freshness = { ...(packet.freshness ?? {}) };
+    freshness.path_fingerprints = memoryPathFingerprints(projectDir, presentPaths);
+    freshness.last_verified_at = now;
+    const { stale: _stale, stale_reasons: _staleReasons, suggested_action: _suggestedAction, ...nextQuality } = quality;
+    writeJson(entry.path, {
+        ...packet,
+        paths: presentPaths.length ? presentPaths : packet.paths,
+        freshness,
+        quality: { ...nextQuality, reverified_at: now },
+        updated_at: now,
+    });
+    result.refreshed_paths = presentPaths;
+    result.ok = true;
+    return result;
+}
 function supersedeMemory(projectDir, oldPacketId, replacementPacketId, reason = "") {
     ensureMemoryDirs(projectDir);
     const trimmedReason = reason.trim() || "Newer repo memory supersedes this packet.";
@@ -16152,13 +16207,13 @@ function resolvePacketSyncConflict(memoryDir, file) {
 function rebaseOntoUpstream(memoryDir, upstream) {
     const conflictBackups = [];
     let resolved = 0;
-    let step = runSyncGit(memoryDir, ["-c", "core.editor=true", "rebase", upstream]);
+    let step = runSyncGit(memoryDir, [...syncIdentityArgs(memoryDir), "-c", "core.editor=true", "rebase", upstream]);
     while (!step.ok) {
         const conflicted = runSyncGit(memoryDir, ["diff", "--name-only", "--diff-filter=U"])
             .stdout.split("\n").map((line) => line.trim()).filter(Boolean);
         if (!conflicted.length) {
             // The resolved commit became empty (we kept the upstream side wholesale).
-            const skip = runSyncGit(memoryDir, ["-c", "core.editor=true", "rebase", "--skip"]);
+            const skip = runSyncGit(memoryDir, [...syncIdentityArgs(memoryDir), "-c", "core.editor=true", "rebase", "--skip"]);
             if (skip.ok) {
                 step = skip;
                 continue;
@@ -16182,7 +16237,7 @@ function rebaseOntoUpstream(memoryDir, upstream) {
             const toAdd = [file, ...(resolution.backupPath ? [(0, node_path_1.relative)(memoryDir, resolution.backupPath)] : [])];
             runSyncGit(memoryDir, ["add", "--", ...toAdd]);
         }
-        step = runSyncGit(memoryDir, ["-c", "core.editor=true", "rebase", "--continue"]);
+        step = runSyncGit(memoryDir, [...syncIdentityArgs(memoryDir), "-c", "core.editor=true", "rebase", "--continue"]);
     }
     return { ok: true, resolved, conflictBackups };
 }
@@ -16267,9 +16322,25 @@ function syncSetup(remoteUrl) {
         }
     }
     result.branch = runSyncGit(memoryDir, ["rev-parse", "--abbrev-ref", "HEAD"]).stdout || null;
-    const push = runSyncGit(memoryDir, ["push", "-u", "origin", "HEAD"]);
+    let push = runSyncGit(memoryDir, ["push", "-u", "origin", "HEAD"]);
+    if (!push.ok && /non-fast-forward|behind|fetch first/i.test(push.stderr)) {
+        // Some git versions leave the local branch behind the remote after the
+        // convergence rebase (observed on CI's git, not on macOS). A second
+        // fetch + rebase fast-forwards a behind branch, after which push succeeds.
+        runSyncGit(memoryDir, ["fetch", "origin"]);
+        const retryBranch = syncRemoteDefaultBranch(memoryDir) ?? result.branch;
+        if (retryBranch && runSyncGit(memoryDir, ["rev-parse", "--verify", "--quiet", `origin/${retryBranch}`]).ok) {
+            runSyncGit(memoryDir, ["branch", "-M", retryBranch]);
+            const retryRebase = rebaseOntoUpstream(memoryDir, `origin/${retryBranch}`);
+            if (retryRebase.ok)
+                push = runSyncGit(memoryDir, ["push", "-u", "origin", "HEAD"]);
+        }
+    }
     if (!push.ok) {
-        result.errors.push(`git push failed: ${push.stderr}`);
+        const state = runSyncGit(memoryDir, ["log", "--oneline", "--all", "--decorate", "-n", "8"]).stdout;
+        result.errors.push(`git push failed: ${push.stderr}${state ? `
+repo state:
+${state}` : ""}`);
         return result;
     }
     result.pushed = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kage-core/kage-graph-mcp",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Local-first repo memory, code graph, and recall MCP server for coding agents",
   "main": "dist/index.js",
   "files": [

package/viewer/index.html

@@ -6,35 +6,24 @@
     <title>Kage — memory dashboard</title>
     <style>
       /* V2 "receipts" theme. Tokens mirror docs/assets/site.css so the dashboard
-         matches the site: light-first warm paper, editorial serif display type,
-         deep verified-green for gains, dark-capable via prefers-color-scheme. */
+         matches the site: dark-first product look, editorial serif display type,
+         verified-green for gains. One look everywhere. */
       :root {
-        color-scheme: light dark;
-        --bg: #f6f4ef; --paper: #fffdf9; --paper-2: #efece4;
-        --line: #e2ded2; --line-strong: #c9c4b4;
-        --ink: #1c1e1a; --muted: #5d635b; --faint: #8b9088;
-        --gain: #0c7a4d; --gain-strong: #09935c; --gain-soft: rgba(12, 122, 77, 0.08);
-        --code: #155e9c; --memory: #6d49b8; --warn: #9a6b08; --danger: #b03048;
-        --warn-soft: rgba(154, 107, 8, 0.10);
-        --code-bg: #15181b; --code-text: #d7e2da;
-        --tip-bg: #fffdf9; --shadow: 0 14px 40px rgba(28, 30, 26, 0.12);
+        color-scheme: dark;
+        --bg: #121413; --paper: #1a1d1b; --paper-2: #212522;
+        --line: #2c302c; --line-strong: #41463f;
+        --ink: #edefe9; --muted: #a4aba1; --faint: #767d74;
+        --gain: #43c98a; --gain-strong: #5fdca0; --gain-soft: rgba(67, 201, 138, 0.12);
+        --code: #6fb4e8; --memory: #b095e8; --warn: #d9a93f; --danger: #e07a8c;
+        --warn-soft: rgba(217, 169, 63, 0.10);
+        --code-bg: #0e1110; --code-text: #cfe0d4;
+        --tip-bg: #212522; --shadow: 0 14px 40px rgba(0, 0, 0, 0.5);
         --sans: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
         --serif: "Iowan Old Style", "Palatino Linotype", Palatino, Georgia, "Times New Roman", serif;
         --mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
         --r-control: 4px; --r-panel: 6px; --r-card: 8px;
       }
-      @media (prefers-color-scheme: dark) {
-        :root {
-          --bg: #121413; --paper: #1a1d1b; --paper-2: #212522;
-          --line: #2c302c; --line-strong: #41463f;
-          --ink: #edefe9; --muted: #a4aba1; --faint: #767d74;
-          --gain: #43c98a; --gain-strong: #5fdca0; --gain-soft: rgba(67, 201, 138, 0.12);
-          --code: #6fb4e8; --memory: #b095e8; --warn: #d9a93f; --danger: #e07a8c;
-          --warn-soft: rgba(217, 169, 63, 0.10);
-          --code-bg: #0e1110; --code-text: #cfe0d4;
-          --tip-bg: #212522; --shadow: 0 14px 40px rgba(0, 0, 0, 0.5);
-        }
-      }
+      /* Dark-first: one product look (light tokens retired 2026-06-12). */
       * { box-sizing: border-box; }
       html, body { margin: 0; }
       body { background: var(--bg); color: var(--ink); font: 400 14px/1.55 var(--sans); -webkit-font-smoothing: antialiased; }