@remnic/core 9.3.692 → 9.3.694

package/src/access-mcp.ts

@@ -111,6 +111,22 @@ 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",
 };
 
 function resolveChatGptInspectorRecallSessionKey(
@@ -331,6 +347,13 @@ 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(
     private readonly service: EngramAccessService,
@@ -341,6 +364,8 @@ export class EngramMcpServer {
       emitLegacyTools?: boolean;
       codingDecisionVisible?: boolean;
       architectureCardVisible?: boolean;
+      codegraphVisible?: boolean;
+      sessionDeltaVisible?: boolean;
     } = {},
   ) {
     this.citationsEnabled = options.citationsEnabled === true;
@@ -348,6 +373,8 @@ 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() ||
       readEnvVar("OPENCLAW_ENGRAM_ACCESS_PRINCIPAL")?.trim() ||
@@ -2033,6 +2060,95 @@ 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(
+        {
+          name: "engram.coding_delta",
+          description:
+            "Get the session delta (commits + touched files since last seen) for the session's coding namespace (issue #1548 Track A PR 4). Subcommand: get.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              subcommand: {
+                type: "string",
+                enum: ["get"],
+                description: "Which delta operation to run.",
+              },
+              sessionKey: { type: "string", description: "Session identifier whose coding context scopes the operation." },
+              namespace: { type: "string", description: "Optional explicit namespace (overrides coding-context overlay)." },
+            },
+            required: ["subcommand"],
+            additionalProperties: false,
+          },
+        },
+        this.emitLegacyTools,
+      );
+      this.tools = [...this.tools, ...deltaTools];
+    }
   }
 
   /** Get clientInfo for a specific MCP session. Returns undefined for non-MCP requests. */
@@ -2394,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,16 @@ 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,
+  type DeltaSurfaceResponse,
+} from "./coding/session-delta-surfaces.js";
 
 // ---------------------------------------------------------------------------
 // memory_get — fetch one memory by id
@@ -250,6 +260,90 @@ 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)
+// ---------------------------------------------------------------------------
+
+const codingDeltaSchema = 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({
+    subcommand: z.enum(DELTA_SUBCOMMANDS),
+    sessionKey: z.string().trim().max(512).optional(),
+    namespace: z.string().trim().max(256).optional(),
+  }),
+);
+
+export type CodingDeltaInput = DeltaSurfaceRequest;
+export type CodingDeltaOutput = { result: DeltaSurfaceResponse };
+
+export const codingDeltaOperation = defineOperation<
+  CodingDeltaInput,
+  CodingDeltaOutput
+>({
+  name: "coding_delta",
+  description:
+    "Get the session delta (commits + touched files since last seen) for the session's coding namespace (issue #1548 Track A PR 4).",
+  schema: codingDeltaSchema as z.ZodType<CodingDeltaInput>,
+  handler: async (input, ctx) => {
+    const result = await ctx.service.codingDelta(input, ctx.authenticatedPrincipal);
+    return { result };
+  },
+});
+
 // ---------------------------------------------------------------------------
 // Surface registration map — what each transport calls the pilot ops
 // ---------------------------------------------------------------------------
@@ -259,10 +353,221 @@ export const codingArchitectureOperation = 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,26 @@ 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,
+  type DeltaSurfaceResponse,
+  type DeltaSurfaceStorage,
+} from "./coding/session-delta-surfaces.js";
+import { defaultGitInvoker } from "./coding/git-context.js";
 import { createVersion } from "./page-versioning.js";
 import { WorkStorage } from "./work/storage.js";
 import {
@@ -4456,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
@@ -4500,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.
@@ -4545,6 +4634,54 @@ export class EngramAccessService {
     });
   }
 
+  /** Whether the coding_delta tool should appear in tools/list (rule 39). */
+  get sessionDeltaSurfaceVisible(): boolean {
+    return this.orchestrator.config.codingKnowledge?.enabled === true
+      && this.orchestrator.config.codingKnowledge?.sessionDelta === true;
+  }
+  /**
+   * Thin delegate — handler logic in coding/session-delta-surfaces.ts (#1548 PR4).
+   * All three surfaces (MCP/HTTP/CLI) arrive here via the boundary operation.
+   * Namespace resolution uses the SAME coding-scoped read path as the other
+   * coding surfaces; the delta state file lives under
+   * `<memoryDir>/state/coding-knowledge/<namespace>.json`.
+   */
+  async codingDelta(
+    request: DeltaSurfaceRequest,
+    authenticatedPrincipal?: string,
+  ): Promise<DeltaSurfaceResponse> {
+    return handleCodingDelta(request, {
+      codingKnowledge: this.orchestrator.config.codingKnowledge,
+      getCodingContext: (sk) => this.orchestrator.getCodingContextForSession(sk),
+      resolveStorage: async (req) => {
+        const ns = await this.resolveCodingScopedReadableNamespace({
+          namespace: req.namespace,
+          sessionKey: req.sessionKey,
+          authenticatedPrincipal,
+        });
+        const storage = await this.orchestrator.getStorage(ns);
+        // Delta only needs memoryDir + namespace (no readAllMemories). Use the
+        // namespace-ROUTED root (storage.dir), not the global config.memoryDir:
+        // non-default namespaces route to memoryDir/namespaces/<token>, so
+        // session-delta markers must read/write from the routed tree, mirroring
+        // the decision/architecture siblings (cursor review).
+        return {
+          memoryDir: storage.dir,
+          namespace: ns,
+        } satisfies DeltaSurfaceStorage;
+      },
+      gitInvoker: (cwd, args) => {
+        // Reuse the existing defaultGitInvoker (2s timeout, never throws —
+        // the discipline git-context.ts already established). It returns
+        // { stdout, exitCode } so the handler can recover from non-zero
+        // exits without a try/catch.
+        const invoker = defaultGitInvoker();
+        return invoker(cwd, args);
+      },
+      throwInputError: (msg) => { throw new EngramAccessInputError(msg); },
+    });
+  }
+
   async memoryBrowse(
     request: EngramAccessMemoryBrowseRequest = {},
   ): Promise<EngramAccessMemoryBrowseResponse> {

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 });
+  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>();