kirograph 0.22.0 → 0.26.0

package/README.md

@@ -43,8 +43,9 @@ The result is fewer tool calls, less context used, and faster responses on compl
 | <h4>Security</h4> | |
 | 🔒 **Security (KiroGraph-Sec opt-in  module)** | Goes beyond "this dependency has a CVE" — uses the call graph to determine if vulnerable code is **actually reachable** from your entry points. Maps your **attack surface** (which HTTP routes reach vulnerable deps). Detects **hardcoded secrets** and shows how many entry points expose them. **SAST-lite** finds SQL injection, path traversal, and dangerous eval in your code. **AST-based SAST (opt-in via `enablePatterns`)** runs 10 bundled structural pattern rules via `@ast-grep/napi` — matches actual code structure, not just symbol names. **Supply chain health** checks OpenSSF Scorecard scores and detects dependency confusion attacks. Covers 14 ecosystems, outputs CycloneDX SBOM/VEX and CI-ready SARIF reports. |
 | <h4>Knowledge & Data</h4> | |
-| 🧠 **Persistent Memor (KiroGraph-Mem opt-in module)** | Cross-session observations — decisions, errors, patterns — auto-linked to code symbols |
+| 🧠 **Persistent Memory (KiroGraph-Mem opt-in module)** | Cross-session observations — decisions, errors, patterns — auto-linked to code symbols. **Conflict detection**: typed relations between observations (`supersedes`, `conflicts_with`, `compatible`) with agent judgment workflow (`kirograph_mem_compare`, `kirograph_mem_judge`). **Stale review**: schedule observations for re-evaluation (`review_after` + `kirograph_mem_review`). **Passive capture**: extract learnings from structured text. **Prompt saving**: session context reconstruction. **Topic key**: stable semantic addressing. Inspired by [Engram](https://github.com/Gentleman-Programming/engram). |
 | 👁️ **Watchmen (KiroGraph-Watchmen opt-in module)** ⚠️ *experimental* | Auto-synthesizes accumulated memory observations into workspace briefs and `inclusion: manual` skill files. Fires via the `watchmenReady` signal in `kirograph_mem_store` when threshold is reached. **Local model** (default, `watchmenSynthesisMode: 'local'`): runs `gemma-4-E4B-it-ONNX` on-device via `@huggingface/transformers` — ~3–4 GB one-time download, ~3–5 GB RAM, 8–15 s on Apple Silicon M1+. No API key, no background daemon, no external calls. **Agent mode** also available for Kiro (`watchmenSynthesisMode: 'agent'`, uses active session). ⚠️ **Experimental:** output quality in local mode depends heavily on the model chosen and your hardware. Smaller models or slower machines may produce incomplete briefs and lower-quality skill files. Use `agent` mode for best results. |
+| 📚 **Wiki (KiroGraph-Wiki opt-in module)** | Karpathy-style LLM wiki — a set of markdown pages that compound knowledge across sessions. Three ops: **ingest** (build structured prompt from source text), **apply-diff** (write LLM-generated WIKI_DIFF to SQLite + disk), **lint** (broken links, orphan pages, contradictions). Context enrichment: `kirograph_context` auto-includes relevant wiki pages above score threshold. Two synthesis modes: `agent` (IDE LLM) or `local` (HuggingFace, same infra as Watchmen). Conflict resolution: deterministic by source date when `wikiAutoResolveConflicts: true`. Inspired by [Karpathy's LLM Wiki pattern](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f). |
 | 📖 **Documentation Indexing (KiroGraph-Doc opt-in  module)** | Section-level retrieval from Markdown, MDX, RST, AsciiDoc, OpenAPI — 92-97% token savings |
 | 📊 **Data Navigation (KiroGraph-Data opt-in  module)** | Query CSV/JSON/Excel/Parquet/**PDF** with filters, aggregations, joins — all server-side in SQLite |
 | <h4>Token Optimization</h4> | |
@@ -142,11 +143,18 @@ KiroGraph is inspired by [CodeGraph](https://github.com/colbymchenry/codegraph)
 ### Inspirations
 
 - [cavemem](https://github.com/JuliusBrussee/cavemem) by [Julius Brussee](https://www.linkedin.com/in/julius-brussee/): the memory module's hook-based observation capture, deterministic compression, and SQLite storage pattern.
+- [Engram](https://github.com/Gentleman-Programming/engram) by [Gentleman-Programming](https://github.com/Gentleman-Programming): conflict detection (typed relations + judgment workflow), `topic_key` stable addressing, `review_after` stale observation scheduling, passive capture, and prompt saving patterns.
+- [caveman](https://github.com/JuliusBrussee/caveman) by [Julius Brussee](https://www.linkedin.com/in/julius-brussee/): the caveman mode's agent prose compression concept, multi-level steering injection.
 - [watchmen](https://github.com/firstbatchxyz/watchmen) by [firstbatch](https://github.com/firstbatchxyz): the watchmen module's session-mining concept, workspace brief generation, and `AGENTS.md` mirroring pattern.
+- [LLM Wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) by [Andrej Karpathy](https://karpathy.ai/): the wiki module's three-op pattern (ingest → apply → lint), WIKI_DIFF block format, two-tool ingest flow, and the principle of knowledge compounding rather than accumulating.
 - [jDocMunch-MCP](https://github.com/jgravelle/jdocmunch-mcp) by [J. Gravelle](https://www.linkedin.com/in/j-gravelle-2778223/): the documentation module's section-first retrieval approach, stable section IDs, and byte-offset addressing.
 - [jDataMunch-MCP](https://github.com/jgravelle/jdatamunch-mcp) by [J. Gravelle](https://www.linkedin.com/in/j-gravelle-2778223/): the data module's column profiling, streaming parsers, and server-side aggregation approach.
+- [rtk](https://github.com/rtk-ai/rtk) by [rtk-ai](https://github.com/rtk-ai): the shell compression module's command-family approach and token-optimized output patterns.
 - [code-review-graph](https://github.com/tirth8205/code-review-graph) by [Tirth Kanani](https://github.com/tirth8205): community detection, execution flow tracing, refactoring tools, and multi-platform auto-detection patterns.
 - [lean-ctx](https://github.com/yvgude/lean-ctx) by [Yves Gugger](https://github.com/yvgude): file read caching, multiple read modes, and context budget governance concepts.
+- [turboquant-js](https://github.com/danilodevhub/turboquant-js) by [Danilo Dev](https://github.com/danilodevhub): the TurboQuant engine — TypeScript implementation of Google's Walsh-Hadamard + Lloyd-Max quantization algorithm used for embedding compression.
+- [turbovec](https://github.com/RyanCodrai/turbovec) by [Ryan Codrai](https://github.com/RyanCodrai): the TurboVec engine — Rust implementation of TurboQuant with SIMD acceleration, exposed to Node.js via a napi-rs native addon.
+- [pdf-inspector](https://github.com/firecrawl/pdf-inspector) by [Firecrawl](https://github.com/firecrawl): the PDF parser used in the data module — pure Rust, no OCR, no network, prebuilt binaries for linux-x64 and macOS ARM64.
 
 ### Contributors
 
@@ -155,16 +163,22 @@ KiroGraph is inspired by [CodeGraph](https://github.com/colbymchenry/codegraph)
 
 ## How It Compares
 
-KiroGraph combines capabilities from 7 separate tools into one integrated MCP server:
+KiroGraph combines capabilities from 13 separate projects into one integrated MCP server:
 
 | Capability | Inspired by | What KiroGraph adds |
 |-----------|-------------|---------------------|
-| Code graph | [CodeGraph](https://github.com/colbymchenry/codegraph) | Architecture metrics, community detection, execution flows |
-| Memory | [cavemem](https://github.com/JuliusBrussee/cavemem) | Symbol-linked observations, 7 semantic engines |
+| Code graph | [CodeGraph](https://github.com/colbymchenry/codegraph) | Architecture metrics, execution flows, layered dependency view |
+| Community detection | [code-review-graph](https://github.com/tirth8205/code-review-graph) | Coupling metrics (Ca/Ce/instability), refactoring tools, multi-platform auto-detect |
+| Memory | [cavemem](https://github.com/JuliusBrussee/cavemem) + [Engram](https://github.com/Gentleman-Programming/engram) | Symbol-linked observations, 9 semantic engines, conflict detection, stale review |
+| Watchmen synthesis | [watchmen](https://github.com/firstbatchxyz/watchmen) | Local-model synthesis on-device, auto threshold, steering + skill file generation |
+| LLM Wiki | [Karpathy's LLM Wiki gist](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f) | WIKI_DIFF format, FTS5 search, conflict resolution, local model mode |
 | Docs | [jDocMunch-MCP](https://github.com/jgravelle/jdocmunch-mcp) | Code ↔ docs cross-references |
-| Data | [jDataMunch-MCP](https://github.com/jgravelle/jdatamunch-mcp) | Unified with code graph in one server |
+| Data | [jDataMunch-MCP](https://github.com/jgravelle/jdatamunch-mcp) | Unified with code graph in one server, PDF parsing |
+| PDF parsing | [pdf-inspector](https://github.com/firecrawl/pdf-inspector) | Pure Rust, no OCR/network, prebuilt binaries, piped into data module |
 | Shell compression | [rtk](https://github.com/rtk-ai/rtk) | Integrated as MCP tool, no separate binary |
 | Prose compression | [caveman](https://github.com/JuliusBrussee/caveman) | Multi-level (lite/full/ultra) via steering |
+| Embedding compression | [turboquant-js](https://github.com/danilodevhub/turboquant-js) | 9 engine options, SIMD Rust variant, 20–30× RAM savings |
+| SIMD vector search | [turbovec](https://github.com/RyanCodrai/turbovec) | NEON on ARM64, AVX-512BW on x86, auto-built by installer |
 | Context layer | [lean-ctx](https://github.com/yvgude/lean-ctx) | File caching, read modes, budget governance |
 
 See the [full comparison](docs/guide/comparison.md) for a detailed feature matrix against CodeGraph, code-review-graph, jCodeMunch, and others.

package/dist/bin/commands/configure-mcp.js

@@ -0,0 +1,104 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var configure_mcp_exports = {};
+__export(configure_mcp_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(configure_mcp_exports);
+var path = __toESM(require("path"));
+var fs = __toESM(require("fs"));
+var os = __toESM(require("os"));
+var import_config = require("../../config");
+var import_tool_names = require("../../mcp/tool-names");
+var import_common = require("../installer/common");
+const PROJECT_MCP_PATHS = [
+  ".kiro/settings/mcp.json",
+  ".mcp.json",
+  ".cursor/mcp.json",
+  ".warp/.mcp.json",
+  ".roo/mcp.json",
+  ".augment/mcp.json",
+  ".tabnine/mcp.json",
+  ".cline/mcp_settings.json",
+  ".trae/mcp.json",
+  ".junie/mcp/mcp.json",
+  ".qoder/mcp.json",
+  ".github/copilot-mcp.json",
+  ".continue/mcpServers/kirograph.json"
+];
+const HOME_MCP_PATHS = [
+  path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json"),
+  path.join(os.homedir(), ".copilot", "mcp-config.json"),
+  path.join(os.homedir(), ".gemini", "antigravity", "mcp_config.json"),
+  path.join(os.homedir(), ".qwen", "settings.json")
+];
+function register(program) {
+  program.command("configure-mcp [projectPath]").description("Sync MCP autoApprove list with the features enabled in .kirograph/config.json").action(async (projectPath) => {
+    const target = path.resolve(projectPath ?? process.cwd());
+    const configFile = path.join(target, ".kirograph", "config.json");
+    if (!fs.existsSync(configFile)) {
+      console.error(`  \u2717 No .kirograph/config.json found in ${target}`);
+      console.error(`    Run 'kirograph install' first.`);
+      process.exit(1);
+    }
+    const config = await (0, import_config.loadConfig)(target);
+    const cfg = config;
+    const toolNames = (0, import_tool_names.filterToolNamesByConfig)(import_tool_names.KIROGRAPH_TOOL_NAMES, cfg);
+    const featuresArg = (0, import_tool_names.serializeFeaturesArg)(cfg);
+    const enabledFeatures = Object.keys(import_tool_names.FEATURE_TOOLS).filter((f) => cfg[f]);
+    console.log(`
+  Enabled features: ${enabledFeatures.length ? enabledFeatures.join(", ") : "none (core only)"}`);
+    console.log(`  Tools to approve: ${toolNames.length} / ${import_tool_names.KIROGRAPH_TOOL_NAMES.length}
+`);
+    const candidates = [
+      ...PROJECT_MCP_PATHS.map((p) => path.join(target, p)),
+      ...HOME_MCP_PATHS
+    ];
+    let updatedCount = 0;
+    for (const mcpPath of candidates) {
+      const autoApproveUpdated = (0, import_common.updateMcpAutoApprove)(mcpPath, toolNames);
+      const argsUpdated = (0, import_common.updateMcpFeaturesArg)(mcpPath, featuresArg || null);
+      if (autoApproveUpdated || argsUpdated) {
+        console.log(`  \u2713 ${mcpPath}`);
+        updatedCount++;
+      }
+    }
+    if (updatedCount === 0) {
+      console.error(`  \u2717 No registered MCP configs found. Run 'kirograph install' first.`);
+      process.exit(1);
+    }
+    console.log(`
+  Updated ${updatedCount} config(s). Restart your IDE for changes to take effect.`);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});
+//# sourceMappingURL=configure-mcp.js.map

package/dist/bin/commands/configure-mcp.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/bin/commands/configure-mcp.ts"],
+  "sourcesContent": ["import { Command } from 'commander';\nimport * as path from 'path';\nimport * as fs from 'fs';\nimport * as os from 'os';\nimport { loadConfig } from '../../config';\nimport { filterToolNamesByConfig, serializeFeaturesArg, KIROGRAPH_TOOL_NAMES, FEATURE_TOOLS } from '../../mcp/tool-names';\nimport { updateMcpAutoApprove, updateMcpFeaturesArg } from '../installer/common';\n\nconst PROJECT_MCP_PATHS = [\n  '.kiro/settings/mcp.json',\n  '.mcp.json',\n  '.cursor/mcp.json',\n  '.warp/.mcp.json',\n  '.roo/mcp.json',\n  '.augment/mcp.json',\n  '.tabnine/mcp.json',\n  '.cline/mcp_settings.json',\n  '.trae/mcp.json',\n  '.junie/mcp/mcp.json',\n  '.qoder/mcp.json',\n  '.github/copilot-mcp.json',\n  '.continue/mcpServers/kirograph.json',\n];\n\nconst HOME_MCP_PATHS = [\n  path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json'),\n  path.join(os.homedir(), '.copilot', 'mcp-config.json'),\n  path.join(os.homedir(), '.gemini', 'antigravity', 'mcp_config.json'),\n  path.join(os.homedir(), '.qwen', 'settings.json'),\n];\n\nexport function register(program: Command): void {\n  program\n    .command('configure-mcp [projectPath]')\n    .description('Sync MCP autoApprove list with the features enabled in .kirograph/config.json')\n    .action(async (projectPath?: string) => {\n      const target = path.resolve(projectPath ?? process.cwd());\n\n      const configFile = path.join(target, '.kirograph', 'config.json');\n      if (!fs.existsSync(configFile)) {\n        console.error(`  \u2717 No .kirograph/config.json found in ${target}`);\n        console.error(`    Run 'kirograph install' first.`);\n        process.exit(1);\n      }\n\n      const config = await loadConfig(target);\n      const cfg = config as unknown as Record<string, boolean>;\n      const toolNames = filterToolNamesByConfig(KIROGRAPH_TOOL_NAMES, cfg);\n      const featuresArg = serializeFeaturesArg(cfg);\n\n      const enabledFeatures = Object.keys(FEATURE_TOOLS).filter(f => cfg[f]);\n      console.log(`\\n  Enabled features: ${enabledFeatures.length ? enabledFeatures.join(', ') : 'none (core only)'}`);\n      console.log(`  Tools to approve: ${toolNames.length} / ${KIROGRAPH_TOOL_NAMES.length}\\n`);\n\n      const candidates = [\n        ...PROJECT_MCP_PATHS.map(p => path.join(target, p)),\n        ...HOME_MCP_PATHS,\n      ];\n\n      let updatedCount = 0;\n      for (const mcpPath of candidates) {\n        const autoApproveUpdated = updateMcpAutoApprove(mcpPath, toolNames);\n        const argsUpdated = updateMcpFeaturesArg(mcpPath, featuresArg || null);\n        if (autoApproveUpdated || argsUpdated) {\n          console.log(`  \u2713 ${mcpPath}`);\n          updatedCount++;\n        }\n      }\n\n      if (updatedCount === 0) {\n        console.error(`  \u2717 No registered MCP configs found. Run 'kirograph install' first.`);\n        process.exit(1);\n      }\n\n      console.log(`\\n  Updated ${updatedCount} config(s). Restart your IDE for changes to take effect.`);\n    });\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,WAAsB;AACtB,SAAoB;AACpB,SAAoB;AACpB,oBAA2B;AAC3B,wBAAmG;AACnG,oBAA2D;AAE3D,MAAM,oBAAoB;AAAA,EACxB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEA,MAAM,iBAAiB;AAAA,EACrB,KAAK,KAAK,GAAG,QAAQ,GAAG,YAAY,YAAY,iBAAiB;AAAA,EACjE,KAAK,KAAK,GAAG,QAAQ,GAAG,YAAY,iBAAiB;AAAA,EACrD,KAAK,KAAK,GAAG,QAAQ,GAAG,WAAW,eAAe,iBAAiB;AAAA,EACnE,KAAK,KAAK,GAAG,QAAQ,GAAG,SAAS,eAAe;AAClD;AAEO,SAAS,SAAS,SAAwB;AAC/C,UACG,QAAQ,6BAA6B,EACrC,YAAY,+EAA+E,EAC3F,OAAO,OAAO,gBAAyB;AACtC,UAAM,SAAS,KAAK,QAAQ,eAAe,QAAQ,IAAI,CAAC;AAExD,UAAM,aAAa,KAAK,KAAK,QAAQ,cAAc,aAAa;AAChE,QAAI,CAAC,GAAG,WAAW,UAAU,GAAG;AAC9B,cAAQ,MAAM,+CAA0C,MAAM,EAAE;AAChE,cAAQ,MAAM,oCAAoC;AAClD,cAAQ,KAAK,CAAC;AAAA,IAChB;AAEA,UAAM,SAAS,UAAM,0BAAW,MAAM;AACtC,UAAM,MAAM;AACZ,UAAM,gBAAY,2CAAwB,wCAAsB,GAAG;AACnE,UAAM,kBAAc,wCAAqB,GAAG;AAE5C,UAAM,kBAAkB,OAAO,KAAK,+BAAa,EAAE,OAAO,OAAK,IAAI,CAAC,CAAC;AACrE,YAAQ,IAAI;AAAA,sBAAyB,gBAAgB,SAAS,gBAAgB,KAAK,IAAI,IAAI,kBAAkB,EAAE;AAC/G,YAAQ,IAAI,uBAAuB,UAAU,MAAM,MAAM,uCAAqB,MAAM;AAAA,CAAI;AAExF,UAAM,aAAa;AAAA,MACjB,GAAG,kBAAkB,IAAI,OAAK,KAAK,KAAK,QAAQ,CAAC,CAAC;AAAA,MAClD,GAAG;AAAA,IACL;AAEA,QAAI,eAAe;AACnB,eAAW,WAAW,YAAY;AAChC,YAAM,yBAAqB,oCAAqB,SAAS,SAAS;AAClE,YAAM,kBAAc,oCAAqB,SAAS,eAAe,IAAI;AACrE,UAAI,sBAAsB,aAAa;AACrC,gBAAQ,IAAI,YAAO,OAAO,EAAE;AAC5B;AAAA,MACF;AAAA,IACF;AAEA,QAAI,iBAAiB,GAAG;AACtB,cAAQ,MAAM,0EAAqE;AACnF,cAAQ,KAAK,CAAC;AAAA,IAChB;AAEA,YAAQ,IAAI;AAAA,YAAe,YAAY,0DAA0D;AAAA,EACnG,CAAC;AACL;",
+  "names": []
+}

package/dist/bin/commands/memory.js

@@ -80,6 +80,13 @@ function register(program) {
         for (const r of results) {
           const age = formatAge(r.observation.createdAt);
           console.log(`  ${import_ui.violet}[${r.observation.kind}]${import_ui.reset} ${r.observation.content}`);
+          if (r.relations && r.relations.length > 0) {
+            const annotations = r.relations.filter((rel) => rel.judgmentStatus !== "ignored").map((rel) => {
+              const icon = rel.relation === "conflicts_with" ? "\u26A1" : rel.relation === "supersedes" ? "\u21A9" : "~";
+              return `${icon} ${rel.relation}`;
+            }).join("  ");
+            if (annotations) console.log(`  ${import_ui.dim}${annotations}${import_ui.reset}`);
+          }
           console.log(`  ${import_ui.dim}${age} \xB7 score: ${r.score.toFixed(3)}${import_ui.reset}
 `);
         }
@@ -89,7 +96,7 @@ function register(program) {
     trackCliToolSaving(cwd, "kirograph_mem_search", output, { limit: parseInt(opts.limit) });
     cg.close();
   });
-  mem.command("store [content]").description("Store an observation in memory").option("--kind <kind>", "Observation kind", "note").action(async (content, opts) => {
+  mem.command("store [content]").description("Store an observation in memory").option("--kind <kind>", "Observation kind", "note").option("--topic-key <key>", "Stable semantic key (e.g. architecture/auth-model)").option("--review-after <ms>", "Epoch ms: schedule re-evaluation after this timestamp").action(async (content, opts) => {
     const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
     const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
     const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
@@ -120,7 +127,13 @@ function register(program) {
     db.applyMemorySchema();
     const mem2 = new MemoryManager(config, db.getRawDb());
     mem2.initialize();
-    const result = await mem2.store({ content: text, kind: opts.kind, source: "manual" });
+    const result = await mem2.store({
+      content: text,
+      kind: opts.kind,
+      source: "manual",
+      topicKey: opts.topicKey,
+      reviewAfter: opts.reviewAfter ? parseInt(opts.reviewAfter) : void 0
+    });
     if (!result) {
       console.log(`  ${import_ui.dim}Duplicate observation \u2014 already stored.${import_ui.reset}`);
     } else if (typeof result === "object" && result.watchmenReady) {
@@ -233,6 +246,7 @@ function register(program) {
     console.log(`  Observations:   ${import_ui.bold}${stats.observations}${import_ui.reset}`);
     console.log(`  Symbol links:   ${import_ui.bold}${stats.links}${import_ui.reset}`);
     console.log(`  Embeddings:     ${import_ui.bold}${stats.vectors}${import_ui.reset} / ${stats.embeddableCount}`);
+    console.log(`  Relations:      ${import_ui.bold}${stats.relations}${import_ui.reset} (${stats.pendingConflicts} pending)`);
     console.log(`  Model mismatch: ${stats.modelMismatch ? import_ui.violet + "\u26A0 yes \u2014 run kirograph mem reembed" + import_ui.reset : import_ui.dim + "no" + import_ui.reset}`);
     console.log(`  Compression:    ${config.cavemanMode !== "off" ? import_ui.violet + config.cavemanMode + import_ui.reset : import_ui.dim + "off (storing raw)" + import_ui.reset}`);
     console.log("");
@@ -422,6 +436,324 @@ function register(program) {
     console.log("");
     cg.close();
   });
+  mem.command("review").description("List observations past their review_after date").option("--limit <n>", "Max results", "20").option("--format <fmt>", "Output format: text, json", "text").action(async (opts) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    const obs = mem2.getObservationsForReview(parseInt(opts.limit));
+    if (opts.format === "json") {
+      console.log(JSON.stringify(obs));
+    } else if (obs.length === 0) {
+      console.log(`
+  ${import_ui.dim}No overdue observations.${import_ui.reset}
+`);
+    } else {
+      console.log(`
+  ${(0, import_ui.section)("Memory Review Queue")} \u2014 ${obs.length} overdue
+`);
+      const now = Date.now();
+      for (const o of obs) {
+        const daysOverdue = Math.floor((now - (o.reviewAfter ?? now)) / 864e5);
+        console.log(`  ${import_ui.violet}[${o.kind}]${import_ui.reset}${o.topicKey ? ` ${import_ui.dim}(${o.topicKey})${import_ui.reset}` : ""} ${o.content.slice(0, 120)}`);
+        console.log(`  ${import_ui.dim}Overdue by ${daysOverdue}d \xB7 ID: ${o.id}${import_ui.reset}
+`);
+      }
+    }
+    cg.close();
+  });
+  mem.command("mark-reviewed <id>").description("Mark an observation as reviewed \u2014 clears its review_after date").action(async (id) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    mem2.markReviewed(id);
+    console.log(`  \u2713 Observation ${import_ui.dim}${id}${import_ui.reset} marked as reviewed`);
+    cg.close();
+  });
+  mem.command("suggest-topic-key").description("Suggest a stable topic_key for an observation").requiredOption("--kind <kind>", "Observation kind: decision, error, pattern, architecture, summary, note").requiredOption("--title <title>", "Short title or first sentence").action(async (opts) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    const key = mem2.suggestTopicKey(opts.kind, opts.title);
+    console.log(`  ${import_ui.violet}${key}${import_ui.reset}`);
+    cg.close();
+  });
+  mem.command("capture [content]").description("Extract and store structured learnings from text (## Key Learnings, ## Decisions, etc.)").action(async (content) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    let text = content;
+    if (!text) {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      text = Buffer.concat(chunks).toString("utf8").trim();
+    }
+    if (!text) {
+      console.error("  \u2716 No content provided.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    const results = mem2.capturePassive(text);
+    if (results.length === 0) {
+      console.log(`  ${import_ui.dim}No structured sections found. Use ## Key Learnings, ## Observations, ## Decisions headings.${import_ui.reset}`);
+    } else {
+      console.log(`
+  ${(0, import_ui.section)("Passive Capture")} \u2014 ${results.length} observation(s)
+`);
+      for (const r of results) {
+        console.log(`  ${import_ui.violet}[${r.kind}]${import_ui.reset} ${r.content.slice(0, 100)}${r.id ? "" : ` ${import_ui.dim}(duplicate)${import_ui.reset}`}`);
+      }
+      console.log("");
+    }
+    cg.close();
+  });
+  mem.command("save-prompt [content]").description("Save the current user prompt to session memory").action(async (content) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    let text = content;
+    if (!text) {
+      const chunks = [];
+      for await (const chunk of process.stdin) chunks.push(chunk);
+      text = Buffer.concat(chunks).toString("utf8").trim();
+    }
+    if (!text) {
+      console.error("  \u2716 No content provided.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    const id = await mem2.savePrompt(text);
+    console.log(`  \u2713 Prompt saved ${import_ui.dim}${id}${import_ui.reset}`);
+    cg.close();
+  });
+  const conflicts = mem.command("conflicts").description("Manage conflict relations between memory observations");
+  conflicts.command("list").description("List pending conflict relations").option("--limit <n>", "Max results", "20").option("--format <fmt>", "Output format: text, json", "text").action(async (opts) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    const pending = mem2.getPendingRelations(parseInt(opts.limit));
+    if (opts.format === "json") {
+      console.log(JSON.stringify(pending, null, 2));
+    } else if (pending.length === 0) {
+      console.log(`
+  ${import_ui.dim}No pending conflict relations.${import_ui.reset}
+`);
+    } else {
+      console.log(`
+  ${(0, import_ui.section)("Pending Relations")} \u2014 ${pending.length}
+`);
+      for (const r of pending) {
+        console.log(`  ${import_ui.violet}${r.relation}${import_ui.reset} [${import_ui.dim}${r.id}${import_ui.reset}]`);
+        console.log(`  A: ${r.observationA}`);
+        console.log(`  B: ${r.observationB}`);
+        if (r.reason) console.log(`  Reason: ${import_ui.dim}${r.reason}${import_ui.reset}`);
+        console.log("");
+      }
+    }
+    cg.close();
+  });
+  conflicts.command("scan").description("Scan recent observations for potential conflicts using FTS similarity").option("--limit <n>", "Max observations to scan", "50").option("--format <fmt>", "Output format: text, json", "text").action(async (opts) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    const candidates = mem2.scanConflicts(parseInt(opts.limit));
+    if (opts.format === "json") {
+      console.log(JSON.stringify(candidates.map((c) => ({ a: c.observationA.id, b: c.observationB.id, similarity: c.similarity })), null, 2));
+    } else if (candidates.length === 0) {
+      console.log(`
+  ${import_ui.dim}No potential conflicts found.${import_ui.reset}
+`);
+    } else {
+      console.log(`
+  ${(0, import_ui.section)("Conflict Scan")} \u2014 ${candidates.length} candidate(s)
+`);
+      for (const c of candidates) {
+        console.log(`  ${import_ui.violet}\u2194${import_ui.reset} [${c.observationA.kind}] "${c.observationA.content.slice(0, 80)}"`);
+        console.log(`     [${c.observationB.kind}] "${c.observationB.content.slice(0, 80)}"`);
+        console.log(`  ${import_ui.dim}Similarity: ${c.similarity.toFixed(2)} \xB7 Use 'kirograph mem compare' to establish a relation${import_ui.reset}
+`);
+      }
+    }
+    cg.close();
+  });
+  conflicts.command("compare <observationA> <observationB>").description("Establish a typed relation between two observations (IDs or topic_keys)").requiredOption("--relation <type>", "Relation: supersedes, conflicts_with, compatible, scoped, related, not_conflict").option("--confidence <n>", "Confidence 0.0\u20131.0", "1.0").option("--reason <text>", "Explanation").option("--evidence <text>", "Supporting evidence").action(async (observationA, observationB, opts) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    const id = mem2.compareObservations({
+      observationA,
+      observationB,
+      relation: opts.relation,
+      confidence: parseFloat(opts.confidence),
+      reason: opts.reason,
+      evidence: opts.evidence
+    });
+    console.log(`  \u2713 Relation ${import_ui.dim}${id}${import_ui.reset} created: ${import_ui.violet}${opts.relation}${import_ui.reset} (confidence: ${opts.confidence})`);
+    cg.close();
+  });
+  conflicts.command("judge <relationId>").description("Finalize a pending relation").requiredOption("--relation <type>", "Final relation type").requiredOption("--confidence <n>", "Final confidence 0.0\u20131.0").option("--reason <text>", "Reasoning").option("--evidence <text>", "Evidence").action(async (relationId, opts) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    mem2.judgeRelation(relationId, opts.relation, parseFloat(opts.confidence), opts.reason, opts.evidence);
+    console.log(`  \u2713 Relation ${import_ui.dim}${relationId}${import_ui.reset} judged as ${import_ui.violet}${opts.relation}${import_ui.reset} (confidence: ${opts.confidence})`);
+    cg.close();
+  });
+  conflicts.command("ignore <relationId>").description("Ignore a pending relation (mark as not relevant)").action(async (relationId) => {
+    const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));
+    const { loadConfig } = await Promise.resolve().then(() => require("../../config.js"));
+    const KiroGraph = (await Promise.resolve().then(() => require("../../index.js"))).default;
+    const cwd = process.cwd();
+    if (!KiroGraph.isInitialized(cwd)) {
+      console.error("  \u2716 Not initialized.");
+      process.exit(1);
+    }
+    const config = await loadConfig(cwd);
+    if (!config.enableMemory) {
+      console.error("  \u2716 Memory not enabled.");
+      process.exit(1);
+    }
+    const cg = await KiroGraph.open(cwd);
+    const db = cg.getDatabase();
+    db.applyMemorySchema();
+    const mem2 = new MemoryManager(config, db.getRawDb());
+    mem2.initialize();
+    mem2.ignoreRelation(relationId);
+    console.log(`  \u2713 Relation ${import_ui.dim}${relationId}${import_ui.reset} ignored`);
+    cg.close();
+  });
   const watchmen = mem.command("watchmen").description("Watchmen \u2014 workspace brief synthesis from memory observations (requires enableWatchmen: true)");
   watchmen.command("status").description("Show pending observation count and which files would be written on next synthesis").action(async () => {
     const { MemoryManager } = await Promise.resolve().then(() => require("../../memory/index.js"));