@remnic/core 9.3.693 → 9.3.694

package/src/access-mcp.ts

@@ -111,6 +111,21 @@ const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   "engram.memory_store": "memory_store",
   "engram.coding_decision": "coding_decision",
   "engram.coding_architecture": "coding_architecture",
+  // codegraph parity tools (issue #1554) — each maps to its boundary op.
+  "engram.codegraph_index": "codegraph_index",
+  "engram.codegraph_list_projects": "codegraph_list_projects",
+  "engram.codegraph_delete_project": "codegraph_delete_project",
+  "engram.codegraph_index_status": "codegraph_index_status",
+  "engram.codegraph_search_graph": "codegraph_search_graph",
+  "engram.codegraph_trace_path": "codegraph_trace_path",
+  "engram.codegraph_detect_changes": "codegraph_detect_changes",
+  "engram.codegraph_query_graph": "codegraph_query_graph",
+  "engram.codegraph_get_schema": "codegraph_get_schema",
+  "engram.codegraph_get_snippet": "codegraph_get_snippet",
+  "engram.codegraph_get_architecture": "codegraph_get_architecture",
+  "engram.codegraph_search_code": "codegraph_search_code",
+  "engram.codegraph_manage_adr": "codegraph_manage_adr",
+  "engram.codegraph_ingest_traces": "codegraph_ingest_traces",
   "engram.coding_delta": "coding_delta",
 };
 
