@remnic/core 9.30.1 → 9.32.0

package/src/access-http-lifecycle-flush.ts

@@ -0,0 +1,81 @@
+import type { OperationName } from "./access-boundary.js";
+import { runLcmCompactionFlushHttp, runLcmCompactionRecordHttp } from "./access-http-lcm-compaction.js";
+import type { LcmCompactionFlushRequest, LcmCompactionRecordRequest } from "./access-schema.js";
+import type { EngramAccessExtractionForceFlushRequest, EngramAccessService } from "./access-service.js";
+
+export interface LifecycleFlushHttpDeps {
+  service: Pick<EngramAccessService, "extractionForceFlush" | "lcmCompactionFlush" | "lcmCompactionRecord">;
+  enforceTokenOp(op: OperationName): void;
+  defaultNamespace?: string;
+  readValidatedBody(schemaName: "lcmCompactionFlush"): Promise<LcmCompactionFlushRequest>;
+  readValidatedBody(schemaName: "lcmCompactionRecord"): Promise<LcmCompactionRecordRequest>;
+  readValidatedBody(schemaName: "extractionForceFlush"): Promise<EngramAccessExtractionForceFlushRequest>;
+  ensureWriteRateLimitAvailable(): void;
+  resolveNamespace(namespace: string | undefined): string | undefined;
+  resolveRequestPrincipal(): string | undefined;
+  recordWriteRateLimitHit(): void;
+  respondJson(payload: unknown): void;
+}
+
+export async function maybeHandleLifecycleFlush(
+  deps: LifecycleFlushHttpDeps,
+  method: string | undefined,
+  pathname: string,
+  abortSignal: AbortSignal
+): Promise<boolean> {
+  if (method !== "POST") return false;
+  if (pathname === "/engram/v1/lcm/compaction/flush" || pathname === "/remnic/v1/lcm/compaction/flush") {
+    deps.enforceTokenOp("lcm_compaction_flush");
+    const body = await deps.readValidatedBody("lcmCompactionFlush");
+    const response = await runLcmCompactionFlushHttp({
+      body,
+      service: deps.service,
+      ensureWriteRateLimitAvailable: deps.ensureWriteRateLimitAvailable,
+      recordWriteRateLimitHit: deps.recordWriteRateLimitHit,
+      resolveNamespace: deps.resolveNamespace,
+      defaultNamespace: deps.defaultNamespace,
+      resolveRequestPrincipal: deps.resolveRequestPrincipal,
+    });
+    deps.respondJson(response);
+    return true;
+  }
+
+  if (pathname === "/engram/v1/lcm/compaction/record" || pathname === "/remnic/v1/lcm/compaction/record") {
+    deps.enforceTokenOp("lcm_compaction_record");
+    const body = await deps.readValidatedBody("lcmCompactionRecord");
+    const response = await runLcmCompactionRecordHttp({
+      body,
+      service: deps.service,
+      ensureWriteRateLimitAvailable: deps.ensureWriteRateLimitAvailable,
+      recordWriteRateLimitHit: deps.recordWriteRateLimitHit,
+      resolveNamespace: deps.resolveNamespace,
+      resolveRequestPrincipal: deps.resolveRequestPrincipal,
+    });
+    deps.respondJson(response);
+    return true;
+  }
+
+  if (pathname === "/engram/v1/extraction/flush" || pathname === "/remnic/v1/extraction/flush") {
+    deps.enforceTokenOp("extraction_force_flush");
+    const body = await deps.readValidatedBody("extractionForceFlush");
+    deps.ensureWriteRateLimitAvailable();
+    let writeRateLimitRecorded = false;
+    const recordCommittedWrite = (): void => {
+      if (writeRateLimitRecorded) return;
+      writeRateLimitRecorded = true;
+      deps.recordWriteRateLimitHit();
+    };
+    const response = await deps.service.extractionForceFlush({
+      ...body,
+      namespace: deps.resolveNamespace(body.namespace),
+      authenticatedPrincipal: deps.resolveRequestPrincipal(),
+      abortSignal,
+      onCommitted: recordCommittedWrite,
+    });
+    recordCommittedWrite();
+    deps.respondJson(response);
+    return true;
+  }
+
+  return false;
+}

