kirograph 0.27.1 → 0.27.2

package/dist/mcp/tools.js

@@ -101,21 +101,27 @@ const tools = [
           enum: ["function", "method", "class", "interface", "type_alias", "variable", "route", "component"]
         },
         limit: { type: "number", description: "Max results 1-100 (default: 10)", default: 10 },
-        projectPath: { type: "string", description: "Project root path (optional, defaults to current project)" }
+        projectPath: { type: "string" }
       },
       required: ["query"]
     }
   },
   {
     name: "kirograph_context",
-    description: "PRIMARY TOOL: Build comprehensive context for a task or feature request. Returns entry points, related symbols, and key code \u2014 often enough to understand the codebase without additional tool calls.",
+    description: "Build comprehensive context for a task or feature request.",
     inputSchema: {
       type: "object",
       properties: {
-        task: { type: "string", description: "Description of the task, bug, or feature to build context for" },
-        maxNodes: { type: "number", description: "Max symbols to include (default: 20)", default: 20 },
-        includeCode: { type: "boolean", description: "Include code snippets (default: true)", default: true },
-        projectPath: { type: "string", description: "Project root path (optional, defaults to current project)" }
+        task: { type: "string", description: "Task description or feature name" },
+        maxNodes: { type: "number", description: "Max symbols to include", default: 20 },
+        includeCode: { type: "boolean", description: "Include code snippets. Deprecated \u2014 prefer detail.", default: true },
+        detail: {
+          type: "string",
+          description: "Code verbosity: full, signatures, or summary",
+          enum: ["full", "signatures", "summary"],
+          default: "full"
+        },
+        projectPath: { type: "string" }
       },
       required: ["task"]
     }
@@ -128,7 +134,7 @@ const tools = [
       properties: {
         symbol: { type: "string", description: "Symbol name to find callers for" },
         limit: { type: "number", description: "Max results 1-100 (default: 20)", default: 20 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["symbol"]
     }
@@ -141,33 +147,39 @@ const tools = [
       properties: {
         symbol: { type: "string", description: "Symbol name to find callees for" },
         limit: { type: "number", description: "Max results 1-100 (default: 20)", default: 20 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["symbol"]
     }
   },
   {
     name: "kirograph_impact",
-    description: "Analyze what code would be affected by changing a symbol. Use before making changes.",
+    description: "Analyze what code would be affected by changing a symbol.",
     inputSchema: {
       type: "object",
       properties: {
         symbol: { type: "string", description: "Symbol name to analyze impact for" },
         depth: { type: "number", description: "Traversal depth (default: 2)", default: 2 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["symbol"]
     }
   },
   {
     name: "kirograph_node",
-    description: "Get details about a specific symbol, optionally including its source code.",
+    description: "Get details about a specific symbol.",
     inputSchema: {
       type: "object",
       properties: {
         symbol: { type: "string", description: "Symbol name to look up" },
-        includeCode: { type: "boolean", description: "Include source code (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        includeCode: { type: "boolean", description: "Include full source code. Deprecated \u2014 prefer detail.", default: false },
+        detail: {
+          type: "string",
+          description: "Output level: summary, signatures, or full",
+          enum: ["summary", "signatures", "full"],
+          default: "summary"
+        },
+        projectPath: { type: "string" }
       },
       required: ["symbol"]
     }
@@ -178,27 +190,27 @@ const tools = [
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_files",
-    description: "List the indexed file structure of the project. Supports filtering by path prefix, glob pattern, or depth.",
+    description: "List indexed file structure with optional filtering.",
     inputSchema: {
       type: "object",
       properties: {
         filterPath: { type: "string", description: 'Filter by directory path prefix (e.g., "src/")' },
         pattern: { type: "string", description: 'Filter by glob pattern (e.g., "**/*.ts")' },
-        maxDepth: { type: "number", description: "Limit tree depth" },
+        maxDepth: { type: "number", description: "Max directory depth to traverse" },
         format: {
           type: "string",
           description: 'Output format: "tree" (default, visual tree), "flat" (one path per line), "grouped" (grouped by directory), "compact" (rtk-style summary with counts)',
           enum: ["tree", "flat", "grouped", "compact"],
           default: "tree"
         },
-        includeMetadata: { type: "boolean", description: "Include language and symbol count (default: true)", default: true },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        includeMetadata: { type: "boolean", description: "Include language and symbol count", default: true },
+        projectPath: { type: "string" }
       }
     }
   },
@@ -209,7 +221,7 @@ const tools = [
       type: "object",
       properties: {
         limit: { type: "number", description: "Max results 1-100 (default: 50)", default: 50 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
@@ -219,7 +231,7 @@ const tools = [
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
@@ -231,54 +243,54 @@ const tools = [
       properties: {
         from: { type: "string", description: "Source symbol name" },
         to: { type: "string", description: "Target symbol name" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["from", "to"]
     }
   },
   {
     name: "kirograph_architecture",
-    description: "Get the high-level software architecture: packages, layers, and their dependencies. Requires enableArchitecture=true in config. Call this first on a new task to orient yourself without reading files.",
+    description: "Show high-level architecture: packages, layers, dependencies.",
     inputSchema: {
       type: "object",
       properties: {
         level: {
           type: "string",
-          description: 'View level: "packages" (package graph), "layers" (architectural layers), or "both" (default)',
+          description: "packages, layers, or both",
           enum: ["packages", "layers", "both"],
           default: "both"
         },
-        includeFiles: { type: "boolean", description: "Include per-file package/layer assignments (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        includeFiles: { type: "boolean", description: "Include per-file package/layer assignments", default: false },
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_coupling",
-    description: "Show coupling metrics for packages: afferent (Ca), efferent (Ce), and instability (Ce/(Ca+Ce)). High instability = depends on many others; low instability = depended on by many. Requires enableArchitecture=true.",
+    description: "Package coupling metrics: Ca, Ce, and instability (Ce/(Ca+Ce)).",
     inputSchema: {
       type: "object",
       properties: {
         sortBy: {
           type: "string",
-          description: 'Sort order: "instability" (default), "afferent", or "efferent"',
+          description: "Sort by instability, ca, ce, or name",
           enum: ["instability", "afferent", "efferent"],
           default: "instability"
         },
         limit: { type: "number", description: "Max results (default: 20)", default: 20 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_package",
-    description: "Drill into one package: files it contains, symbols it exports, packages it depends on, and packages that depend on it. Requires enableArchitecture=true.",
+    description: "Drill into a package: files, exports, and dependencies.",
     inputSchema: {
       type: "object",
       properties: {
         package: { type: "string", description: "Package name or path (partial match accepted)" },
         includeFiles: { type: "boolean", description: "List files in the package (default: true)", default: true },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["package"]
     }
@@ -290,7 +302,7 @@ const tools = [
       type: "object",
       properties: {
         limit: { type: "number", description: "Max results 1-100 (default: 20)", default: 20 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
@@ -301,78 +313,99 @@ const tools = [
       type: "object",
       properties: {
         limit: { type: "number", description: "Max results 1-100 (default: 20)", default: 20 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_diff",
-    description: "Compare the current graph against a saved snapshot. Shows added/removed symbols and relationships since the snapshot was taken. Use `kirograph snapshot` CLI command to save a snapshot first.",
+    description: "Compare current graph against a saved snapshot.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        snapshot: { type: "string", description: "Snapshot label; omit for latest" },
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_snapshot_save",
+    description: "Save a snapshot of the current graph state. Snapshots can be compared with kirograph_diff to track structural changes over time.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        label: { type: "string", description: "Label for the snapshot (default: timestamp-based label)" },
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_snapshot_list",
+    description: "List all saved graph snapshots with their labels, timestamps, and symbol/edge counts.",
     inputSchema: {
       type: "object",
       properties: {
-        snapshot: { type: "string", description: "Snapshot label to compare against. Omit to use the latest saved snapshot." },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_type_hierarchy",
-    description: "Traverse the type hierarchy of a class or interface (base types and derived types).",
+    description: "Traverse base and derived types of a class or interface.",
     inputSchema: {
       type: "object",
       properties: {
         symbol: { type: "string", description: "Class or interface name" },
         direction: {
           type: "string",
-          description: 'Direction: "up" for base types, "down" for derived types, "both" for all (default)',
+          description: "up=base, down=derived, both=all",
           enum: ["up", "down", "both"],
           default: "both"
         },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["symbol"]
     }
   },
   {
     name: "kirograph_exec",
-    description: "Run a shell command and return token-optimized output. Automatically filters noise from git, test runners, linters, build tools, docker, and package managers. Use instead of raw shell for 60-90% token savings on verbose commands.",
+    description: "Run a shell command with token-optimized, noise-filtered output.",
     inputSchema: {
       type: "object",
       properties: {
-        command: { type: "string", description: 'Shell command to execute (e.g., "git status", "npm test", "cargo build")' },
-        cwd: { type: "string", description: "Working directory (default: project root)" },
+        command: { type: "string", description: "Shell command to execute" },
+        cwd: { type: "string", description: "Working directory" },
         level: {
           type: "string",
           description: 'Compression level: "normal" (balanced), "aggressive" (more compact), "ultra" (maximum compression)',
           enum: ["normal", "aggressive", "ultra"],
           default: "normal"
         },
-        timeout: { type: "number", description: "Timeout in seconds (default: 60)", default: 60 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        timeout: { type: "number", description: "Timeout in seconds", default: 60 },
+        projectPath: { type: "string" }
       },
       required: ["command"]
     }
   },
   {
     name: "kirograph_gain",
-    description: "Show token savings statistics \u2014 both from graph tools (vs manual file reads/grep) and from kirograph_exec shell compression.",
+    description: "Show token savings from graph tools and shell compression.",
     inputSchema: {
       type: "object",
       properties: {
         period: {
           type: "string",
-          description: 'Time period: "session" (current), "today", "week", or "all"',
+          description: "Time window: session, hour, day, week, all",
           enum: ["session", "today", "week", "all"],
           default: "session"
         },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_read",
-    description: 'Read a file with caching and multiple modes. First read returns full content; subsequent reads of unchanged files return a compact "cached" marker (~13 tokens). Supports modes: full, map, signatures, diff, lines, imports, exports.',
+    description: "Read a file with caching; unchanged files return cache marker.",
     inputSchema: {
       type: "object",
       properties: {
@@ -385,58 +418,88 @@ const tools = [
         },
         start: { type: "number", description: "Start line (for lines mode)" },
         end: { type: "number", description: "End line (for lines mode)" },
-        noCache: { type: "boolean", description: "Force fresh read, bypass cache (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        noCache: { type: "boolean", description: "Force fresh read, bypass cache", default: false },
+        projectPath: { type: "string" }
       },
       required: ["path"]
     }
   },
+  {
+    name: "kirograph_retrieve",
+    description: 'Retrieve cached file content by path (CCR \u2014 Cached Content Retrieval). Returns the full content stored in the session cache, or reads and caches the file if not yet seen. Use after kirograph_read returns a "[cached: file unchanged]" marker to get the actual content without a redundant filesystem read.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "File path to retrieve (absolute or relative to project root)" },
+        projectPath: { type: "string" }
+      },
+      required: ["path"]
+    }
+  },
+  {
+    name: "kirograph_compress",
+    description: "Compress text via rtk shell filters or caveman grammar engine.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "Text to compress" },
+        command: { type: "string", description: "Shell command text came from (selects rtk engine)" },
+        level: {
+          type: "string",
+          description: 'Compression intensity: "lite" / "normal" (light), "full" / "aggressive" (default), "ultra" (maximum)',
+          enum: ["lite", "normal", "full", "aggressive", "ultra"],
+          default: "full"
+        }
+      },
+      required: ["text"]
+    }
+  },
   {
     name: "kirograph_budget",
-    description: "Show current session context budget usage. Returns tokens consumed, remaining budget, and utilization percentage.",
+    description: "Show session context budget: tokens used, remaining, utilization.",
     inputSchema: {
       type: "object",
       properties: {
-        reset: { type: "boolean", description: "Reset session budget counters (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        reset: { type: "boolean", description: "Reset session budget counters", default: false },
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_flows",
-    description: "Trace execution flows from entry points (routes, handlers, main functions) through the call graph. Returns ordered call chains sorted by criticality.",
+    description: "Trace execution flows from entry points through the call graph.",
     inputSchema: {
       type: "object",
       properties: {
-        entryPoint: { type: "string", description: "Symbol name to trace from, or omit to auto-detect entry points" },
+        entryPoint: { type: "string", description: "Symbol to trace; omit to auto-detect" },
         maxFlows: { type: "number", description: "Max number of flows to return (default 10)" },
         maxDepth: { type: "number", description: "Max call chain depth (default 10)" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_communities",
-    description: "Detect code communities (clusters of related symbols) using graph-based community detection. Shows which code belongs together and how communities are coupled.",
+    description: "Detect clusters of related symbols via graph community detection.",
     inputSchema: {
       type: "object",
       properties: {
-        resolution: { type: "number", description: "Resolution parameter (default 1.0, higher = more communities)" },
+        resolution: { type: "number", description: "Granularity 0.1\u20132.0; higher=more smaller clusters" },
         limit: { type: "number", description: "Max communities to return (default 15)" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_refactor",
-    description: 'Refactoring assistant. Use mode "rename" to preview all locations that reference a symbol (rename preview). Use mode "suggest" for community-driven refactoring suggestions.',
+    description: "Rename preview (all references) or function summarization.",
     inputSchema: {
       type: "object",
       properties: {
-        mode: { type: "string", description: 'Mode: "rename" (preview references) or "suggest" (refactoring suggestions)', enum: ["rename", "suggest"] },
+        mode: { type: "string", description: "rename=preview references, summarize=summary", enum: ["rename", "suggest"] },
         symbol: { type: "string", description: "Symbol name (required for rename mode)" },
         limit: { type: "number", description: "Max results (default 10)" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["mode"]
     }
@@ -444,7 +507,7 @@ const tools = [
   // ── Memory tools (require enableMemory=true) ────────────────────────────────
   {
     name: "kirograph_mem_search",
-    description: "Search project memory for past decisions, errors, patterns, and context. Returns observations ranked by relevance.",
+    description: "Search project memory for decisions, errors, patterns, context.",
     inputSchema: {
       type: "object",
       properties: {
@@ -457,14 +520,14 @@ const tools = [
         limit: { type: "number", description: "Max results (default: 10)", default: 10 },
         sessionId: { type: "string", description: "Filter to specific session" },
         asOf: { type: "number", description: "Query facts valid at this timestamp (epoch ms). Filters out expired/superseded observations." },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["query"]
     }
   },
   {
     name: "kirograph_mem_store",
-    description: "Store an observation in project memory. Content is automatically compressed (if caveman mode is on) and linked to relevant code symbols.",
+    description: "Store an observation in project memory.",
     inputSchema: {
       type: "object",
       properties: {
@@ -475,9 +538,9 @@ const tools = [
           enum: ["decision", "error", "pattern", "architecture", "summary", "note"],
           default: "note"
         },
-        projectPath: { type: "string", description: "Project root path (optional)" },
+        projectPath: { type: "string" },
         topicKey: { type: "string", description: "Stable semantic key for this observation (e.g. 'architecture/auth-model'). Enables addressing by concept." },
-        reviewAfter: { type: "number", description: "Epoch ms: schedule this observation for re-evaluation after this timestamp." }
+        reviewAfter: { type: "number", description: "ISO date to flag for review" }
       },
       required: ["content"]
     }
@@ -488,42 +551,42 @@ const tools = [
     inputSchema: {
       type: "object",
       properties: {
-        limit: { type: "number", description: "Number of sessions to show (default: 5)", default: 5 },
+        limit: { type: "number", description: "Number of sessions to show", default: 5 },
         sessionId: { type: "string", description: "Show observations for a specific session" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_mem_status",
-    description: "Memory subsystem health: session count, observations, embedding coverage, storage size.",
+    description: "Memory subsystem health: sessions, observations, embeddings, size.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   // ── Engram-parity mem tools ──────────────────────────────────────────────────
   {
     name: "kirograph_mem_review",
-    description: "List observations past their review_after date \u2014 stale facts the agent should re-evaluate, update, or supersede.",
+    description: "List observations past their review_after date.",
     inputSchema: {
       type: "object",
       properties: {
         limit: { type: "number", description: "Max results (default: 20)", default: 20 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_mem_mark_reviewed",
-    description: "Mark an observation as reviewed \u2014 clears its review_after date.",
+    description: "Clear review_after date on an observation.",
     inputSchema: {
       type: "object",
       properties: {
         id: { type: "string", description: "Observation ID" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["id"]
     }
@@ -538,9 +601,9 @@ const tools = [
         observationB: { type: "string", description: "Second observation ID or topic_key" },
         relation: { type: "string", enum: ["supersedes", "conflicts_with", "compatible", "scoped", "related", "not_conflict"], description: "Relation type" },
         confidence: { type: "number", description: "Confidence 0.0\u20131.0 (default: 1.0)" },
-        reason: { type: "string", description: "Explanation for the relation" },
+        reason: { type: "string", description: "Explanation of the relation" },
         evidence: { type: "string", description: "Supporting evidence text" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["observationA", "observationB", "relation"]
     }
@@ -554,218 +617,303 @@ const tools = [
         relationId: { type: "string", description: "Relation ID (from kirograph_mem_compare or kirograph_mem_search)" },
         relation: { type: "string", enum: ["supersedes", "conflicts_with", "compatible", "scoped", "related", "not_conflict"], description: "Final relation type" },
         confidence: { type: "number", description: "Final confidence 0.0\u20131.0" },
-        reason: { type: "string", description: "Reasoning for judgment" },
+        reason: { type: "string", description: "Reasoning" },
         evidence: { type: "string", description: "Supporting evidence" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["relationId", "relation", "confidence"]
     }
   },
   {
     name: "kirograph_mem_capture",
-    description: "Extract and store structured learnings from a freeform text block. Looks for ## Key Learnings, ## Observations, ## Decisions, ## Key Changes sections and saves each bullet as a separate observation.",
+    description: "Extract and store structured learnings from freeform text.",
     inputSchema: {
       type: "object",
       properties: {
         content: { type: "string", description: "Text block with structured sections" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["content"]
     }
   },
   {
     name: "kirograph_mem_save_prompt",
-    description: "Save the current user prompt to session memory for context reconstruction.",
+    description: "Save the current user prompt to session memory.",
     inputSchema: {
       type: "object",
       properties: {
-        content: { type: "string", description: "Prompt content to save" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        content: { type: "string", description: "The user prompt text to save" },
+        projectPath: { type: "string" }
       },
       required: ["content"]
     }
   },
   {
     name: "kirograph_mem_suggest_topic_key",
-    description: 'Suggest a stable topic_key for an observation based on its kind and content. Returns a deterministic slug like "architecture/auth-model".',
+    description: "Suggest a stable topic_key slug for an observation.",
     inputSchema: {
       type: "object",
       properties: {
         kind: { type: "string", enum: ["decision", "error", "pattern", "architecture", "summary", "note"], description: "Observation kind" },
-        title: { type: "string", description: "Short title or first sentence of the observation" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        title: { type: "string", description: "Short description of the observation" },
+        projectPath: { type: "string" }
       },
       required: ["kind", "title"]
     }
   },
   {
     name: "kirograph_mem_conflicts_scan",
-    description: "Scan recent observations for potential conflicts using FTS similarity. Returns candidate pairs that may need a relation established via kirograph_mem_compare.",
+    description: "Scan recent observations for potential conflicts using FTS.",
     inputSchema: {
       type: "object",
       properties: {
         limit: { type: "number", description: "Max observations to scan (default: 50)", default: 50 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_mem_prune",
+    description: "Remove memory observations older than a given duration.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        olderThan: { type: "string", description: 'Duration threshold e.g. "90d" or "6m"', default: "90d" },
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_mem_lint",
+    description: "Health check: stale links, model mismatch, orphaned sessions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        fix: { type: "boolean", description: "Auto-remove stale links", default: false },
+        projectPath: { type: "string" }
       }
     }
   },
+  {
+    name: "kirograph_mem_conflicts_list",
+    description: "List pending conflict relations needing resolution.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Max results (default: 20)", default: 20 },
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_mem_conflicts_ignore",
+    description: "Dismiss a pending conflict relation as not relevant.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        relationId: { type: "string", description: "Relation ID to ignore (from kirograph_mem_conflicts_list)" },
+        projectPath: { type: "string" }
+      },
+      required: ["relationId"]
+    }
+  },
   // ── Wiki tools (require enableWiki=true) ────────────────────────────────────
   {
     name: "kirograph_wiki_ingest",
-    description: "Returns an ingest prompt (SCHEMA + MANIFEST + source content) for the LLM to produce a WIKI_DIFF. Call kirograph_wiki_apply_diff with the result.",
+    description: "Build ingest prompt for LLM to produce a WIKI_DIFF.",
     inputSchema: {
       type: "object",
       properties: {
         source: { type: "string", description: "Source content to ingest (markdown, notes, ADR text, etc.)" },
-        sourceName: { type: "string", description: 'Name or path of the source (e.g. "ADR-001.md")', default: "source" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        sourceName: { type: "string", description: "Name or path of the source", default: "source" },
+        projectPath: { type: "string" }
       },
       required: ["source"]
     }
   },
   {
     name: "kirograph_wiki_apply_diff",
-    description: "Apply a WIKI_DIFF string (produced by the LLM after kirograph_wiki_ingest) to the wiki filesystem and SQLite index.",
+    description: "Apply a WIKI_DIFF to the wiki filesystem and SQLite index.",
     inputSchema: {
       type: "object",
       properties: {
         diff: { type: "string", description: "WIKI_DIFF string with WIKI_DIFF_START/END blocks" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["diff"]
     }
   },
   {
     name: "kirograph_wiki_search",
-    description: "Full-text search over wiki pages. Returns page slugs, titles, and previews ranked by relevance.",
+    description: "FTS over wiki pages; returns slugs, titles, previews.",
     inputSchema: {
       type: "object",
       properties: {
         query: { type: "string", description: "Search query" },
         limit: { type: "number", description: "Max results (default: 5)", default: 5 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["query"]
     }
   },
   {
     name: "kirograph_wiki_page",
-    description: "Retrieve the full markdown content of a wiki page by slug.",
+    description: "Retrieve full markdown of a wiki page by slug.",
     inputSchema: {
       type: "object",
       properties: {
-        slug: { type: "string", description: 'Page slug (e.g. "AuthService", "arch/auth-model")' },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        slug: { type: "string", description: 'Page slug (e.g. "arch/auth-model")' },
+        projectPath: { type: "string" }
       },
       required: ["slug"]
     }
   },
   {
     name: "kirograph_wiki_lint",
-    description: "Health check the wiki for broken links, orphan pages, stale sources, and potential contradictions between pages.",
+    description: "Check wiki for broken links, orphans, stale sources, contradictions.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_wiki_list",
-    description: "List all wiki pages with slug, title, source count, and last updated date.",
+    description: "List all wiki pages with slug, title, source count, date.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_wiki_synthesize",
+    description: 'Run local-model wiki synthesis: process the pending source queue (requires wikiSynthesisMode: "local").',
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_wiki_init",
+    description: "Initialize the wiki: create SCHEMA.md and MANIFEST.md in .kirograph/wiki/.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_wiki_reindex",
+    description: "Rebuild the SQLite index from .kirograph/wiki/*.md files on disk.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_wiki_status",
+    description: "Show wiki subsystem stats: page count, total sources, oldest/newest page dates.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string" }
       }
     }
   },
   // ── Docs tools (require enableDocs=true) ────────────────────────────────────
   {
     name: "kirograph_docs_toc",
-    description: "Get table of contents for a documentation file or the whole project. Returns section IDs, titles, levels, and summaries.",
+    description: "Get TOC for a doc file or whole project (IDs, titles, levels, summaries).",
     inputSchema: {
       type: "object",
       properties: {
         file: { type: "string", description: "Filter to a specific doc file (relative path). Omit for project-wide TOC." },
-        tree: { type: "boolean", description: "Return nested tree structure (default: false, flat list)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        tree: { type: "boolean", description: "Return nested tree structure.", default: false },
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_docs_search",
-    description: "Search documentation sections by query. Returns matching sections ranked by relevance. Independent from kirograph_search (code-only).",
+    description: "Search documentation sections by query, ranked by relevance.",
     inputSchema: {
       type: "object",
       properties: {
         query: { type: "string", description: "Search query (natural language or keywords)" },
-        file: { type: "string", description: "Narrow search to a specific doc file (relative path)" },
+        file: { type: "string", description: "Limit search to a specific doc file." },
         limit: { type: "number", description: "Max results (default: 10)", default: 10 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["query"]
     }
   },
   {
     name: "kirograph_docs_section",
-    description: "Retrieve full content of a documentation section by its stable ID. Use context=true to also get ancestor headings and child summaries.",
+    description: "Retrieve full content of a doc section by its stable ID.",
     inputSchema: {
       type: "object",
       properties: {
-        id: { type: "string", description: "Section ID (from kirograph_docs_toc or kirograph_docs_search results)" },
-        context: { type: "boolean", description: "Include ancestor heading chain and child summaries (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        id: { type: "string", description: "Section ID." },
+        context: { type: "boolean", description: "Include ancestor headings and child summaries.", default: false },
+        projectPath: { type: "string" }
       },
       required: ["id"]
     }
   },
   {
     name: "kirograph_docs_outline",
-    description: "Get the heading hierarchy for a single documentation file. Lighter than full TOC when you know which file is relevant.",
+    description: "Get heading hierarchy for a single documentation file.",
     inputSchema: {
       type: "object",
       properties: {
-        file: { type: "string", description: "Relative path to the doc file" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        file: { type: "string", description: "Documentation file path (relative to project root)." },
+        projectPath: { type: "string" }
       },
       required: ["file"]
     }
   },
   {
     name: "kirograph_docs_refs",
-    description: "Find code symbols referenced by a doc section, or doc sections that reference a code symbol. Bidirectional lookup.",
+    description: "Bidirectional lookup: doc section\u2194code symbol references.",
     inputSchema: {
       type: "object",
       properties: {
-        sectionId: { type: "string", description: "Doc section ID (find code symbols it references)" },
-        nodeId: { type: "string", description: "Code symbol qualified name (find doc sections that reference it)" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        sectionId: { type: "string", description: "Doc section ID to find referenced symbols." },
+        nodeId: { type: "string", description: "Code symbol ID to find referencing doc sections." },
+        projectPath: { type: "string" }
       }
     }
   },
   // ── Data tools (require enableData=true) ────────────────────────────────────
   {
     name: "kirograph_data_list",
-    description: "List all indexed datasets with row counts, column counts, and file sizes.",
-    inputSchema: { type: "object", properties: { projectPath: { type: "string", description: "Project root path (optional)" } } }
+    description: "List all indexed datasets with row/column counts and file sizes.",
+    inputSchema: { type: "object", properties: { projectPath: { type: "string" } } }
   },
   {
     name: "kirograph_data_describe",
-    description: "Full schema profile of a dataset: column names, types, cardinality, null%, sample values. Use to orient on a dataset without reading any rows.",
+    description: "Full schema profile: types, cardinality, null%, sample values.",
     inputSchema: {
       type: "object",
       properties: {
         dataset: { type: "string", description: "Dataset ID (from kirograph_data_list)" },
-        column: { type: "string", description: "Optional: deep-dive on a single column" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        column: { type: "string", description: "Deep-dive on a single column." },
+        projectPath: { type: "string" }
       },
       required: ["dataset"]
     }
   },
   {
     name: "kirograph_data_query",
-    description: "Filtered row retrieval with structured operators. Returns only matching rows (max 500). Use instead of reading raw data files.",
+    description: "Filtered row retrieval with structured operators (max 500 rows).",
     inputSchema: {
       type: "object",
       properties: {
@@ -774,14 +922,14 @@ const tools = [
         columns: { type: "array", description: "Column projection (only return these columns)" },
         limit: { type: "number", description: "Max rows (default: 100, hard cap: 500)", default: 100 },
         offset: { type: "number", description: "Pagination offset", default: 0 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["dataset"]
     }
   },
   {
     name: "kirograph_data_aggregate",
-    description: "Server-side GROUP BY aggregation. Computation runs in SQLite \u2014 only the result set enters context. Use for count, sum, avg, min, max questions.",
+    description: "Server-side GROUP BY aggregation: count, sum, avg, min, max.",
     inputSchema: {
       type: "object",
       properties: {
@@ -789,27 +937,27 @@ const tools = [
         groupBy: { type: "array", description: "Columns to group by" },
         metrics: { type: "array", description: "Array of {column, op} metrics. Ops: count, sum, avg, min, max, count_distinct" },
         filters: { type: "array", description: "Optional pre-filters (same format as kirograph_data_query)" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["dataset", "groupBy", "metrics"]
     }
   },
   {
     name: "kirograph_data_search",
-    description: "Search column names and sample values by keyword. Tells you which column holds the answer without loading data.",
+    description: "Search column names and sample values by keyword.",
     inputSchema: {
       type: "object",
       properties: {
         dataset: { type: "string", description: "Dataset ID" },
         query: { type: "string", description: "Search keyword" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["dataset", "query"]
     }
   },
   {
     name: "kirograph_data_join",
-    description: "SQL JOIN across two indexed datasets. Combines data without loading either file into context.",
+    description: "SQL JOIN across two indexed datasets.",
     inputSchema: {
       type: "object",
       properties: {
@@ -820,50 +968,126 @@ const tools = [
         type: { type: "string", description: "Join type: inner (default), left, right", enum: ["inner", "left", "right"], default: "inner" },
         columns: { type: "array", description: "Column projection (prefix with dataset ID)" },
         limit: { type: "number", description: "Max rows (default: 100, hard cap: 500)", default: 100 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["left", "right", "leftColumn", "rightColumn"]
     }
   },
   {
     name: "kirograph_data_correlations",
-    description: "Pairwise Pearson correlations between numeric columns. Discovers hidden relationships without loading data.",
+    description: "Pairwise Pearson correlations between numeric columns.",
     inputSchema: {
       type: "object",
       properties: {
         dataset: { type: "string", description: "Dataset ID" },
         threshold: { type: "number", description: "Min absolute correlation to include (default: 0.3)", default: 0.3 },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["dataset"]
     }
   },
   {
     name: "kirograph_data_quality",
-    description: "Data quality triage: rank columns by risk (null rate, cardinality anomalies, type issues). Identifies problematic columns without loading data.",
+    description: "Rank columns by data quality risk: nulls, cardinality, type issues.",
     inputSchema: {
       type: "object",
       properties: {
         dataset: { type: "string", description: "Dataset ID" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["dataset"]
     }
   },
+  {
+    name: "kirograph_data_drift",
+    description: "Schema drift between last two index runs: columns, types, row counts.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dataset: { type: "string", description: "Dataset ID (from kirograph_data_list)" },
+        projectPath: { type: "string" }
+      },
+      required: ["dataset"]
+    }
+  },
+  {
+    name: "kirograph_data_history",
+    description: "History of schema snapshots: timestamps, row/column counts, hashes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        dataset: { type: "string", description: "Dataset ID (from kirograph_data_list)" },
+        limit: { type: "number", description: "Max snapshots to return (default: 10)", default: 10 },
+        projectPath: { type: "string" }
+      },
+      required: ["dataset"]
+    }
+  },
+  // ── Watchmen tools (require enableMemory=true + enableWatchmen=true) ──────────
+  {
+    name: "kirograph_watchmen_status",
+    description: "Show watchmen status: pending observation count, synthesis threshold, and which brief files would be written on next synthesis.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_watchmen_synthesize",
+    description: 'Run watchmen synthesis immediately using the local model (requires watchmenSynthesisMode: "local"). Processes pending observations into a workspace brief.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        force: { type: "boolean", description: "Run even if below threshold (default: false)", default: false },
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "kirograph_watchmen_reset",
+    description: "Reset the watchmen synthesis counter by storing a summary observation, without running full synthesis.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: { type: "string" }
+      }
+    }
+  },
+  // ── Affected tests ────────────────────────────────────────────────────────────
+  {
+    name: "kirograph_affected",
+    description: "Find test files affected by a set of changed source files, by traversing the dependency graph.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        files: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of changed source file paths (relative to project root)"
+        },
+        depth: { type: "number", description: "Max dependency traversal depth (default: 5)", default: 5 },
+        testPattern: { type: "string", description: "Custom glob to identify test files (optional)" },
+        projectPath: { type: "string" }
+      },
+      required: ["files"]
+    }
+  },
   // ── Security tools (require enableSecurity=true) ────────────────────────────
   {
     name: "kirograph_security",
-    description: "Security overview: vulnerability counts, affected/not_affected verdicts, stale data warnings. Requires enableSecurity=true and enableArchitecture=true.",
+    description: "Security overview: vuln counts, verdicts, stale data warnings.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_vulns",
-    description: "List vulnerabilities with reachability verdicts, severity, and affected components. Supports on-demand refresh.",
+    description: "List vulns with reachability verdicts, severity, affected components.",
     inputSchema: {
       type: "object",
       properties: {
@@ -871,13 +1095,13 @@ const tools = [
         verdict: { type: "string", description: "Filter by reachability verdict", enum: ["affected", "not_affected", "under_investigation"] },
         limit: { type: "number", description: "Max results (default: 20)", default: 20 },
         refresh: { type: "boolean", description: "Trigger fresh vulnerability enrichment before listing (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_vuln_add",
-    description: "Manually register a CVE against a dependency without querying external databases.",
+    description: "Manually register a CVE against a dependency.",
     inputSchema: {
       type: "object",
       properties: {
@@ -886,178 +1110,178 @@ const tools = [
         severity: { type: "number", description: "CVSS v3.1 base score (optional)" },
         summary: { type: "string", description: "Vulnerability summary (optional)" },
         fixedVersion: { type: "string", description: "Version that fixes the vulnerability (optional)" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["cveId", "package"]
     }
   },
   {
     name: "kirograph_vuln_suppress",
-    description: "Suppress a CVE so it no longer appears in vulnerability reports (mark as false positive or accepted risk). Suppressions are stored in .kirograph/security-suppressions.json.",
+    description: "Suppress a CVE from vulnerability reports.",
     inputSchema: {
       type: "object",
       properties: {
         cveId: { type: "string", description: 'CVE identifier to suppress (e.g., "CVE-2024-1234")' },
         reason: { type: "string", description: "Reason for suppression (optional)" },
         expires: { type: "string", description: 'Expiry date in ISO format after which the suppression is removed (e.g. "2026-12-31", optional)' },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["cveId"]
     }
   },
   {
     name: "kirograph_sbom",
-    description: "Generate and return CycloneDX 1.5 SBOM JSON for the project.",
+    description: "Generate CycloneDX 1.5 SBOM JSON for the project.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_vex",
-    description: "Generate and return CycloneDX 1.5 VEX JSON with reachability verdicts.",
+    description: "Generate CycloneDX 1.5 VEX JSON with reachability verdicts.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_reachability",
-    description: "Check reachability for a specific dependency or vulnerability. Returns verdict, paths, and impact summary.",
+    description: "Check reachability for a dependency or CVE.",
     inputSchema: {
       type: "object",
       properties: {
         target: { type: "string", description: "Dependency name or CVE ID to check reachability for" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       },
       required: ["target"]
     }
   },
   {
     name: "kirograph_staleness",
-    description: "Check dependency freshness \u2014 identifies packages significantly behind their latest published version.",
+    description: "Check dependency freshness against latest published versions.",
     inputSchema: {
       type: "object",
       properties: {
         threshold: { type: "number", description: "Only return packages with staleness_score >= threshold (default: 0.3)", default: 0.3 },
         refresh: { type: "boolean", description: "Fetch latest version info from registries before listing (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_licenses",
-    description: "Show dependency licenses and check against the configured license policy (deny/warn lists). Supports wildcard patterns (e.g. GPL-* matches GPL-2.0, GPL-3.0-only).",
+    description: "Show licenses and check against configured deny/warn policy.",
     inputSchema: {
       type: "object",
       properties: {
         policy: { type: "boolean", description: "Return only policy violations (default: false)", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_attack_surface",
-    description: "Map the attack surface: all HTTP routes and their paths to vulnerable dependencies, with hop count, authentication status, and risk score.",
+    description: "Map HTTP routes to vulnerable deps with hop count and auth status.",
     inputSchema: {
       type: "object",
       properties: {
         limit: { type: "number", description: "Max routes to return (default: 20)", default: 20 },
         publicOnly: { type: "boolean", description: "Only return public/unauthenticated routes", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_secrets",
-    description: "Scan for hardcoded secrets and credentials, enriched with call-graph blast radius showing which entry points reach the secret.",
+    description: "Scan for hardcoded secrets with call-graph blast radius.",
     inputSchema: {
       type: "object",
       properties: {
         includeTests: { type: "boolean", description: "Include test files in scan", default: false },
         severity: { type: "string", description: "Filter by severity: critical, high, medium, low", enum: ["critical", "high", "medium", "low"] },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_security_flows",
-    description: "SAST-lite: detect dangerous data flows (SQL injection, dangerous eval, unsafe deserialization, path traversal, weak crypto). Each finding tagged with OWASP Top 10 category.",
+    description: "SAST-lite: detect SQL injection, eval, deserialize, path, crypto flows.",
     inputSchema: {
       type: "object",
       properties: {
         type: { type: "string", description: "Filter by type: sql, eval, deserialize, path, crypto, all", default: "all" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_supply_chain",
-    description: "Supply chain health: OpenSSF Scorecard scores, maintainer count, abandoned package detection for project dependencies.",
+    description: "OpenSSF Scorecard scores, maintainer count, abandoned package detection.",
     inputSchema: {
       type: "object",
       properties: {
         threshold: { type: "string", description: "Minimum risk level: critical, high, medium", enum: ["critical", "high", "medium"] },
         refresh: { type: "boolean", description: "Re-fetch from APIs", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_dep_confusion",
-    description: "Detect dependency confusion vulnerabilities: internal package names that exist in public registries (typosquatting/supply chain attack vectors).",
+    description: "Detect dependency confusion: internal names in public registries.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_remediation",
-    description: "Remediation SLA tracking: which vulnerabilities are overdue for fixing based on severity thresholds (critical=7d, high=30d, medium=90d).",
+    description: "Remediation SLA tracking: overdue vulns by severity thresholds.",
     inputSchema: {
       type: "object",
       properties: {
         overdueOnly: { type: "boolean", description: "Show only overdue items", default: false },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   // ── Pattern tools (require enablePatterns=true) ─────────────────────────────
   {
     name: "kirograph_pattern_coverage",
-    description: "OWASP Top 10 coverage report: shows which vulnerability categories are covered by bundled pattern rules and how many matches exist in each.",
+    description: "OWASP Top 10 coverage report: categories covered and match counts.",
     inputSchema: {
       type: "object",
       properties: {
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_pattern_save_baseline",
-    description: "Save current pattern match counts as a baseline for future diffing.",
+    description: "Save current pattern match counts as a baseline.",
     inputSchema: {
       type: "object",
       properties: {
         label: { type: "string", description: 'Baseline label (default: "default")', default: "default" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   },
   {
     name: "kirograph_pattern_diff",
-    description: "Diff current pattern matches against a saved baseline. Shows new findings, resolved findings, and unchanged counts.",
+    description: "Diff pattern matches against a saved baseline.",
     inputSchema: {
       type: "object",
       properties: {
         label: { type: "string", description: 'Baseline label (default: "default")', default: "default" },
-        projectPath: { type: "string", description: "Project root path (optional)" }
+        projectPath: { type: "string" }
       }
     }
   }
@@ -1072,7 +1296,7 @@ const LIVE_SEARCH_TOOL_DEFINITION = {
       pattern: { type: "string", description: 'ast-grep inline pattern (e.g. "eval($X)")' },
       language: { type: "string", description: "Language to search: javascript, typescript, python, go, rust, java, etc." },
       limit: { type: "number", description: "Max results (default 20, max 100)", default: 20 },
-      projectPath: { type: "string", description: "Project root path (optional)" }
+      projectPath: { type: "string" }
     }
   }
 };
@@ -1298,6 +1522,52 @@ ${result.content}`;
       }
       return result.content;
     }
+    if (toolName === "kirograph_retrieve") {
+      const filePath = args.path;
+      if (!filePath) return "Error: path is required.";
+      const projectRoot = args.projectPath || process.cwd();
+      const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(projectRoot, filePath);
+      const { getFileReadCache } = await Promise.resolve().then(() => require("./cache.js"));
+      const cache = getFileReadCache();
+      const cached = cache.getPreviousContent(resolvedPath);
+      if (cached !== void 0) {
+        return cached;
+      }
+      if (!fs.existsSync(resolvedPath)) {
+        return `Error: File not found: ${resolvedPath}`;
+      }
+      const result = cache.read(resolvedPath, true);
+      return result.content;
+    }
+    if (toolName === "kirograph_compress") {
+      const text = args.text;
+      if (!text) return "Error: text is required.";
+      const rawLevel = args.level ?? "full";
+      const command = args.command;
+      const { estimateTokens: est } = await Promise.resolve().then(() => require("../compression/index.js"));
+      const originalTokens = est(text);
+      let compressed;
+      let strategy;
+      if (command) {
+        const shellLevel = rawLevel === "ultra" ? "ultra" : rawLevel === "lite" || rawLevel === "normal" ? "normal" : "aggressive";
+        const { compress: compress2 } = await Promise.resolve().then(() => require("../compression/index.js"));
+        const result = compress2(command, text, { level: shellLevel });
+        compressed = result.output;
+        strategy = `rtk:${result.commandFamily}:${shellLevel}`;
+      } else {
+        const cavemanLevel = rawLevel === "normal" || rawLevel === "lite" ? "lite" : rawLevel === "aggressive" ? "full" : rawLevel;
+        const { compressObservation } = await Promise.resolve().then(() => require("../memory/compress.js"));
+        const result = compressObservation(text, cavemanLevel);
+        compressed = result.compressed;
+        strategy = `caveman:${cavemanLevel}`;
+      }
+      const compressedTokens = est(compressed);
+      const savings = originalTokens > 0 ? Math.round((originalTokens - compressedTokens) / originalTokens * 100) : 0;
+      const footer = savings > 5 ? `
+
+[${savings}% tokens saved | ${originalTokens}\u2192${compressedTokens} | ${strategy}]` : "";
+      return compressed + footer;
+    }
     if (toolName === "kirograph_budget") {
       const projectRoot = args.projectPath || process.cwd();
       const reset = args.reset ?? false;
@@ -1340,9 +1610,10 @@ ${result.content}`;
         ).join("\n\n");
       }
       case "kirograph_context": {
+        const detail = args.detail ?? (args.includeCode === false ? "summary" : "full");
         const ctx = await cg.buildContext(args.task, {
           maxNodes: args.maxNodes ?? 20,
-          includeCode: args.includeCode ?? true
+          includeCode: detail === "full"
         });
         const lines = [ctx.summary, ""];
         if (ctx.entryPoints.length === 0) {
@@ -1351,8 +1622,11 @@ ${result.content}`;
           lines.push("## Entry Points");
           for (const n of ctx.entryPoints) {
             lines.push(`- ${mapKind(n.kind)} \`${n.name}\` \u2014 ${n.filePath}:${n.startLine}`);
-            if (ctx.codeSnippets.has(n.id)) {
+            if (detail === "full" && ctx.codeSnippets.has(n.id)) {
               lines.push("```", ctx.codeSnippets.get(n.id), "```");
+            } else if (detail === "signatures") {
+              if (n.signature) lines.push(`  Signature: ${n.signature}`);
+              if (n.docstring) lines.push(`  Docs: ${n.docstring}`);
             }
           }
           if (ctx.relatedNodes.length > 0) {
@@ -1385,8 +1659,7 @@ ${result.content}`;
             if (memResults.length > 0) {
               lines.push("", "## Related Memory");
               for (const r of memResults.slice(0, contextLimit)) {
-                const age = formatAge(r.observation.createdAt);
-                lines.push(`- [${r.observation.kind}] ${r.observation.content} (${age})`);
+                lines.push(`- [${r.observation.kind}] ${r.observation.content}`);
               }
             }
           }
@@ -1624,14 +1897,17 @@ ${result.content}`;
         const results = cg.searchNodes(args.symbol, void 0, 5);
         if (results.length === 0) return `Symbol "${args.symbol}" not found in index.`;
         const node = results[0].node;
+        const nodeDetail = args.detail ?? (args.includeCode ? "full" : "summary");
         const lines = [
           `${mapKind(node.kind)} \`${node.name}\``,
           `File: ${node.filePath}:${node.startLine}-${node.endLine}`,
-          `Qualified: ${node.qualifiedName}`,
-          node.signature ? `Signature: ${node.signature}` : "",
-          node.docstring ? `Docs: ${node.docstring}` : ""
-        ].filter(Boolean);
-        if (args.includeCode) {
+          `Qualified: ${node.qualifiedName}`
+        ];
+        if (nodeDetail === "signatures" || nodeDetail === "full") {
+          if (node.signature) lines.push(`Signature: ${node.signature}`);
+          if (node.docstring) lines.push(`Docs: ${node.docstring}`);
+        }
+        if (nodeDetail === "full") {
           const src = cg.getNodeSource(node);
           if (src) lines.push("", "```", src, "```");
         }
@@ -2073,6 +2349,23 @@ ${result.content}`;
         }
         return lines.join("\n");
       }
+      case "kirograph_snapshot_save": {
+        const sm = cg.createSnapshotManager();
+        const snapshot = sm.save(args.label);
+        return `Snapshot saved: "${snapshot.label}" \u2014 ${snapshot.nodeCount} symbols, ${snapshot.edgeCount} edges`;
+      }
+      case "kirograph_snapshot_list": {
+        const sm = cg.createSnapshotManager();
+        const snapshots = sm.list();
+        if (snapshots.length === 0) return "No snapshots yet. Use kirograph_snapshot_save to save one first.";
+        const lines = [`Saved snapshots (${snapshots.length}):
+`];
+        for (const s of snapshots) {
+          const date = new Date(s.timestamp).toISOString().slice(0, 19).replace("T", " ");
+          lines.push(`- ${s.label}  (${date}, ${s.nodeCount} symbols, ${s.edgeCount} edges)`);
+        }
+        return lines.join("\n");
+      }
       case "kirograph_flows": {
         const { getExecutionFlows, traceFlow, detectEntryPoints } = await Promise.resolve().then(() => require("../graph/flows.js"));
         const db = cg.getDatabase();
@@ -2419,6 +2712,102 @@ ${result.content}`;
           (c, i) => `${i + 1}. [${c.observationA.kind}] "${c.observationA.content.slice(0, 80)}" \u2194 [${c.observationB.kind}] "${c.observationB.content.slice(0, 80)}" (similarity: ${c.similarity.toFixed(2)})`
         ).join("\n") + "\n\nUse kirograph_mem_compare to establish relations.";
       }
+      case "kirograph_mem_prune": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled.";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const olderThan = args.olderThan ?? "90d";
+        const durationMs = (() => {
+          const m = olderThan.match(/^(\d+)(d|m|w|h)$/);
+          if (!m) return 90 * 864e5;
+          const v = parseInt(m[1]);
+          switch (m[2]) {
+            case "h":
+              return v * 36e5;
+            case "d":
+              return v * 864e5;
+            case "w":
+              return v * 7 * 864e5;
+            case "m":
+              return v * 30 * 864e5;
+            default:
+              return 90 * 864e5;
+          }
+        })();
+        const deleted = mem.prune(durationMs);
+        return `Pruned ${deleted} observation(s) older than ${olderThan}.`;
+      }
+      case "kirograph_mem_lint": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled.";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const result = mem.lint();
+        const lines = ["Memory Lint Results:"];
+        lines.push(`  Stale links:    ${result.staleLinks}`);
+        lines.push(`  Model mismatch: ${result.modelMismatch ? "yes" : "no"}`);
+        lines.push(`  Stale sessions: ${result.staleSessions} (auto-closed)`);
+        if (args.fix && result.staleLinks > 0) {
+          const removed = mem.removeStaleLinks();
+          lines.push(`
+\u2713 Removed ${removed} stale link(s)`);
+        } else if (result.staleLinks > 0) {
+          lines.push(`
+Pass fix: true to remove stale links.`);
+        }
+        if (result.modelMismatch) {
+          lines.push(`
+Run 'kirograph mem reembed' to fix model mismatch.`);
+        }
+        return lines.join("\n");
+      }
+      case "kirograph_mem_conflicts_list": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled.";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const limit = clampLimit(args.limit, 20);
+        const pending = mem.getPendingRelations(limit);
+        if (pending.length === 0) return "No pending conflict relations.";
+        return `Pending relations (${pending.length}):
+
+` + pending.map(
+          (r) => `[${r.id}] ${r.relation}
+  A: ${r.observationA}
+  B: ${r.observationB}${r.reason ? `
+  Reason: ${r.reason}` : ""}`
+        ).join("\n\n") + "\n\nUse kirograph_mem_conflicts_ignore to dismiss, or kirograph_mem_judge to finalize.";
+      }
+      case "kirograph_mem_conflicts_ignore": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled.";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mem = new MemoryManager(config, db.getRawDb());
+        mem.initialize();
+        const relationId = args.relationId;
+        mem.ignoreRelation(relationId);
+        return `Relation "${relationId}" ignored.`;
+      }
       // ── Docs tools ────────────────────────────────────────────────────────────
       case "kirograph_docs_toc": {
         const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
@@ -2772,6 +3161,138 @@ ${lines.join("\n")}`;
         return `Quality report for "${args.dataset}" (${quality.length} columns with issues):
 
 ${lines.join("\n")}`;
+      }
+      case "kirograph_data_drift": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableData) return "Data indexing is not enabled. Set enableData: true in .kirograph/config.json and run kirograph index.";
+        const { DataQueries } = await Promise.resolve().then(() => require("../data/queries.js"));
+        const db = cg.getDatabase();
+        db.applyDataSchema();
+        const dq = new DataQueries(db.getRawDb());
+        const drift = dq.detectDrift(args.dataset);
+        if (drift === null) return `Dataset "${args.dataset}" not found.`;
+        if (!drift.hasDrift) {
+          const rowDelta = drift.rowCountDelta !== 0 ? ` (rows: ${drift.rowCountDelta > 0 ? "+" : ""}${drift.rowCountDelta})` : "";
+          return `No schema drift detected for "${args.dataset}".${rowDelta}`;
+        }
+        const driftLines = [`Schema drift detected for "${args.dataset}":`];
+        if (drift.addedColumns?.length) driftLines.push(`  Added columns: ${drift.addedColumns.join(", ")}`);
+        if (drift.removedColumns?.length) driftLines.push(`  Removed columns: ${drift.removedColumns.join(", ")}`);
+        if (drift.typeChanges?.length) {
+          for (const tc of drift.typeChanges) {
+            driftLines.push(`  Type change: ${tc.column} ${tc.from} \u2192 ${tc.to}`);
+          }
+        }
+        if (drift.rowCountDelta !== 0) driftLines.push(`  Row count delta: ${drift.rowCountDelta > 0 ? "+" : ""}${drift.rowCountDelta}`);
+        return driftLines.join("\n");
+      }
+      case "kirograph_data_history": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableData) return "Data indexing is not enabled. Set enableData: true in .kirograph/config.json and run kirograph index.";
+        const { DataQueries } = await Promise.resolve().then(() => require("../data/queries.js"));
+        const db = cg.getDatabase();
+        db.applyDataSchema();
+        const dq = new DataQueries(db.getRawDb());
+        const limit = Math.min(Number(args.limit ?? 10), 50);
+        const history = dq.getHistory(args.dataset, limit);
+        if (history === null) return `Dataset "${args.dataset}" not found.`;
+        if (history.length === 0) return `No history snapshots for "${args.dataset}".`;
+        const histLines = [`Schema history for "${args.dataset}" (${history.length} snapshot(s)):
+`];
+        for (const snap of history) {
+          const date = new Date(snap.snapshotAt).toISOString().replace("T", " ").slice(0, 19);
+          const colNames = snap.columns.map((c) => c.name).join(", ");
+          histLines.push(`${date}  rows: ${snap.rowCount.toLocaleString()}  cols: ${snap.columnCount}  schema: ${colNames}`);
+        }
+        return histLines.join("\n");
+      }
+      // ── Watchmen tools (require enableMemory + enableWatchmen) ────────────────
+      case "kirograph_watchmen_status": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled. Set enableMemory: true in .kirograph/config.json";
+        if (!config.enableWatchmen) return "Watchmen is not enabled. Set enableWatchmen: true in .kirograph/config.json";
+        const { WatchmenChecker } = await Promise.resolve().then(() => require("../watchmen/index.js"));
+        const { MemoryDatabase } = await Promise.resolve().then(() => require("../memory/database.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const memDb = new MemoryDatabase(db.getRawDb());
+        memDb.initialize();
+        const checker = new WatchmenChecker(config.watchmenThreshold);
+        const { ready, pendingCount } = checker.shouldSynthesize(memDb);
+        const { targetFiles } = checker.buildReadyResponse("", pendingCount, projectRoot);
+        const statusLines = [
+          `Watchmen Status:`,
+          `  Pending observations: ${pendingCount} / ${config.watchmenThreshold} threshold`,
+          `  Ready to synthesize:  ${ready ? "yes" : "no"}`,
+          `  Target files:`
+        ];
+        for (const f of targetFiles) statusLines.push(`    \xB7 ${f}`);
+        return statusLines.join("\n");
+      }
+      case "kirograph_watchmen_synthesize": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory || !config.enableWatchmen) return "Watchmen is not enabled (enableMemory + enableWatchmen required).";
+        if (config.watchmenSynthesisMode !== "local") return 'watchmenSynthesisMode is not "local" \u2014 use the agent hook instead.';
+        const { WatchmenChecker } = await Promise.resolve().then(() => require("../watchmen/index.js"));
+        const { MemoryDatabase } = await Promise.resolve().then(() => require("../memory/database.js"));
+        const { runLocalSynthesis } = await Promise.resolve().then(() => require("../watchmen/synthesize.js"));
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const memDb = new MemoryDatabase(db.getRawDb());
+        memDb.initialize();
+        const checker = new WatchmenChecker(config.watchmenThreshold);
+        const { ready, pendingCount } = checker.shouldSynthesize(memDb);
+        if (!ready && !args.force) {
+          return `Watchmen: ${pendingCount}/${config.watchmenThreshold} observations \u2014 threshold not reached. Pass force: true to run anyway.`;
+        }
+        const observations = memDb.getObservationsSinceLastSummary(50);
+        if (observations.length === 0) return "No observations to synthesize.";
+        const readyResult = checker.buildReadyResponse("", pendingCount, projectRoot);
+        const result = await runLocalSynthesis(observations, readyResult, config.watchmenLocalModel, projectRoot, true);
+        const mgr = new MemoryManager(config, db.getRawDb(), projectRoot);
+        mgr.initialize();
+        await mgr.store({ content: result.summaryObservation, kind: "summary", source: "agent" });
+        const synthLines = [`Watchmen synthesis complete.`];
+        if (result.filesWritten.length) synthLines.push(`Brief written to: ${result.filesWritten.join(", ")}`);
+        if (result.skillsWritten.length) synthLines.push(`Skills written: ${result.skillsWritten.join(", ")}`);
+        if (result.skillsPruned.length) synthLines.push(`Pruned stale: ${result.skillsPruned.join(", ")}`);
+        return synthLines.join("\n");
+      }
+      case "kirograph_watchmen_reset": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableMemory) return "Memory is not enabled.";
+        if (!config.enableWatchmen) return "Watchmen is not enabled.";
+        const { MemoryManager } = await Promise.resolve().then(() => require("../memory/index.js"));
+        const db = cg.getDatabase();
+        db.applyMemorySchema();
+        const mgr = new MemoryManager(config, db.getRawDb(), projectRoot);
+        mgr.initialize();
+        const id = await mgr.store({ content: `Watchmen counter reset via MCP at ${(/* @__PURE__ */ new Date()).toISOString()}.`, kind: "summary", source: "manual" });
+        return id ? "Watchmen counter reset \u2014 pending observations set back to 0." : "Already at zero \u2014 nothing to reset.";
+      }
+      // ── Affected tests ────────────────────────────────────────────────────────
+      case "kirograph_affected": {
+        const files = args.files ?? [];
+        if (files.length === 0) return 'No files provided. Pass file paths in the "files" array.';
+        const affected = cg.getAffectedTests(files, {
+          depth: args.depth ?? 5,
+          testPattern: args.testPattern
+        });
+        if (affected.length === 0) return `No affected test files found for the provided ${files.length} changed file(s).`;
+        return `Affected test files (${affected.length}) for ${files.length} changed file(s):
+
+` + affected.map((f) => `- ${f}`).join("\n");
       }
       // ── Security tools (require enableSecurity=true) ──────────────────────────
       case "kirograph_security": {
@@ -3840,6 +4361,77 @@ Produce WIKI_DIFF blocks following SCHEMA.md, then call kirograph_wiki_apply_dif
         }
         return lines.join("\n");
       }
+      case "kirograph_wiki_synthesize": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableWiki) return "Wiki is not enabled. Set enableWiki: true in .kirograph/config.json";
+        if (config.wikiSynthesisMode !== "local") return 'wikiSynthesisMode is not "local". This tool is for local-model synthesis only.';
+        const { KiroGraphWiki } = await Promise.resolve().then(() => require("../wiki/index.js"));
+        const db = cg.getDatabase();
+        db.applyWikiSchema();
+        const wiki = new KiroGraphWiki(db.getRawDb(), projectRoot + "/.kirograph", {
+          autoResolveConflicts: config.wikiAutoResolveConflicts ?? false
+        });
+        wiki.initialize();
+        const queueCount = wiki.getQueueCount();
+        if (queueCount === 0) return "Wiki queue is empty \u2014 nothing to synthesize.";
+        const result = await wiki.synthesize(config.wikiLocalModel, true);
+        const synthLines = [`Wiki synthesis complete \u2014 processed ${result.processed} source(s).`];
+        if (result.created.length) synthLines.push(`Created: ${result.created.join(", ")}`);
+        if (result.updated.length) synthLines.push(`Updated: ${result.updated.join(", ")}`);
+        if (result.errors.length) synthLines.push(`Errors: ${result.errors.join("; ")}`);
+        return synthLines.join("\n");
+      }
+      case "kirograph_wiki_init": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableWiki) return "Wiki is not enabled. Set enableWiki: true in .kirograph/config.json";
+        const { KiroGraphWiki } = await Promise.resolve().then(() => require("../wiki/index.js"));
+        const db = cg.getDatabase();
+        db.applyWikiSchema();
+        const wiki = new KiroGraphWiki(db.getRawDb(), projectRoot + "/.kirograph", {
+          autoResolveConflicts: config.wikiAutoResolveConflicts ?? false
+        });
+        wiki.initWiki();
+        return "Wiki initialized. SCHEMA.md and MANIFEST.md created in .kirograph/wiki/.";
+      }
+      case "kirograph_wiki_reindex": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableWiki) return "Wiki is not enabled. Set enableWiki: true in .kirograph/config.json";
+        const { KiroGraphWiki } = await Promise.resolve().then(() => require("../wiki/index.js"));
+        const db = cg.getDatabase();
+        db.applyWikiSchema();
+        const wiki = new KiroGraphWiki(db.getRawDb(), projectRoot + "/.kirograph");
+        wiki.initialize();
+        const count = wiki.reindex();
+        return `Reindexed ${count} wiki page(s) from .kirograph/wiki/*.md.`;
+      }
+      case "kirograph_wiki_status": {
+        const { loadConfig } = await Promise.resolve().then(() => require("../config.js"));
+        const projectRoot = args.projectPath ?? cg.getProjectRoot();
+        const config = await loadConfig(projectRoot);
+        if (!config.enableWiki) return "Wiki is not enabled. Set enableWiki: true in .kirograph/config.json";
+        const { KiroGraphWiki } = await Promise.resolve().then(() => require("../wiki/index.js"));
+        const db = cg.getDatabase();
+        db.applyWikiSchema();
+        const wiki = new KiroGraphWiki(db.getRawDb(), projectRoot + "/.kirograph");
+        wiki.initialize();
+        const stats = wiki.getStats();
+        const oldest = stats.oldestPage ? new Date(stats.oldestPage).toISOString().slice(0, 10) : "n/a";
+        const newest = stats.newestPage ? new Date(stats.newestPage).toISOString().slice(0, 10) : "n/a";
+        return [
+          "Wiki Status:",
+          `  Pages:         ${stats.pageCount}`,
+          `  Total sources: ${stats.totalSources}`,
+          `  Oldest page:   ${oldest}`,
+          `  Newest page:   ${newest}`,
+          `  Wiki dir:      .kirograph/wiki/`
+        ].join("\n");
+      }
       default:
         return `Unknown tool: ${toolName}`;
     }