@@ -332,6 +347,12 @@ export class EngramMcpServer {
    * (issue #1548 Track A PR 3, rule 39).
    */
   private readonly architectureCardVisible: boolean;
+  /**
+   * Whether the 14 codegraph parity tools should appear in `tools/list`
+   * (issue #1554). Config-only -- runtime availability is checked at call
+   * time. When false the tools array is byte-identical to pre-feature.
+   */
+  private readonly codegraphVisible: boolean;
   private readonly sessionDeltaVisible: boolean;
 
   constructor(
@@ -343,6 +364,7 @@ export class EngramMcpServer {
       emitLegacyTools?: boolean;
       codingDecisionVisible?: boolean;
       architectureCardVisible?: boolean;
+      codegraphVisible?: boolean;
       sessionDeltaVisible?: boolean;
     } = {},
   ) {
@@ -351,6 +373,7 @@ export class EngramMcpServer {
     this.emitLegacyTools = options.emitLegacyTools !== false;
     this.codingDecisionVisible = options.codingDecisionVisible === true;
     this.architectureCardVisible = options.architectureCardVisible === true;
+    this.codegraphVisible = options.codegraphVisible === true;
     this.sessionDeltaVisible = options.sessionDeltaVisible === true;
     this.authenticatedPrincipal =
       options.principal?.trim() ||
@@ -2037,6 +2060,70 @@ export class EngramMcpServer {
       );
       this.tools = [...this.tools, ...architectureTools];
     }
+    if (this.codegraphVisible) {
+      // The 14 codegraph parity tools (issue #1554). Each delegates to its
+      // boundary operation; the MCP dispatch injects the `tool` field from
+      // the operation name. The inputSchema is intentionally permissive —
+      // the boundary's zod schema owns validation (rule 51).
+      const codegraphToolDefs: Array<{ suffix: string; description: string; required?: string[] }> = [
+        { suffix: "index", description: "Index a repository into the code graph.", required: ["repoRoot"] },
+        { suffix: "list_projects", description: "List code graph projects for the principal." },
+        { suffix: "delete_project", description: "Delete a code graph project (requires confirm: true).", required: ["confirm"] },
+        { suffix: "index_status", description: "Get the indexing status for a project." },
+        { suffix: "search_graph", description: "Search the code graph for symbols.", required: ["query"] },
+        { suffix: "trace_path", description: "Trace call/dependency paths from a starting symbol.", required: ["start"] },
+        { suffix: "detect_changes", description: "Detect changed symbols since a git ref.", required: ["head"] },
+        { suffix: "query_graph", description: "Run a structured query against the code graph.", required: ["structuredQuery"] },
+        { suffix: "get_schema", description: "Get the code graph schema statistics." },
+        { suffix: "get_snippet", description: "Get a source code snippet for a symbol.", required: ["qualifiedName"] },
+        { suffix: "get_architecture", description: "Get the composed architecture card + graph stats." },
+        { suffix: "search_code", description: "Search the code graph for code (functions, classes, methods).", required: ["query"] },
+        { suffix: "manage_adr", description: "Manage ADRs via Track A decision records (list, get, record, supersede).", required: ["subcommand"] },
+        { suffix: "ingest_traces", description: "Ingest call-site traces to upgrade edge confidence.", required: ["traces"] },
+      ];
+      for (const def of codegraphToolDefs) {
+        const tools = withToolAliases(
+          {
+            name: `engram.codegraph_${def.suffix}`,
+            description: def.description,
+            inputSchema: {
+              type: "object",
+              properties: {
+                sessionKey: { type: "string", description: "Session identifier whose coding context scopes the operation." },
+                project: { type: "string", description: "Explicit project id (defaults to session coding context)." },
+                principal: { type: "string", description: "Authenticated principal override." },
+                query: { type: "string" },
+                limit: { type: "number" },
+                start: { type: "string" },
+                direction: { type: "string", enum: ["inbound", "outbound", "both"] },
+                depth: { type: "number" },
+                qualifiedName: { type: "string" },
+                path: { type: "string" },
+                structuredQuery: { type: "object" },
+                head: { type: "string" },
+                repoRoot: { type: "string" },
+                mode: { type: "string", enum: ["auto", "full", "incremental"] },
+                confirm: { type: "boolean" },
+                subcommand: { type: "string", enum: ["list", "get", "record", "supersede"] },
+                id: { type: "string" },
+                title: { type: "string" },
+                status: { type: "string", enum: ["proposed", "accepted", "superseded", "rejected"] },
+                context: { type: "string" },
+                decision: { type: "string" },
+                consequences: { type: "string" },
+                entityRefs: { type: "array", items: { type: "string" } },
+                supersedesId: { type: "string" },
+                traces: { type: "array", items: { type: "object" } },
+              },
+              required: def.required ?? [],
+              additionalProperties: false,
+            },
+          },
+          this.emitLegacyTools,
+        );
+        this.tools = [...this.tools, ...tools];
+      }
+    }
     if (this.sessionDeltaVisible) {
       const deltaTools = withToolAliases(
         {
@@ -2423,8 +2510,18 @@ export class EngramMcpServer {
       if (!op) {
         throw new EngramAccessInputError(`access-boundary: operation not registered: ${migrated}`);
       }
-      const envelope =
-        migrated === "memory_store" ? parseMcpRequest("memoryStore", args) : args;
+      let envelope: Record<string, unknown>;
+      if (migrated === "memory_store") {
+        envelope = parseMcpRequest("memoryStore", args);
+      } else if (migrated.startsWith("codegraph_")) {
+        // codegraph parity tools (issue #1554): the surface handler dispatches
+        // on the `tool` field. The MCP tool name encodes it (e.g.
+        // codegraph_search_graph → tool: "search_graph"); inject it so the
+        // client payload does not need to carry the internal dispatch field.
+        envelope = { ...args, tool: migrated.slice("codegraph_".length) };
+      } else {
+        envelope = args;
+      }
       // The registry erases In/Out at the Map boundary; the caller knows the
       // concrete output shape ({ result: <service response> }) so the cast is
       // the type-erasure seam, not a leap of faith.

package/src/access-operations.ts

@@ -29,6 +29,11 @@ import {
   type ArchitectureSurfaceRequest,
   type ArchitectureSurfaceResponse,
 } from "./coding/architecture-surfaces.js";
+import {
+  type CodegraphSurfaceRequest,
+  type CodegraphSurfaceResponse,
+  isCodegraphToolName,
+} from "./coding/codegraph-surfaces.js";
 import {
   DELTA_SUBCOMMANDS,
   type DeltaSurfaceRequest,
@@ -255,6 +260,50 @@ export const codingArchitectureOperation = defineOperation<
   },
 });
 
+const codegraphSurfaceSchema = z.preprocess(
+  (data) => {
+    if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+      const obj = data as Record<string, unknown>;
+      const cleaned: Record<string, unknown> = {};
+      for (const [key, value] of Object.entries(obj)) {
+        if (value !== null) cleaned[key] = value;
+      }
+      return cleaned;
+    }
+    return data;
+  },
+  z.object({
+    tool: z.string().refine(isCodegraphToolName, {
+      message: "tool must be one of the codegraph tool names",
+    }),
+    sessionKey: z.string().max(512).optional(),
+    principal: z.string().max(256).optional(),
+    project: z.string().max(256).optional(),
+    query: z.string().max(2048).optional(),
+    limit: z.number().int().positive().max(200).optional(),
+    start: z.string().max(512).optional(),
+    direction: z.string().max(64).optional(),
+    depth: z.number().int().positive().max(10).optional(),
+    qualifiedName: z.string().max(1024).optional(),
+    path: z.string().max(2048).optional(),
+    structuredQuery: z.record(z.string(), z.unknown()).optional(),
+    head: z.string().max(256).optional(),
+    repoRoot: z.string().max(2048).optional(),
+    mode: z.string().max(64).optional(),
+    confirm: z.boolean().optional(),
+    subcommand: z.string().max(64).optional(),
+    id: z.string().max(512).optional(),
+    title: z.string().max(512).optional(),
+    status: z.string().max(64).optional(),
+    context: z.string().max(8192).optional(),
+    decision: z.string().max(8192).optional(),
+    consequences: z.string().max(8192).optional(),
+    entityRefs: z.array(z.string().max(256)).optional(),
+    supersedesId: z.string().max(512).optional(),
+    traces: z.array(z.unknown()).optional(),
+  }),
+) as z.ZodType<CodegraphSurfaceRequest>;
+
 // ---------------------------------------------------------------------------
 // coding_delta — session-delta surface (issue #1548 Track A PR 4)
 // ---------------------------------------------------------------------------
@@ -304,11 +353,221 @@ export const codingDeltaOperation = defineOperation<
  * the boundary owns today. The fitness test treats this set as the migrated
  * set; everything else on a surface is unmigrated and counted by the ratchet.
  */
+export const codegraphIndexOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_index",
+  description:
+    "Codegraph parity tool (issue #1554): index. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphListProjectsOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_list_projects",
+  description:
+    "Codegraph parity tool (issue #1554): list_projects. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphDeleteProjectOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_delete_project",
+  description:
+    "Codegraph parity tool (issue #1554): delete_project. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphIndexStatusOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_index_status",
+  description:
+    "Codegraph parity tool (issue #1554): index_status. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphSearchGraphOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_search_graph",
+  description:
+    "Codegraph parity tool (issue #1554): search_graph. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphTracePathOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_trace_path",
+  description:
+    "Codegraph parity tool (issue #1554): trace_path. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphDetectChangesOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_detect_changes",
+  description:
+    "Codegraph parity tool (issue #1554): detect_changes. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphQueryGraphOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_query_graph",
+  description:
+    "Codegraph parity tool (issue #1554): query_graph. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphGetSchemaOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_get_schema",
+  description:
+    "Codegraph parity tool (issue #1554): get_schema. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphGetSnippetOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_get_snippet",
+  description:
+    "Codegraph parity tool (issue #1554): get_snippet. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphGetArchitectureOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_get_architecture",
+  description:
+    "Codegraph parity tool (issue #1554): get_architecture. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphSearchCodeOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_search_code",
+  description:
+    "Codegraph parity tool (issue #1554): search_code. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphManageAdrOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_manage_adr",
+  description:
+    "Codegraph parity tool (issue #1554): manage_adr. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
+export const codegraphIngestTracesOperation = defineOperation<
+  CodegraphSurfaceRequest,
+  { result: CodegraphSurfaceResponse }
+>({
+  name: "codegraph_ingest_traces",
+  description:
+    "Codegraph parity tool (issue #1554): ingest_traces. Delegates to the shared codegraph surface handler.",
+  schema: codegraphSurfaceSchema,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codegraphTool(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
 export const REGISTERED_OPERATIONS = [
   memoryGetOperation.spec.name,
   memorySearchOperation.spec.name,
   memoryStoreOperation.spec.name,
   codingDecisionOperation.spec.name,
   codingArchitectureOperation.spec.name,
+  codegraphIndexOperation.spec.name,
+  codegraphListProjectsOperation.spec.name,
+  codegraphDeleteProjectOperation.spec.name,
+  codegraphIndexStatusOperation.spec.name,
+  codegraphSearchGraphOperation.spec.name,
+  codegraphTracePathOperation.spec.name,
+  codegraphDetectChangesOperation.spec.name,
+  codegraphQueryGraphOperation.spec.name,
+  codegraphGetSchemaOperation.spec.name,
+  codegraphGetSnippetOperation.spec.name,
+  codegraphGetArchitectureOperation.spec.name,
+  codegraphSearchCodeOperation.spec.name,
+  codegraphManageAdrOperation.spec.name,
+  codegraphIngestTracesOperation.spec.name,
   codingDeltaOperation.spec.name,
 ] as const;

package/src/access-service.ts

@@ -1,6 +1,7 @@
 import { stat } from "node:fs/promises";
 import * as nodeFs from "node:fs/promises";
 import { constants as fsConstants } from "node:fs";
+import { readdirSync, unlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { ZodError } from "zod";
 import { AccessIdempotencyStore, hashAccessIdempotencyPayload } from "./access-idempotency.js";
@@ -28,6 +29,19 @@ import {
   ARCHITECTURE_CARD_TAG,
 } from "./coding/architecture-surfaces.js";
 import { buildArchitectureCard, createArchitectureCardSummariser } from "./coding/architecture-card.js";
+import {
+  handleCodegraphTool,
+  type CodegraphSurfaceContext,
+  type CodegraphSurfaceRequest,
+  type CodegraphSurfaceResponse,
+} from "./coding/codegraph-surfaces.js";
+import {
+  codegraphSurfaceVisible,
+  getCodegraphStore,
+  makeCodegraphRuntimeDelegates,
+  resolveCodegraphProjectId,
+  type CodegraphStore,
+} from "./coding/codegraph-runtime.js";
 import {
   handleCodingDelta,
   type DeltaSurfaceRequest,
@@ -4463,6 +4477,65 @@ export class EngramAccessService {
     };
   }
 
+  /**
+   * Codegraph parity tool delegate (issue #1554). All three surfaces (MCP,
+   * HTTP, CLI) arrive here via the codegraph_* boundary operations. The
+   * handler lives in coding/codegraph-surfaces.ts; this method just wires
+   * the context. Memory dir + principal + coding-context lookup come from
+   * the orchestrator/access-service fabric -- no handler-side state.
+   */
+  async codegraphTool(
+    request: CodegraphSurfaceRequest,
+    authenticatedPrincipal?: string,
+  ): Promise<CodegraphSurfaceResponse> {
+    const principal = authenticatedPrincipal ?? "default";
+    const memoryDir = this.orchestrator.config.memoryDir;
+    const ctx: CodegraphSurfaceContext = {
+      config: this.orchestrator.config,
+      memoryDir,
+      principal,
+      getCodingContext: (sk) => this.orchestrator.getCodingContextForSession(sk),
+      // Project resolution chokepoint lives in codegraph-runtime.ts so every
+      // store-backed tool derives the same id and the tagged error flows back
+      // as a structured response (issue #1554 threads 7/9/11). Thin wiring.
+      resolveStore: async (req) => {
+        const projectId = resolveCodegraphProjectId({
+          request: req,
+          getCodingContext: (sk) => this.orchestrator.getCodingContextForSession(sk),
+        });
+        return getCodegraphStore({
+          config: this.orchestrator.config,
+          memoryDir,
+          principal,
+          projectId,
+          repoRoot: req.repoRoot,
+        }) as Promise<CodegraphStore>;
+      },
+      listDirs: (dir) => {
+        try {
+          return readdirSync(dir) as readonly string[];
+        } catch {
+          return [];
+        }
+      },
+      removeFile: (filePath) => unlinkSync(filePath), // propagate failures → deleteCodegraphProject classifies (thread 7)
+      throwInputError: (msg) => {
+        throw new EngramAccessInputError(msg);
+      },
+      delegateDecisionRecord: async (decisionRequest) => {
+        return this.codingDecision(decisionRequest, authenticatedPrincipal);
+      },
+      buildArchitectureCard: async (repoRoot) => {
+        return buildArchitectureCard(repoRoot, {
+          llmSummary: this.orchestrator.config.codingKnowledge?.architectureCardLlmSummary === true,
+          summariser: createArchitectureCardSummariser(this.fallbackLlmRef ?? this.localLlmRef),
+        });
+      },
+      ...makeCodegraphRuntimeDelegates(),
+    };
+    return handleCodegraphTool(request, ctx);
+  }
+
   /** Whether the coding_decision tool should appear in tools/list (rule 39). */
   get decisionRecordSurfaceVisible(): boolean {
     return this.orchestrator.config.codingKnowledge?.enabled === true
@@ -4507,6 +4580,15 @@ export class EngramAccessService {
     return this.orchestrator.config.codingKnowledge?.enabled === true
       && this.orchestrator.config.codingKnowledge?.architectureCard === true;
   }
+
+  /**
+   * Whether the 14 codegraph parity tools should appear in tools/list
+   * (rule 39). Config-only -- runtime availability is checked at call time.
+   * When false the tools array is byte-identical to pre-feature.
+   */
+  get codegraphSurfaceVisible(): boolean {
+    return codegraphSurfaceVisible(this.orchestrator.config);
+  }
   /**
    * Thin delegate — handler logic in coding/architecture-surfaces.ts (#1548 PR3).
    * All three surfaces (MCP/HTTP/CLI) arrive here via the boundary operation.

package/src/access-surface-catalog.test.ts

@@ -67,7 +67,7 @@ function shortToolName(advertised: string): string {
 /** Spin up a server with emitLegacyTools=true and read the deduped short names. */
 async function liveMcpToolShortNames(): Promise<ReadonlySet<string>> {
   const stub = { briefingEnabled: true } as unknown as EngramAccessService;
-  const server = new EngramMcpServer(stub, { emitLegacyTools: true, codingDecisionVisible: true, architectureCardVisible: true, sessionDeltaVisible: true });
+  const server = new EngramMcpServer(stub, { emitLegacyTools: true, codingDecisionVisible: true, architectureCardVisible: true, codegraphVisible: true, sessionDeltaVisible: true });
   const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
   const result = (response as { result?: { tools?: Array<{ name: string }> } }).result;
   const names = new Set<string>();

package/src/access-surface-catalog.ts

@@ -74,6 +74,21 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "memory_store", operation: "memory_store" },
   { tool: "coding_decision", operation: "coding_decision" },
   { tool: "coding_architecture", operation: "coding_architecture" },
+  // codegraph parity tools (issue #1554)
+  { tool: "codegraph_index", operation: "codegraph_index" },
+  { tool: "codegraph_list_projects", operation: "codegraph_list_projects" },
+  { tool: "codegraph_delete_project", operation: "codegraph_delete_project" },
+  { tool: "codegraph_index_status", operation: "codegraph_index_status" },
+  { tool: "codegraph_search_graph", operation: "codegraph_search_graph" },
+  { tool: "codegraph_trace_path", operation: "codegraph_trace_path" },
+  { tool: "codegraph_detect_changes", operation: "codegraph_detect_changes" },
+  { tool: "codegraph_query_graph", operation: "codegraph_query_graph" },
+  { tool: "codegraph_get_schema", operation: "codegraph_get_schema" },
+  { tool: "codegraph_get_snippet", operation: "codegraph_get_snippet" },
+  { tool: "codegraph_get_architecture", operation: "codegraph_get_architecture" },
+  { tool: "codegraph_search_code", operation: "codegraph_search_code" },
+  { tool: "codegraph_manage_adr", operation: "codegraph_manage_adr" },
+  { tool: "codegraph_ingest_traces", operation: "codegraph_ingest_traces" },
   { tool: "coding_delta", operation: "coding_delta" },
   { tool: "suggestion_submit", operation: null },
   { tool: "entity_get", operation: null },

package/src/cli.ts

@@ -2803,6 +2803,7 @@ export async function runAccessMcpServeCliCommand(
       emitLegacyTools: options.emitLegacyTools,
       codingDecisionVisible: service.decisionRecordSurfaceVisible,
       architectureCardVisible: service.architectureCardSurfaceVisible,
+      codegraphVisible: service.codegraphSurfaceVisible,
       sessionDeltaVisible: service.sessionDeltaSurfaceVisible,
     });
   await server.runStdio(options.stdin ?? process.stdin, options.stdout ?? process.stdout);

package/src/coding/architecture-surfaces.test.ts

@@ -53,6 +53,8 @@ const DEFAULT_CONFIG: CodingKnowledgeConfig = {
   architectureCardLlmSummary: false,
   structuralProvider: "none",
   structuralProviderCommand: "",
+  codegraphTools: false,
+  codegraphDbDir: "",
 };
 
 const CODING_CONTEXT: CodingContext = {