package/src/access-http.test.ts

@@ -203,6 +203,72 @@ test("HTTP batch LCM flush isolates namespace failures and charges one write quo
   }
 });
 
+test("HTTP LCM compaction record uses the lifecycle route and write quota", async () => {
+  const calls: unknown[] = [];
+  const service = {
+    lcmCompactionRecord: async (request: unknown) => {
+      calls.push(request);
+      return { enabled: true, recorded: true, sessionKey: "record-session" };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/record`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "record-session",
+        namespace: "team-a",
+        tokensBefore: 100,
+        tokensAfter: 40,
+      }),
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), {
+      enabled: true,
+      recorded: true,
+      sessionKey: "record-session",
+    });
+    assert.deepEqual(calls, [
+      {
+        sessionKey: "record-session",
+        namespace: "team-a",
+        tokensBefore: 100,
+        tokensAfter: 40,
+        authenticatedPrincipal: undefined,
+      },
+    ]);
+
+    const rateLimited = await fetch(`http://127.0.0.1:${status.port}/engram/v1/lcm/compaction/record`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        sessionKey: "record-session",
+        tokensBefore: 120,
+        tokensAfter: 60,
+      }),
+    });
+    assert.equal(rateLimited.status, 429);
+    assert.equal(calls.length, 1);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP batch LCM flush deduplicates aliases after effective namespace resolution", async () => {
   const calls: Array<{ namespace?: string; sessionKey: string; authenticatedPrincipal?: string }> = [];
   const service = {
@@ -3172,6 +3238,167 @@ test("HTTP meetings build enforces the per-principal write rate limit (issue #19
     await server.stop();
   }
 });
