@grafema/mcp 0.2.12-beta → 0.3.0-beta

package/src/handlers/dataflow-handlers.ts

@@ -1,5 +1,7 @@
 /**
  * MCP Dataflow Handlers
+ *
+ * Delegates BFS tracing to @grafema/util's shared traceDataflow module.
  */
 
 import { ensureAnalyzed } from '../analysis.js';
@@ -9,6 +11,7 @@ import {
   textResult,
   errorResult,
 } from '../utils.js';
+import { isGrafemaUri, toCompactSemanticId } from '@grafema/util';
 import type {
   ToolResult,
   TraceAliasArgs,
@@ -16,8 +19,14 @@ import type {
   CheckInvariantArgs,
   GraphNode,
 } from '../types.js';
+import {
+  traceDataflow,
+  renderTraceNarrative,
+  type DataflowBackend,
+  type TraceDetail,
+} from '@grafema/util';
 
-// === TRACE HANDLERS ===
+// === TRACE ALIAS (unchanged) ===
 
 export async function handleTraceAlias(args: TraceAliasArgs): Promise<ToolResult> {
   const db = await ensureAnalyzed();
@@ -58,6 +67,16 @@ export async function handleTraceAlias(args: TraceAliasArgs): Promise<ToolResult
     }
     visited.add(current.id);
 
+    // Resolve REFERENCE → declaration transparently (don't add to chain)
+    if (current.type === 'REFERENCE') {
+      const resolveEdges = await db.getOutgoingEdges(current.id, ['READS_FROM']);
+      if (resolveEdges.length > 0) {
+        current = await db.getNode(resolveEdges[0].dst);
+        continue;
+      }
+      break;
+    }
+
     chain.push({
       type: current.type,
       name: current.name,
@@ -80,71 +99,64 @@ export async function handleTraceAlias(args: TraceAliasArgs): Promise<ToolResult
   );
 }
 
+// === TRACE DATAFLOW ===
+
 export async function handleTraceDataFlow(args: TraceDataFlowArgs): Promise<ToolResult> {
   const db = await ensureAnalyzed();
-  const { source, direction = 'forward', max_depth = 10 } = args;
+  const { source, file, direction = 'forward', max_depth = 10, limit = 50, detail } = args;
 
   // Find source node
-  let sourceNode: GraphNode | null = null;
-
-  // Try to find by ID first
-  sourceNode = await db.getNode(source);
-
-  // If not found, search by name
+  let sourceNode: GraphNode | null = await db.getNode(source);
   if (!sourceNode) {
+    // Search by name, preferring nodes that match the file filter
+    let fallbackNode: GraphNode | null = null;
     for await (const node of db.queryNodes({ name: source })) {
+      if (file && !node.file?.includes(file)) {
+        // Keep first match as fallback in case no file-matching node is found
+        if (!fallbackNode) fallbackNode = node;
+        continue;
+      }
       sourceNode = node;
       break;
     }
-  }
-
-  if (!sourceNode) {
-    return errorResult(`Source "${source}" not found`);
-  }
-
-  const visited = new Set<string>();
-  const paths: unknown[] = [];
-
-  async function trace(nodeId: string, depth: number, path: string[]): Promise<void> {
-    if (depth > max_depth || visited.has(nodeId)) return;
-    visited.add(nodeId);
-
-    const newPath = [...path, nodeId];
-
-    if (direction === 'forward' || direction === 'both') {
-      const outEdges = await db.getOutgoingEdges(nodeId, [
-        'ASSIGNED_FROM',
-        'DERIVES_FROM',
-        'PASSES_ARGUMENT',
-      ]);
-      for (const edge of outEdges) {
-        await trace(edge.dst, depth + 1, newPath);
-      }
-    }
-
-    if (direction === 'backward' || direction === 'both') {
-      const inEdges = await db.getIncomingEdges(nodeId, [
-        'ASSIGNED_FROM',
-        'DERIVES_FROM',
-        'PASSES_ARGUMENT',
-      ]);
-      for (const edge of inEdges) {
-        await trace(edge.src, depth + 1, newPath);
+    // Also try PARAMETER type nodes (often the real entry point for dataflow)
+    if (!sourceNode) {
+      for await (const node of db.queryNodes({ type: 'PARAMETER', name: source })) {
+        if (file && !node.file?.includes(file)) {
+          if (!fallbackNode) fallbackNode = node;
+          continue;
+        }
+        sourceNode = node;
+        break;
       }
     }
-
-    if (depth > 0) {
-      paths.push(newPath);
+    // Use fallback (first name match regardless of file) if no file-specific match
+    if (!sourceNode && fallbackNode) {
+      sourceNode = fallbackNode;
     }
   }
+  if (!sourceNode) {
+    const displaySource = isGrafemaUri(source) ? toCompactSemanticId(source) : source;
+    return errorResult(`Source "${displaySource}" not found`);
+  }
 
-  await trace(sourceNode.id, 0, []);
+  // Cast db to DataflowBackend — runtime types are compatible
+  const dfDb = db as unknown as DataflowBackend;
 
-  return textResult(
-    `Data flow from "${source}" (${paths.length} paths):\n\n${JSON.stringify(paths, null, 2)}`
-  );
+  const traceResults = await traceDataflow(dfDb, sourceNode.id, {
+    direction: direction as 'forward' | 'backward' | 'both',
+    maxDepth: max_depth,
+    limit,
+  });
+
+  const sourceName = sourceNode.name || source;
+  return textResult(renderTraceNarrative(traceResults, sourceName, {
+    detail: (detail as TraceDetail) || 'normal',
+  }));
 }
 
+// === CHECK INVARIANT (unchanged) ===
+
 export async function handleCheckInvariant(args: CheckInvariantArgs): Promise<ToolResult> {
   const db = await ensureAnalyzed();
   const { rule, name: description } = args;
@@ -155,32 +167,38 @@ export async function handleCheckInvariant(args: CheckInvariantArgs): Promise<To
 
   try {
     const checkFn = (db as unknown as { checkGuarantee: (q: string) => Promise<Array<{ bindings: Array<{ name: string; value: string }> }>> }).checkGuarantee;
-    const violations = await checkFn(rule);
+    const violations = await checkFn.call(db, rule);
     const total = violations.length;
 
     if (total === 0) {
-      return textResult(`✅ Invariant holds: ${description || 'No violations found'}`);
+      return textResult(`Invariant holds: ${description || 'No violations found'}`);
     }
 
     const enrichedViolations: unknown[] = [];
     for (const v of violations.slice(0, 20)) {
-      const nodeId = v.bindings?.find((b: any) => b.name === 'X')?.value;
-      if (nodeId) {
-        const node = await db.getNode(nodeId);
+      const xBinding = v.bindings?.find((b: { name: string; value: string }) => b.name === 'X');
+      if (xBinding) {
+        const node = await db.getNode(xBinding.value);
         if (node) {
           enrichedViolations.push({
-            id: nodeId,
+            id: xBinding.value,
             type: node.type,
             name: node.name,
             file: node.file,
             line: node.line,
           });
+        } else {
+          const bindingsMap: Record<string, string> = {};
+          for (const b of v.bindings!) {
+            bindingsMap[b.name] = b.value;
+          }
+          enrichedViolations.push(bindingsMap);
         }
       }
     }
 
     return textResult(
-      `❌ ${total} violation(s) found:\n\n${JSON.stringify(
+      `${total} violation(s) found:\n\n${JSON.stringify(
         serializeBigInt(enrichedViolations),
         null,
         2

package/src/handlers/documentation-handlers.ts

@@ -2,7 +2,7 @@
  * MCP Documentation Handlers
  */
 
-import { getOnboardingInstruction } from '@grafema/core';
+import { getOnboardingInstruction } from '@grafema/util';
 import {
   textResult,
 } from '../utils.js';
@@ -41,7 +41,7 @@ Grafema is a static code analyzer that builds a graph of your codebase.
 violation(X) :- node(X, "TYPE"), attr(X, "name", "value").
 
 ## Available Predicates
-- node(Id, Type) - match nodes
+- type(Id, Type) - match nodes (alias: node)
 - edge(Src, Dst, Type) - match edges
 - attr(Id, Name, Value) - match attributes
 - \\+ - negation (not)
@@ -81,6 +81,60 @@ Use check_guarantees to verify all guarantees.
 ## Example
 Name: no-eval
 Rule: violation(X) :- node(X, "CALL"), attr(X, "name", "eval").
+`,
+    notation: `
+# Grafema DSL — Compact Visual Notation
+
+Grafema DSL renders graph structure as compact, readable notation.
+Output-only — Datalog remains the query language.
+
+## Archetypes & Operators
+
+| Archetype  | Op    | Meaning                   | Example edge types                    |
+|------------|-------|---------------------------|---------------------------------------|
+| contains   | (nest)| structural containment    | CONTAINS, HAS_MEMBER, DECLARES        |
+| depends    | o-    | dependency / import       | DEPENDS_ON, IMPORTS_FROM, USES        |
+| flow_out   | >     | outward call / data flow  | CALLS, ROUTES_TO, PASSES_ARGUMENT     |
+| flow_in    | <     | inward data / type flow   | READS_FROM, ASSIGNED_FROM, EXTENDS    |
+| write      | =>    | persistent side effect    | WRITES_TO, LOGS_TO                    |
+| exception  | >x    | error / rejection         | THROWS, REJECTS, CATCHES_FROM         |
+| publishes  | ~>>   | event / message           | EMITS_EVENT, PUBLISHES_TO, EXPOSED_VIA|
+| gates      | ?|    | conditional guard         | HAS_CONDITION, HAS_CASE               |
+| governs    | |=    | governance / invariant    | GOVERNS, VIOLATES, MONITORED_BY       |
+
+## LOD Levels (depth)
+
+- **depth=0**: Node names only — minimal overview
+- **depth=1** (default): Node + edges — shows all relationships with operators
+- **depth=2**: Node + edges + nested children, **folded** — repetitive siblings compressed into exemplar + summary. Ideal for large modules (e.g., 36 handler imports → 1 exemplar + fold summary)
+- **depth=3**: Node + edges + nested children, **exact** — every node expanded individually, no folding. Use when you need the precise bijective DSL output
+
+## Perspective Presets
+
+| Preset   | Archetypes shown              | Use case                  |
+|----------|-------------------------------|---------------------------|
+| security | write, exception              | Audit side effects & errors|
+| data     | flow_out, flow_in, write      | Trace data movement       |
+| errors   | exception                     | Error handling review      |
+| api      | flow_out, publishes, depends  | API surface analysis       |
+| events   | publishes                     | Event flow mapping         |
+
+## Special Modifiers
+
+- \`??\` — uncertain/dynamic (unresolved call, dynamic import)
+- \`[]\` — inside loop (edge occurs within iteration)
+
+## Budget
+
+Default budget: 7 items per group. When exceeded, remaining items are
+summarized as \`+N more\`. Override with budget parameter.
+
+## Usage
+
+**MCP:** \`describe(target="src/app.ts->FUNCTION->main", depth=1, perspective="security")\`
+**CLI:** \`grafema describe "src/app.ts->FUNCTION->main" -d 1 --perspective security\`
+
+Target resolution order: semantic ID → file path (MODULE) → node name.
 `,
   };
 

package/src/handlers/graph-handlers.ts

@@ -0,0 +1,212 @@
+/**
+ * Graph traversal handlers: get_node, get_neighbors, traverse_graph
+ * REG-521: Add raw graph traversal primitives to MCP
+ */
+
+import { ensureAnalyzed } from '../analysis.js';
+import { textResult, errorResult } from '../utils.js';
+import { isGrafemaUri, toCompactSemanticId } from '@grafema/util';
+import type { ToolResult, GetNodeArgs, GetNeighborsArgs, TraverseGraphArgs } from '../types.js';
+import type { EdgeType, EdgeRecord } from '@grafema/types';
+
+const MAX_TRAVERSAL_RESULTS = 10_000;
+const MAX_DEPTH = 20;
+
+/**
+ * Minimal backend interface for graph-handler logic functions.
+ * Allows testing with mock backends without importing full GraphBackend.
+ */
+interface GraphBackendLike {
+  getNode(id: string): Promise<Record<string, unknown> | null>;
+  getOutgoingEdges(nodeId: string, edgeTypes?: EdgeType[] | null): Promise<EdgeRecord[]>;
+  getIncomingEdges(nodeId: string, edgeTypes?: EdgeType[] | null): Promise<EdgeRecord[]>;
+}
+
+// === Shared helpers ===
+
+async function groupEdgesByType(
+  edges: EdgeRecord[],
+  db: GraphBackendLike,
+  getNodeId: (edge: EdgeRecord) => string,
+): Promise<Record<string, Array<Record<string, unknown>>>> {
+  const grouped: Record<string, Array<Record<string, unknown>>> = {};
+
+  for (const edge of edges) {
+    const type = edge.type as string;
+    if (!grouped[type]) grouped[type] = [];
+    const nodeId = getNodeId(edge);
+    const node = await db.getNode(nodeId);
+    grouped[type].push({
+      id: nodeId,
+      ...(node ? { type: node.type, name: node.name, file: node.file, line: node.line } : { type: 'UNKNOWN' }),
+      ...(edge.metadata ? { edgeMetadata: edge.metadata } : {}),
+    });
+  }
+
+  return grouped;
+}
+
+// === Logic functions (testable, accept backend directly) ===
+
+export async function getNodeLogic(db: GraphBackendLike, args: GetNodeArgs): Promise<ToolResult> {
+  const { semanticId } = args;
+
+  if (!semanticId || semanticId.trim() === '') {
+    return errorResult('semanticId must be a non-empty string');
+  }
+
+  // Accept both grafema:// URI and compact format
+  // If URI is passed, convert to compact for error messages
+  const displayId = isGrafemaUri(semanticId) ? toCompactSemanticId(semanticId) : semanticId;
+
+  const node = await db.getNode(semanticId);
+
+  if (!node) {
+    return errorResult(`Node not found: "${displayId}". Use find_nodes to search by type, name, or file.`);
+  }
+
+  return textResult(JSON.stringify(node, null, 2));
+}
+
+export async function getNeighborsLogic(db: GraphBackendLike, args: GetNeighborsArgs): Promise<ToolResult> {
+  const { semanticId, direction = 'both', edgeTypes } = args;
+
+  if (!semanticId || semanticId.trim() === '') {
+    return errorResult('semanticId must be a non-empty string');
+  }
+
+  if (edgeTypes !== undefined && edgeTypes.length === 0) {
+    return errorResult('edgeTypes must not be an empty array. Omit edgeTypes to get all edge types.');
+  }
+
+  // Accept both grafema:// URI and compact format
+  const displayId = isGrafemaUri(semanticId) ? toCompactSemanticId(semanticId) : semanticId;
+
+  const node = await db.getNode(semanticId);
+
+  if (!node) {
+    return errorResult(`Node not found: "${displayId}". Use find_nodes to search by type, name, or file.`);
+  }
+
+  const edgeFilter = (edgeTypes as EdgeType[] | undefined) ?? null;
+  const result: Record<string, unknown> = {};
+
+  if (direction === 'outgoing' || direction === 'both') {
+    const edges = await db.getOutgoingEdges(semanticId, edgeFilter);
+    result.outgoing = await groupEdgesByType(edges, db, (e) => e.dst);
+  }
+
+  if (direction === 'incoming' || direction === 'both') {
+    const edges = await db.getIncomingEdges(semanticId, edgeFilter);
+    result.incoming = await groupEdgesByType(edges, db, (e) => e.src);
+  }
+
+  return textResult(JSON.stringify(result, null, 2));
+}
+
+export async function traverseGraphLogic(db: GraphBackendLike, args: TraverseGraphArgs): Promise<ToolResult> {
+  const { startNodeIds, edgeTypes, maxDepth = 5, direction = 'outgoing' } = args;
+
+  // Validate inputs
+  if (!startNodeIds || startNodeIds.length === 0) {
+    return errorResult('startNodeIds must not be empty');
+  }
+  if (!edgeTypes || edgeTypes.length === 0) {
+    return errorResult('edgeTypes must not be empty. Use get_schema(type="edges") to see available types.');
+  }
+  if (!Number.isInteger(maxDepth) || maxDepth < 0) {
+    return errorResult('maxDepth must be a non-negative integer');
+  }
+  if (maxDepth > MAX_DEPTH) {
+    return errorResult(`maxDepth must be <= ${MAX_DEPTH} to prevent performance issues`);
+  }
+
+  // Deduplicate start nodes
+  const uniqueStartIds = [...new Set(startNodeIds)];
+
+  // Verify start nodes exist
+  for (const id of uniqueStartIds) {
+    const node = await db.getNode(id);
+    if (!node) {
+      // Accept both grafema:// URI and compact format for display
+      const displayId = isGrafemaUri(id) ? toCompactSemanticId(id) : id;
+      return errorResult(`Start node not found: "${displayId}". Use find_nodes to search by type, name, or file.`);
+    }
+  }
+
+  const edgeFilter = edgeTypes as EdgeType[];
+
+  // Manual BFS (works for both directions, provides depth info)
+  const visited = new Set<string>(uniqueStartIds);
+  const queue: Array<{ id: string; depth: number }> = uniqueStartIds.map(id => ({ id, depth: 0 }));
+  const results: Array<{ id: string; depth: number }> = uniqueStartIds.map(id => ({ id, depth: 0 }));
+
+  while (queue.length > 0) {
+    const current = queue.shift()!;
+    if (current.depth >= maxDepth) continue;
+
+    const edges: EdgeRecord[] = direction === 'outgoing'
+      ? await db.getOutgoingEdges(current.id, edgeFilter)
+      : await db.getIncomingEdges(current.id, edgeFilter);
+
+    for (const edge of edges) {
+      const neighborId = direction === 'outgoing' ? edge.dst : edge.src;
+      if (!visited.has(neighborId)) {
+        visited.add(neighborId);
+        const nextDepth = current.depth + 1;
+        queue.push({ id: neighborId, depth: nextDepth });
+        results.push({ id: neighborId, depth: nextDepth });
+
+        if (results.length >= MAX_TRAVERSAL_RESULTS) {
+          const nodes = await enrichResults(db, results);
+          return textResult(JSON.stringify({
+            count: nodes.length,
+            truncated: true,
+            message: `Traversal hit limit of ${MAX_TRAVERSAL_RESULTS} nodes. Use more specific edge types or lower maxDepth.`,
+            nodes,
+          }, null, 2));
+        }
+      }
+    }
+  }
+
+  const nodes = await enrichResults(db, results);
+  return textResult(JSON.stringify({
+    count: nodes.length,
+    truncated: false,
+    nodes,
+  }, null, 2));
+}
+
+async function enrichResults(
+  db: GraphBackendLike,
+  results: Array<{ id: string; depth: number }>
+): Promise<Array<Record<string, unknown>>> {
+  return Promise.all(
+    results.map(async ({ id, depth }) => {
+      const node = await db.getNode(id);
+      return {
+        id,
+        depth,
+        ...(node ? { type: node.type, name: node.name, file: node.file, line: node.line } : { type: 'UNKNOWN' }),
+      };
+    })
+  );
+}
+
+// === Public handlers (call ensureAnalyzed, used by MCP routing) ===
+
+export async function handleGetNode(args: GetNodeArgs): Promise<ToolResult> {
+  const db = await ensureAnalyzed();
+  return getNodeLogic(db as unknown as GraphBackendLike, args);
+}
+
+export async function handleGetNeighbors(args: GetNeighborsArgs): Promise<ToolResult> {
+  const db = await ensureAnalyzed();
+  return getNeighborsLogic(db as unknown as GraphBackendLike, args);
+}
+
+export async function handleTraverseGraph(args: TraverseGraphArgs): Promise<ToolResult> {
+  const db = await ensureAnalyzed();
+  return traverseGraphLogic(db as unknown as GraphBackendLike, args);
+}

package/src/handlers/graphql-handlers.ts

@@ -0,0 +1,70 @@
+/**
+ * GraphQL query handler — execute GraphQL queries against the code graph.
+ *
+ * Uses @grafema/api's schema and resolvers in-process via graphql-yoga.
+ * No HTTP server needed — yoga.fetch() accepts synthetic Request objects.
+ */
+
+import { ensureAnalyzed } from '../analysis.js';
+import { textResult, errorResult } from '../utils.js';
+import type { ToolResult, GraphQLQueryArgs } from '../types.js';
+import type { RFDBServerBackend } from '@grafema/util';
+
+let yogaInstance: any = null;
+let yogaBackend: RFDBServerBackend | null = null;
+
+/**
+ * Get or create the yoga instance.
+ * Recreated if the backend changes (e.g., after re-analysis).
+ */
+async function getYoga(backend: RFDBServerBackend) {
+  if (yogaInstance && yogaBackend === backend) {
+    return yogaInstance;
+  }
+
+  // Dynamic import to avoid loading graphql-yoga unless needed
+  const { createGraphQLServer } = await import('@grafema/api');
+  yogaInstance = createGraphQLServer({ backend });
+  yogaBackend = backend;
+  return yogaInstance;
+}
+
+export async function handleGraphQLQuery(args: GraphQLQueryArgs): Promise<ToolResult> {
+  const { query, variables, operationName } = args;
+
+  if (!query || query.trim() === '') {
+    return errorResult('query must be a non-empty GraphQL query string');
+  }
+
+  const db = await ensureAnalyzed();
+  const yoga = await getYoga(db as RFDBServerBackend);
+
+  // Build the GraphQL request body
+  const body: Record<string, unknown> = { query };
+  if (variables) body.variables = variables;
+  if (operationName) body.operationName = operationName;
+
+  // Execute via yoga.fetch() — no HTTP server needed
+  const response = await yoga.fetch('http://localhost/graphql', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+
+  const result = await response.json();
+
+  // Format output
+  if (result.errors && result.errors.length > 0) {
+    const errorMessages = result.errors.map((e: any) => e.message).join('\n');
+    if (result.data) {
+      // Partial success — return data with errors noted
+      return textResult(
+        `GraphQL partial result (with errors):\n${errorMessages}\n\n` +
+        JSON.stringify(result.data, null, 2)
+      );
+    }
+    return errorResult(`GraphQL errors:\n${errorMessages}`);
+  }
+
+  return textResult(JSON.stringify(result.data, null, 2));
+}

package/src/handlers/guarantee-handlers.ts

@@ -13,7 +13,7 @@ import type {
   CheckGuaranteesArgs,
   DeleteGuaranteeArgs,
 } from '../types.js';
-import { isGuaranteeType } from '@grafema/core';
+import { isGuaranteeType } from '@grafema/util';
 
 // === GUARANTEE HANDLERS ===
 

package/src/handlers/guard-handlers.ts

@@ -8,6 +8,7 @@ import {
   textResult,
   errorResult,
 } from '../utils.js';
+import { isGrafemaUri, toCompactSemanticId } from '@grafema/util';
 import type {
   ToolResult,
   FindGuardsArgs,
@@ -28,10 +29,13 @@ export async function handleFindGuards(args: FindGuardsArgs): Promise<ToolResult
   const db = await getOrCreateBackend();
   const { nodeId } = args;
 
+  // Accept both grafema:// URI and compact format
+  const displayId = isGrafemaUri(nodeId) ? toCompactSemanticId(nodeId) : nodeId;
+
   // Verify target node exists
   const targetNode = await db.getNode(nodeId);
   if (!targetNode) {
-    return errorResult(`Node not found: ${nodeId}`);
+    return errorResult(`Node not found: ${displayId}`);
   }
 
   const guards: GuardInfo[] = [];
@@ -79,7 +83,7 @@ export async function handleFindGuards(args: FindGuardsArgs): Promise<ToolResult
 
   if (guards.length === 0) {
     return textResult(
-      `No guards found for node: ${nodeId}\n` +
+      `No guards found for node: ${displayId}\n` +
       `The node is not protected by any conditional scope (if/else/switch/etc.).`
     );
   }
@@ -91,7 +95,7 @@ export async function handleFindGuards(args: FindGuardsArgs): Promise<ToolResult
   }).join('\n');
 
   return textResult(
-    `Found ${guards.length} guard(s) for node: ${nodeId}\n` +
+    `Found ${guards.length} guard(s) for node: ${displayId}\n` +
     `(inner to outer order)\n\n` +
     summary +
     `\n\n` +

package/src/handlers/index.ts

@@ -12,3 +12,9 @@ export { handleGetCoverage } from './coverage-handlers.js';
 export { handleFindGuards } from './guard-handlers.js';
 export { handleGetDocumentation } from './documentation-handlers.js';
 export { handleReportIssue } from './issue-handlers.js';
+export { handleGetNode, handleGetNeighbors, handleTraverseGraph } from './graph-handlers.js';
+export { handleAddKnowledge, handleQueryKnowledge, handleQueryDecisions, handleSupersedeFact, handleGetKnowledgeStats } from './knowledge-handlers.js';
+// Disabled: requires git-ingest (US-17). See US-17 in AI-AGENT-STORIES.md
+// export { handleGitChurn, handleGitCoChange, handleGitOwnership, handleGitArchaeology } from './knowledge-handlers.js';
+export { handleDescribe } from './notation-handlers.js';
+export { handleGraphQLQuery } from './graphql-handlers.js';