+test("HTTP-MCP extraction force-flush aliases consume the write quota", async () => {
+  let flushes = 0;
+  const service = {
+    extractionForceFlush: async () => {
+      flushes += 1;
+      return {
+        flushed: true,
+        sessionKey: "session-1",
+        namespace: "default",
+        effectiveNamespace: "default",
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+  const status = await server.start();
+  try {
+    const responses: Response[] = [];
+    for (const name of ["remnic.extraction_force_flush", "engram.extraction_force_flush"]) {
+      responses.push(
+        await fetch(`http://127.0.0.1:${status.port}/mcp`, {
+          method: "POST",
+          headers: {
+            authorization: "Bearer test-token",
+            "content-type": "application/json",
+          },
+          body: JSON.stringify({
+            jsonrpc: "2.0",
+            id: name,
+            method: "tools/call",
+            params: {
+              name,
+              arguments: {
+                sessionKey: "session-1",
+                namespace: "default",
+                cwd: "/workspace/project",
+                projectTag: "Acme/Webshop",
+                deadlineMs: Date.now() + 60_000,
+              },
+            },
+          }),
+        }),
+      );
+    }
+    const [first, second] = responses;
+    assert.equal(first.status, 200);
+    await first.text();
+    assert.equal(second.status, 429);
+    const rateLimited = await second.json() as { code?: string };
+    assert.equal(rateLimited.code, "write_rate_limited");
+    assert.equal(flushes, 1, "the rate-limited alias must not reach the service");
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP extraction force-flush records quota after commit when cleanup fails", async () => {
+  let flushes = 0;
+  let committed = 0;
+  const service = {
+    extractionForceFlush: async (request: {
+      onCommitted?: () => void;
+    }) => {
+      flushes += 1;
+      request.onCommitted?.();
+      committed += 1;
+      throw new Error("retained cleanup deadline");
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+  const status = await server.start();
+  const flush = () =>
+    fetch(`http://127.0.0.1:${status.port}/engram/v1/extraction/flush`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({ sessionKey: "session-1" }),
+    });
+  try {
+    const first = await flush();
+    assert.equal(first.status, 500);
+    await first.text();
+    const second = await flush();
+    assert.equal(second.status, 429);
+    const rateLimited = await second.json() as { code?: string };
+    assert.equal(rateLimited.code, "write_rate_limited");
+    assert.equal(flushes, 1);
+    assert.equal(committed, 1);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP-MCP extraction force-flush records quota at the commit boundary", async () => {
+  let flushes = 0;
+  let committed = 0;
+  const service = {
+    extractionForceFlush: async (request: { onCommitted?: () => void }) => {
+      flushes += 1;
+      if (request.onCommitted) {
+        committed += 1;
+        request.onCommitted();
+      }
+      throw new Error("retained cleanup deadline");
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+    writeRateLimitMaxRequests: 1,
+  });
+  const status = await server.start();
+  const flush = () =>
+    fetch(`http://127.0.0.1:${status.port}/mcp`, {
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: "extraction-force-flush",
+        method: "tools/call",
+        params: {
+          name: "remnic.extraction_force_flush",
+          arguments: { sessionKey: "session-1" },
+        },
+      }),
+    });
+  try {
+    const first = await flush();
+    assert.equal(first.status, 200);
+    const firstBody = (await first.json()) as {
+      result?: { isError?: boolean; content?: Array<{ text?: string }> };
+    };
+    assert.equal(firstBody.result?.isError, true);
+    const second = await flush();
+    assert.equal(second.status, 429);
+    const rateLimited = (await second.json()) as { code?: string };
+    assert.equal(rateLimited.code, "write_rate_limited");
+    assert.equal(flushes, 1, "the rate-limited MCP flush must not reach the service");
+    assert.equal(committed, 1);
+  } finally {
+    await server.stop();
+  }
+});
 
 test("HTTP meetings get returns 400 (not 500) for a malformed percent-encoded id (issue #1900)", async () => {
   let called = 0;

package/src/access-http.ts

@@ -17,6 +17,7 @@ import {
   type EngramAccessMemoryResponse,
   type EngramAccessWriteResponse,
 } from "./access-service.js";
+import { maybeHandleLifecycleFlush, type LifecycleFlushHttpDeps } from "./access-http-lifecycle-flush.js";
 import { CorrectionContractError } from "./correction/correction-contract.js";
 import { WearablesInputError } from "./wearables/errors.js"; import { respondMeetingsList, respondMeetingsGet, respondMeetingsBuild } from "./meetings/http-glue.js";
 import { EngramMcpServer, MCP_SUPPORTED_PROTOCOL_VERSIONS } from "./access-mcp.js";
@@ -40,7 +41,7 @@ import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { getOperation, type OperationName } from "./access-boundary.js";
 import { authorizationProbeNamespaces, probeOperationAuthorization } from "./access-authorization-probe.js";
 import { resolveQueryNamespaceWritablePreflight } from "./access-namespace-preflight.js";
-import * as lcm from "./access-http-lcm-compaction.js";
+import { respondLcmCompactionCapabilitiesHttp } from "./access-http-lcm-compaction.js";
 import {
   assertOperationAllowed,
   capabilityAllowsOp,
@@ -890,7 +891,7 @@ export class EngramAccessHttpServer {
       this.respondJson(res, 200, await this.service.health());
       return;
     }
-    if (req.method === "GET" && pathname === "/engram/v1/capabilities") return lcm.respondLcmCompactionCapabilitiesHttp(res);
+    if (req.method === "GET" && pathname === "/engram/v1/capabilities") return respondLcmCompactionCapabilitiesHttp(res);
     if (req.method === "GET" && pathname === "/engram/v1/authorization") {
       res.setHeader("cache-control", "no-store");
       const probe = probeOperationAuthorization(tokenCapabilityStore.getStore(), parsed.searchParams.getAll("op"));
@@ -1668,41 +1669,9 @@ export class EngramAccessHttpServer {
       this.respondJson(res, 200, response);
       return;
     }
-
-    if (
-      req.method === "POST" &&
-      (pathname === "/engram/v1/lcm/compaction/flush" || pathname === "/remnic/v1/lcm/compaction/flush")
-    ) {
-      this.enforceTokenOp("lcm_compaction_flush"); // boundary dispatch (issue #1525)
-      const body = await this.readValidatedBody(req, "lcmCompactionFlush");
-      await lcm.handleLcmCompactionFlushHttp({
-        body, service: this.service,
-        response: res, ensureWriteRateLimitAvailable: () => this.ensureWriteRateLimitAvailable(req),
-        recordWriteRateLimitHit: () => this.recordWriteRateLimitHit(req),
-        resolveNamespace: (namespace) => this.resolveNamespace(req, namespace), defaultNamespace: this.service.configRef?.defaultNamespace,
-        resolveRequestPrincipal: () => this.resolveRequestPrincipal(req), respondJson: this.respondJson.bind(this),
-      });
-      return;
-    }
-
-    if (
-      req.method === "POST" &&
-      (pathname === "/engram/v1/lcm/compaction/record" || pathname === "/remnic/v1/lcm/compaction/record")
-    ) {
-      this.enforceTokenOp("lcm_compaction_record"); // boundary dispatch (issue #1525)
-      const body = await this.readValidatedBody(req, "lcmCompactionRecord");
-      this.ensureWriteRateLimitAvailable(req);
-      const response = await this.service.lcmCompactionRecord({
-        sessionKey: body.sessionKey,
-        namespace: this.resolveNamespace(req, body.namespace),
-        tokensBefore: body.tokensBefore,
-        tokensAfter: body.tokensAfter,
-        authenticatedPrincipal: this.resolveRequestPrincipal(req),
-      });
-      this.recordWriteRateLimitHit(req);
-      this.respondJson(res, 200, response);
-      return;
-    }
+    if (await maybeHandleLifecycleFlush(
+      this.lifecycleFlushDeps(req, res), req.method, pathname, abortSignal,
+    )) return;
 
     if (req.method === "GET" && pathname === "/engram/v1/lcm/status") {
       this.enforceTokenOp("lcm_status"); // boundary dispatch (issue #1525)
@@ -3218,6 +3187,8 @@ export class EngramAccessHttpServer {
         toolName === "remnic.observe" ||
         toolName === "engram.lcm_compaction_flush" ||
         toolName === "remnic.lcm_compaction_flush" ||
+        toolName === "engram.extraction_force_flush" ||
+        toolName === "remnic.extraction_force_flush" ||
         toolName === "engram.lcm_compaction_record" ||
         toolName === "remnic.lcm_compaction_record" ||
         toolName === "engram.capsule_export" ||
@@ -3254,6 +3225,16 @@ export class EngramAccessHttpServer {
     // the record). Other write tools keep the coarse pre-check.
     const observeSelfEnforcesQuota =
       toolName === "engram.observe" || toolName === "remnic.observe";
+    const extractionForceFlushWrite =
+      toolName === "engram.extraction_force_flush" || toolName === "remnic.extraction_force_flush";
+    let writeRateLimitRecorded = false;
+    const recordCommittedMcpWrite = extractionForceFlushWrite
+      ? () => {
+          if (writeRateLimitRecorded) return;
+          writeRateLimitRecorded = true;
+          this.recordWriteRateLimitHit(req);
+        }
+      : undefined;
     if (isMcpWrite && !observeSelfEnforcesQuota) {
       this.ensureWriteRateLimitAvailable(req);
     }
@@ -3296,6 +3277,7 @@ export class EngramAccessHttpServer {
       enforceWriteQuota: observeSelfEnforcesQuota
         ? () => this.ensureWriteRateLimitAvailable(req)
         : undefined,
+      recordWriteCommit: recordCommittedMcpWrite,
       sourceConnector: this.resolveConnector(req),
       abortSignal,
     });
@@ -3317,8 +3299,9 @@ export class EngramAccessHttpServer {
       // consumed a write — count it. Tools WITH structuredContent use the
       // dryRun/idempotencyReplay guards.
       const counts = structured ? this.shouldCountWriteRateLimit(structured) : true;
-      if (!isError && !isRejectedCodegraph && counts) {
+      if (!writeRateLimitRecorded && !isError && !isRejectedCodegraph && counts) {
         this.recordWriteRateLimitHit(req);
+        writeRateLimitRecorded = true;
       }
     }
     // A mutating tool may have committed just before the client disconnected.
@@ -3621,7 +3604,6 @@ export class EngramAccessHttpServer {
     }
     return parsed;
   }
-
   private parseOptionalBooleanHeader(
     req: IncomingMessage,
     name: string,
@@ -3633,7 +3615,18 @@ export class EngramAccessHttpServer {
     if (raw === "false") return false;
     throw new EngramAccessInputError(`${name} header must be one of: true, false`);
   }
-
+  private lifecycleFlushDeps(req: IncomingMessage, res: ServerResponse): LifecycleFlushHttpDeps {
+    const readValidatedBody = ((schemaName: SchemaName) => this.readValidatedBody(req, schemaName)) as LifecycleFlushHttpDeps["readValidatedBody"];
+    return { service: this.service, defaultNamespace: this.service.configRef?.defaultNamespace,
+      enforceTokenOp: (op) => this.enforceTokenOp(op),
+      readValidatedBody,
+      ensureWriteRateLimitAvailable: () => this.ensureWriteRateLimitAvailable(req),
+      resolveNamespace: (namespace) => this.resolveNamespace(req, namespace),
+      resolveRequestPrincipal: () => this.resolveRequestPrincipal(req),
+      recordWriteRateLimitHit: () => this.recordWriteRateLimitHit(req),
+      respondJson: (payload) => this.respondJson(res, 200, payload),
+    };
+  }
   private async readValidatedBody<S extends SchemaName>(
     req: IncomingMessage,
     schemaName: S,

package/src/access-mcp-output-schemas.ts

@@ -167,6 +167,12 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     sessionKey: T_STRING,
     namespace: T_STRING,
   }),
+  extraction_force_flush: objectSchema({
+    flushed: T_BOOLEAN,
+    sessionKey: T_STRING,
+    namespace: T_STRING,
+    effectiveNamespace: T_STRING,
+  }),
   lcm_compaction_record: objectSchema({
     enabled: T_BOOLEAN,
     recorded: T_BOOLEAN,

package/src/access-mcp.test.ts

@@ -850,17 +850,57 @@ test("MCP LCM compaction flush dispatches sanitized args to the access service",
     makeToolRequest("remnic.lcm_compaction_flush", {
       sessionKey: "pi:session",
       namespace: "work",
+      cwd: "/workspace/project",
+      projectTag: "Acme/Webshop",
     }),
   );
 
   assert.deepEqual(received, {
     sessionKey: "pi:session",
     namespace: "work",
+    cwd: "/workspace/project",
+    projectTag: "Acme/Webshop",
     authenticatedPrincipal: undefined,
   });
   assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
 });
 
+test("MCP extraction force-flush dispatches scope, deadline, and cancellation to the access service", async () => {
+  let received: Record<string, unknown> | undefined;
+  const service = {
+    ...makeMockService(),
+    extractionForceFlush: async (args: Record<string, unknown>) => {
+      received = args;
+      return { flushed: true, sessionKey: "pi:session", namespace: "work", effectiveNamespace: "work" };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+  const abortController = new AbortController();
+
+  const response = await server.handleRequest(
+    makeToolRequest("remnic.extraction_force_flush", {
+      sessionKey: "pi:session",
+      namespace: "work",
+      cwd: "/workspace/project",
+      projectTag: "Acme/Webshop",
+      deadlineMs: 1_900_000_000_000,
+    }),
+    { abortSignal: abortController.signal },
+  );
+
+  assert.deepEqual(received, {
+    sessionKey: "pi:session",
+    namespace: "work",
+    cwd: "/workspace/project",
+    projectTag: "Acme/Webshop",
+    deadlineMs: 1_900_000_000_000,
+    authenticatedPrincipal: undefined,
+    onCommitted: undefined,
+    abortSignal: abortController.signal,
+  });
+  assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+});
+
 test("MCP tools/list exposes LCM compaction tools under remnic aliases", async () => {
   const server = new EngramMcpServer(makeMockService());
 

package/src/access-mcp.ts

@@ -72,6 +72,12 @@ type McpRequestOptions = {
    * the write-rate-limit window); the standalone MCP server has no quota.
    */
   enforceWriteQuota?: () => void | Promise<void>;
+  /**
+   * Called once when a lifecycle write reaches its durable commit boundary.
+   * HTTP transports use this to account writes even when post-commit work
+   * fails or the client disconnects before a response is available.
+   */
+  recordWriteCommit?: () => void;
   /**
    * Server-resolved connector identity (Phase 1 provenance). Set by the HTTP
    * auth boundary from the matched token entry's connector; threaded into
@@ -207,6 +213,7 @@ const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   "engram.observe": "observe",
   "engram.lcm_search": "lcm_search",
   "engram.lcm_compaction_flush": "lcm_compaction_flush",
+  "engram.extraction_force_flush": "extraction_force_flush",
   "engram.lcm_compaction_record": "lcm_compaction_record",
   "engram.continuity_audit_generate": "continuity_audit_generate",
   "engram.continuity_incident_open": "continuity_incident_open",
@@ -1062,6 +1069,24 @@ export class EngramMcpServer {
           properties: {
             sessionKey: { type: "string", description: "Conversation session identifier" },
             namespace: { type: "string" },
+            cwd: { type: "string", description: "Working directory for auto git-context resolution." },
+            projectTag: { type: "string", description: "Project tag for non-git project scoping." },
+          },
+          required: ["sessionKey"],
+          additionalProperties: false,
+        },
+      },
+      {
+        name: "engram.extraction_force_flush",
+        description: "Force-drain a session extraction buffer before a lifecycle boundary.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            sessionKey: { type: "string", description: "Conversation session identifier" },
+            namespace: { type: "string" },
+            cwd: { type: "string", description: "Working directory for auto git-context resolution." },
+            projectTag: { type: "string", description: "Project tag for non-git project scoping." },
+            deadlineMs: { type: "number", minimum: 0 },
           },
           required: ["sessionKey"],
           additionalProperties: false,
@@ -2413,6 +2438,7 @@ export class EngramMcpServer {
           options?.sessionId,
           mcpScope,
           options?.enforceWriteQuota,
+          options?.recordWriteCommit,
           options?.sourceConnector,
           options?.abortSignal,
         );
@@ -2629,6 +2655,7 @@ export class EngramMcpServer {
     mcpSessionId?: string,
     scope?: { namespace?: string; sessionKey?: string },
     enforceWriteQuota?: () => void | Promise<void>,
+    recordWriteCommit?: () => void,
     sourceConnector?: string,
     abortSignal?: AbortSignal,
   ): Promise<unknown> {
@@ -2659,6 +2686,8 @@ export class EngramMcpServer {
       envelope = parseMcpRequest("observe", args);
     } else if (migrated === "lcm_compaction_flush") {
       envelope = parseMcpRequest("lcmCompactionFlush", args);
+    } else if (migrated === "extraction_force_flush") {
+      envelope = parseMcpRequest("extractionForceFlush", args);
     } else if (migrated === "lcm_compaction_record") {
       envelope = parseMcpRequest("lcmCompactionRecord", args);
     } else if (migrated.startsWith("codegraph_")) {
@@ -2730,7 +2759,9 @@ export class EngramMcpServer {
     const output = (await op.run(envelope, {
       service: this.service,
       authenticatedPrincipal: effectivePrincipal,
-      ...(enforceWriteQuota ? { hooks: { enforceWriteQuota } } : {}),
+      ...(enforceWriteQuota || recordWriteCommit
+        ? { hooks: { ...(enforceWriteQuota ? { enforceWriteQuota } : {}), ...(recordWriteCommit ? { recordWriteCommit } : {}) } }
+        : {}),
       ...(sourceConnector ? { sourceConnector } : {}),
       ...(abortSignal ? { abortSignal } : {}),
     })) as { result: unknown };