@remnic/core 9.7.6 → 9.7.7

package/dist/cli.js

@@ -90,7 +90,7 @@ import {
   runWorkProductStatusCliCommand,
   runWorkProjectCliCommand,
   runWorkTaskCliCommand
-} from "./chunk-3UPBVNBX.js";
+} from "./chunk-Q6JPMCPO.js";
 import "./chunk-MMACM5G2.js";
 import "./chunk-54BGIBCR.js";
 import "./chunk-H4CKS5B2.js";
@@ -169,7 +169,7 @@ import "./chunk-G6NKALRN.js";
 import "./chunk-OO42R444.js";
 import "./chunk-K6MV3TRQ.js";
 import "./chunk-OADWQ5CR.js";
-import "./chunk-ESE55PZJ.js";
+import "./chunk-NMMKRVUF.js";
 import "./chunk-V7IZKJI3.js";
 import "./chunk-SEDEKFYQ.js";
 import "./chunk-RKNJBZ55.js";
@@ -178,13 +178,13 @@ import "./chunk-RSUYKGGZ.js";
 import "./chunk-42NQ7AVG.js";
 import "./chunk-TMSXWOBZ.js";
 import "./chunk-7RXCMVFQ.js";
-import "./chunk-BFCQPJ5B.js";
+import "./chunk-CHVU4RE5.js";
 import "./chunk-IC2TCZJ2.js";
 import "./chunk-D24OXEPB.js";
 import "./chunk-5RUE3GHQ.js";
-import "./chunk-3CRHW42H.js";
+import "./chunk-FYKIEOG6.js";
 import "./chunk-2MR3MFQB.js";
-import "./chunk-P2UA6XQG.js";
+import "./chunk-UHGHTOR5.js";
 import "./chunk-HLTAPHZZ.js";
 import "./chunk-YF6FMLBT.js";
 import "./chunk-W4PGTAS2.js";
@@ -192,7 +192,7 @@ import "./chunk-KQDNAXOM.js";
 import "./chunk-35NN3ZFA.js";
 import "./chunk-FTYDWKO6.js";
 import "./chunk-T4WDJPEZ.js";
-import "./chunk-TBQ4CFIP.js";
+import "./chunk-57INMZ6F.js";
 import "./chunk-D7FOKIY5.js";
 import "./chunk-CNWC274T.js";
 import "./chunk-GDASG7NC.js";

package/dist/connectors/index.d.ts

@@ -319,9 +319,16 @@ declare function upsertHermesConfig(opts: {
 /**
  * Remove the `remnic:` block from a Hermes profile config.yaml.
  * Idempotent — if the block is absent, returns skipped.
+ *
+ * `extraConfigPaths` carries the config.yaml location persisted in the
+ * connector JSON at install time, so a HERMES_HOME change between install and
+ * remove cannot leave the old home's remnic: block (with its daemon token)
+ * behind (Codex P2 on PR #1938, round 6). Extra candidates are shape-guarded
+ * and de-duplicated against the environment-resolved paths.
  */
 declare function removeHermesConfig(opts: {
     profile: string;
+    extraConfigPaths?: readonly string[];
 }): HermesConfigResult;
 declare function doctorConnector(connectorId: string): Promise<DoctorResult>;
 interface CodexMemoryExtensionPaths {

package/dist/connectors/index.js

@@ -22,7 +22,7 @@ import {
   upsertHermesConfig,
   validateMarketplaceManifest,
   writeMarketplaceManifest
-} from "../chunk-H67QFYUK.js";
+} from "../chunk-UJBESW6X.js";
 import "../chunk-4OKLXWDZ.js";
 import {
   runCodexMaterialize

package/dist/index.js

@@ -185,7 +185,7 @@ import {
   saveRegistry,
   validateMarketplaceManifest,
   writeMarketplaceManifest
-} from "./chunk-H67QFYUK.js";
+} from "./chunk-UJBESW6X.js";
 import "./chunk-V5OCT34X.js";
 import "./chunk-TECVW3JP.js";
 import "./chunk-LXOM6IQU.js";
@@ -348,7 +348,7 @@ import {
   registerTrainingExportAdapter,
   runBulkImportCliCommand,
   runWearablesCliCommand
-} from "./chunk-3UPBVNBX.js";
+} from "./chunk-Q6JPMCPO.js";
 import "./chunk-MMACM5G2.js";
 import "./chunk-54BGIBCR.js";
 import "./chunk-H4CKS5B2.js";
@@ -551,7 +551,7 @@ import "./chunk-K6MV3TRQ.js";
 import "./chunk-OADWQ5CR.js";
 import {
   EngramAccessHttpServer
-} from "./chunk-ESE55PZJ.js";
+} from "./chunk-NMMKRVUF.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -565,7 +565,7 @@ import "./chunk-TMSXWOBZ.js";
 import "./chunk-7RXCMVFQ.js";
 import {
   EngramMcpServer
-} from "./chunk-BFCQPJ5B.js";
+} from "./chunk-CHVU4RE5.js";
 import "./chunk-IC2TCZJ2.js";
 import {
   buildCitationGuidance,
@@ -574,7 +574,7 @@ import {
   sanitizeNoteForCitation
 } from "./chunk-D24OXEPB.js";
 import "./chunk-5RUE3GHQ.js";
-import "./chunk-3CRHW42H.js";
+import "./chunk-FYKIEOG6.js";
 import {
   formatZodError,
   memoryStoreRequestSchema,
@@ -583,7 +583,7 @@ import {
   suggestionSubmitRequestSchema,
   validateRequest
 } from "./chunk-2MR3MFQB.js";
-import "./chunk-P2UA6XQG.js";
+import "./chunk-UHGHTOR5.js";
 import "./chunk-HLTAPHZZ.js";
 import "./chunk-YF6FMLBT.js";
 import {
@@ -616,7 +616,7 @@ import {
 } from "./chunk-T4WDJPEZ.js";
 import {
   OPERATION_NAMES
-} from "./chunk-TBQ4CFIP.js";
+} from "./chunk-57INMZ6F.js";
 import {
   TOKEN_CAPABILITIES_VERSION,
   capabilityAllowsNamespace,

package/dist/orchestrator.js

@@ -67,7 +67,7 @@ import "./chunk-O7BBFJLP.js";
 import "./chunk-7N4KAIGN.js";
 import "./chunk-AD2KK5MT.js";
 import "./chunk-5CJVLG3H.js";
-import "./chunk-H67QFYUK.js";
+import "./chunk-UJBESW6X.js";
 import "./chunk-V5OCT34X.js";
 import "./chunk-TECVW3JP.js";
 import "./chunk-LXOM6IQU.js";
@@ -126,7 +126,7 @@ import "./chunk-Q6IP2ARR.js";
 import "./chunk-6HEM6HTQ.js";
 import "./chunk-ZQ7UBUZ6.js";
 import "./chunk-HXDKC3BI.js";
-import "./chunk-3UPBVNBX.js";
+import "./chunk-Q6JPMCPO.js";
 import "./chunk-MMACM5G2.js";
 import "./chunk-54BGIBCR.js";
 import "./chunk-H4CKS5B2.js";
@@ -218,7 +218,7 @@ import "./chunk-G6NKALRN.js";
 import "./chunk-OO42R444.js";
 import "./chunk-K6MV3TRQ.js";
 import "./chunk-OADWQ5CR.js";
-import "./chunk-ESE55PZJ.js";
+import "./chunk-NMMKRVUF.js";
 import "./chunk-V7IZKJI3.js";
 import "./chunk-SEDEKFYQ.js";
 import "./chunk-RKNJBZ55.js";
@@ -227,13 +227,13 @@ import "./chunk-RSUYKGGZ.js";
 import "./chunk-42NQ7AVG.js";
 import "./chunk-TMSXWOBZ.js";
 import "./chunk-7RXCMVFQ.js";
-import "./chunk-BFCQPJ5B.js";
+import "./chunk-CHVU4RE5.js";
 import "./chunk-IC2TCZJ2.js";
 import "./chunk-D24OXEPB.js";
 import "./chunk-5RUE3GHQ.js";
-import "./chunk-3CRHW42H.js";
+import "./chunk-FYKIEOG6.js";
 import "./chunk-2MR3MFQB.js";
-import "./chunk-P2UA6XQG.js";
+import "./chunk-UHGHTOR5.js";
 import "./chunk-HLTAPHZZ.js";
 import "./chunk-YF6FMLBT.js";
 import "./chunk-W4PGTAS2.js";
@@ -241,7 +241,7 @@ import "./chunk-KQDNAXOM.js";
 import "./chunk-35NN3ZFA.js";
 import "./chunk-FTYDWKO6.js";
 import "./chunk-T4WDJPEZ.js";
-import "./chunk-TBQ4CFIP.js";
+import "./chunk-57INMZ6F.js";
 import "./chunk-D7FOKIY5.js";
 import "./chunk-CNWC274T.js";
 import "./chunk-GDASG7NC.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.7.6",
+  "version": "9.7.7",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3000,7 +3000,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.7.6"
+    "@remnic/coding-graph": "^9.7.7"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-boundary.ts

@@ -193,6 +193,8 @@ export interface OperationContext {
   readonly service: EngramAccessService;
   readonly authenticatedPrincipal?: string;
   readonly operatorPrincipal?: string;
+  /** Per-request cancellation supplied by transports that own a request lifecycle. */
+  readonly abortSignal?: AbortSignal;
   /** Server-resolved connector identity (Phase 1 provenance). Set by the HTTP auth boundary from the matched token's connector; flows to write handlers so frontmatter records which connector submitted the memory. Client-supplied values are always overridden. */
   readonly sourceConnector?: string;
   readonly hooks?: OperationHooks;

package/src/access-http.ts

@@ -854,7 +854,7 @@ export class EngramAccessHttpServer {
     }
 
     if (req.method === "POST" && pathname === "/mcp") {
-      await this.handleMcpRequest(req, res);
+      await this.handleMcpRequest(req, res, abortSignal);
       return;
     }
 
@@ -2982,7 +2982,11 @@ export class EngramAccessHttpServer {
     req.once("error", cleanup);
   }
 
-  private async handleMcpRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  private async handleMcpRequest(
+    req: IncomingMessage,
+    res: ServerResponse,
+    abortSignal: AbortSignal,
+  ): Promise<void> {
     // Reject requests that advertise an unknown MCP protocol version in
     // the streamable-HTTP `MCP-Protocol-Version` header. Absent or
     // valid → proceed. Unknown → 400 with a JSON-RPC-shaped error so
@@ -3143,6 +3147,7 @@ export class EngramAccessHttpServer {
         ? () => this.ensureWriteRateLimitAvailable()
         : undefined,
       sourceConnector: this.resolveConnector(req),
+      abortSignal,
     });
 
     if (isMcpWrite && response !== null) {
@@ -3166,6 +3171,14 @@ export class EngramAccessHttpServer {
         this.recordWriteRateLimitHit();
       }
     }
+    // A mutating tool may have committed just before the client disconnected.
+    // Record that side effect above, then honor cancellation before emitting
+    // any response. Read-only calls reach this guard without accounting.
+    if (abortSignal.aborted) {
+      throw isAbortError(abortSignal.reason)
+        ? abortSignal.reason
+        : abortError("HTTP client disconnected");
+    }
     if (response === null) {
       res.statusCode = 202;
       res.end();

package/src/access-mcp-cancellation.test.ts

@@ -0,0 +1,405 @@
+import assert from "node:assert/strict";
+import { request as httpRequest } from "node:http";
+import test from "node:test";
+
+import { abortError } from "./abort-error.js";
+import { EngramAccessHttpServer } from "./access-http.js";
+import { EngramMcpServer } from "./access-mcp.js";
+import { EngramAccessService, type EngramAccessRecallRequest } from "./access-service.js";
+
+function deferred<T = void>(): {
+  promise: Promise<T>;
+  resolve: (value: T | PromiseLike<T>) => void;
+  reject: (reason?: unknown) => void;
+} {
+  let resolve!: (value: T | PromiseLike<T>) => void;
+  let reject!: (reason?: unknown) => void;
+  const promise = new Promise<T>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise;
+    reject = rejectPromise;
+  });
+  return { promise, resolve, reject };
+}
+
+function waitFor<T>(promise: Promise<T>, timeoutMs = 1_000): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<never>((_resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error(`timed out after ${timeoutMs}ms`)), timeoutMs);
+      timer.unref?.();
+    }),
+  ]);
+}
+
+function mcpBody(
+  name: string,
+  args: Record<string, unknown> = { query: "slow recall" },
+): string {
+  return JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name, arguments: args },
+  });
+}
+
+function sendMcp(port: number, name: string): {
+  client: ReturnType<typeof httpRequest>;
+  response: Promise<string>;
+} {
+  const response = deferred<string>();
+  const client = httpRequest({
+    host: "127.0.0.1",
+    port,
+    path: "/mcp",
+    method: "POST",
+    headers: {
+      authorization: "Bearer test-token",
+      "content-type": "application/json",
+    },
+  }, (res) => {
+    const chunks: Buffer[] = [];
+    res.on("data", (chunk: Buffer) => chunks.push(chunk));
+    res.on("end", () => response.resolve(Buffer.concat(chunks).toString("utf8")));
+    res.on("error", response.reject);
+  });
+  client.on("error", (error) => response.reject(error));
+  client.end(mcpBody(name));
+  return { client, response: response.promise };
+}
+
+test("MCP recall aborts in-flight work without writing a JSON-RPC error after disconnect", async () => {
+  const recallStarted = deferred<void>();
+  const recallSettled = deferred<void>();
+  const forceRelease = deferred<void>();
+  let observedSignal: AbortSignal | undefined;
+  let responseStarted = false;
+  const service = {
+    recall: async (input: EngramAccessRecallRequest) => {
+      observedSignal = input.abortSignal;
+      recallStarted.resolve();
+      try {
+        await Promise.race([
+          forceRelease.promise,
+          new Promise<void>((_resolve, reject) => {
+            input.abortSignal?.addEventListener("abort", () => reject(input.abortSignal?.reason), { once: true });
+          }),
+        ]);
+      } finally {
+        recallSettled.resolve();
+      }
+      return {} as never;
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+
+  try {
+    const client = httpRequest({
+      host: "127.0.0.1",
+      port: status.port,
+      path: "/mcp",
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+    }, (res) => {
+      responseStarted = true;
+      res.resume();
+    });
+    client.on("error", () => {});
+    client.end(mcpBody("remnic.recall"));
+
+    await waitFor(recallStarted.promise);
+    assert.ok(observedSignal, "the HTTP request signal must reach the MCP recall service");
+    client.destroy();
+
+    await waitFor(recallSettled.promise);
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    assert.equal(observedSignal.aborted, true);
+    assert.equal(observedSignal.reason?.name, "AbortError");
+    assert.equal(responseStarted, false, "a disconnected client must not receive a JSON-RPC error response");
+  } finally {
+    forceRelease.resolve();
+    await server.stop();
+  }
+});
+
+test("MCP recall_xray forwards the signal and preserves the original AbortError", async () => {
+  const controller = new AbortController();
+  const reason = abortError("caller disconnected");
+  let observedSignal: AbortSignal | undefined;
+  const service = {
+    recallXray: async (input: { abortSignal?: AbortSignal }) => {
+      observedSignal = input.abortSignal;
+      controller.abort(reason);
+      return { snapshotFound: false };
+    },
+  } as unknown as EngramAccessService;
+  const mcp = new EngramMcpServer(service);
+
+  await assert.rejects(
+    mcp.handleRequest(
+      {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: "remnic.recall_xray", arguments: { query: "why" } },
+      },
+      { abortSignal: controller.signal },
+    ),
+    (error: unknown) => error === reason,
+  );
+  assert.equal(observedSignal, controller.signal);
+});
+
+test("MCP memory inspector forwards cancellation to its full recall", async () => {
+  const controller = new AbortController();
+  const reason = abortError("inspector caller disconnected");
+  let observedSignal: AbortSignal | undefined;
+  let actionConfidenceStarted = false;
+  const service = {
+    recallXray: async (input: { abortSignal?: AbortSignal }) => {
+      observedSignal = input.abortSignal;
+      controller.abort(reason);
+      throw input.abortSignal?.reason;
+    },
+    actionConfidence: async () => {
+      actionConfidenceStarted = true;
+      return {} as never;
+    },
+  } as unknown as EngramAccessService;
+  const mcp = new EngramMcpServer(service);
+
+  await assert.rejects(
+    mcp.handleRequest(
+      {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: "remnic.chatgpt_memory_inspector",
+          arguments: { query: "inspect this" },
+        },
+      },
+      { abortSignal: controller.signal },
+    ),
+    (error: unknown) => error === reason,
+  );
+  assert.equal(observedSignal, controller.signal);
+  assert.equal(actionConfidenceStarted, false);
+});
+
+test("standalone MCP calls leave recall cancellation undefined", async () => {
+  let observedSignal: AbortSignal | undefined;
+  const service = {
+    recall: async (input: EngramAccessRecallRequest) => {
+      observedSignal = input.abortSignal;
+      return {} as never;
+    },
+  } as unknown as EngramAccessService;
+  const mcp = new EngramMcpServer(service);
+
+  const response = await mcp.handleRequest({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "tools/call",
+    params: { name: "remnic.recall", arguments: { query: "live" } },
+  });
+
+  assert.equal(observedSignal, undefined);
+  assert.equal((response?.result as { isError?: boolean } | undefined)?.isError, false);
+});
+
+test("an already-aborted MCP write never starts and preserves the AbortError", async () => {
+  const controller = new AbortController();
+  const reason = abortError("caller disconnected before dispatch");
+  let writeStarted = false;
+  const service = {
+    memoryStore: async () => {
+      writeStarted = true;
+      return {} as never;
+    },
+  } as unknown as EngramAccessService;
+  const mcp = new EngramMcpServer(service);
+  controller.abort(reason);
+
+  await assert.rejects(
+    mcp.handleRequest(
+      {
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: {
+          name: "remnic.memory_store",
+          arguments: { content: "must not be stored", category: "fact" },
+        },
+      },
+      { abortSignal: controller.signal },
+    ),
+    (error: unknown) => error === reason,
+  );
+  assert.equal(writeStarted, false);
+});
+
+test("MCP write quota is recorded after commit even when the client disconnects before completion", async () => {
+  const mutationCommitted = deferred<void>();
+  const releaseOperation = deferred<void>();
+  const operationSettled = deferred<void>();
+  const requestAborted = deferred<void>();
+  let responseStarted = false;
+  const service = {
+    memoryStore: async () => {
+      mutationCommitted.resolve();
+      try {
+        await releaseOperation.promise;
+      } finally {
+        operationSettled.resolve();
+      }
+      return {
+        schemaVersion: 1,
+        operation: "memory_store",
+        namespace: "default",
+        dryRun: false,
+        accepted: true,
+        queued: false,
+        status: "stored",
+        memoryId: "committed-memory",
+      };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+  const serverHost = server as unknown as {
+    mcpServer: EngramMcpServer;
+    writeRequestTimestamps: number[];
+  };
+  const originalHandleRequest = serverHost.mcpServer.handleRequest.bind(serverHost.mcpServer);
+  serverHost.mcpServer.handleRequest = async (request, options) => {
+    options?.abortSignal?.addEventListener("abort", () => requestAborted.resolve(), { once: true });
+    return originalHandleRequest(request, options);
+  };
+  const status = await server.start();
+
+  try {
+    const client = httpRequest({
+      host: "127.0.0.1",
+      port: status.port,
+      path: "/mcp",
+      method: "POST",
+      headers: {
+        authorization: "Bearer test-token",
+        "content-type": "application/json",
+      },
+    }, (res) => {
+      responseStarted = true;
+      res.resume();
+    });
+    client.on("error", () => {});
+    client.end(mcpBody("remnic.memory_store", {
+      content: "committed before disconnect",
+      category: "fact",
+    }));
+
+    await waitFor(mutationCommitted.promise);
+    client.destroy();
+    await waitFor(requestAborted.promise);
+    releaseOperation.resolve();
+
+    await waitFor(operationSettled.promise);
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    assert.equal(serverHost.writeRequestTimestamps.length, 1);
+    assert.equal(responseStarted, false, "the disconnected client must not receive the committed write response");
+  } finally {
+    releaseOperation.resolve();
+    await server.stop();
+  }
+});
+
+test("a disconnected MCP recall queued on the budget lock never starts and does not poison the lock", async () => {
+  const firstStarted = deferred<void>();
+  const releaseFirst = deferred<void>();
+  const secondQueued = deferred<void>();
+  const secondAborted = deferred<void>();
+  const secondSettled = deferred<void>();
+  let secondStarted = false;
+  let thirdStarted = false;
+  let callCount = 0;
+
+  const lockService = Object.create(EngramAccessService.prototype) as EngramAccessService;
+  const lockHost = lockService as unknown as {
+    budgetLocks: Map<string, Promise<void>>;
+    withBudgetLock<T>(
+      principal: string,
+      abortSignal: AbortSignal | undefined,
+      operation: () => Promise<T>,
+    ): Promise<T>;
+  };
+  lockHost.budgetLocks = new Map();
+
+  const service = {
+    recall: async (input: EngramAccessRecallRequest) => {
+      callCount += 1;
+      const call = callCount;
+      if (call === 2) {
+        input.abortSignal?.addEventListener("abort", () => secondAborted.resolve(), { once: true });
+        secondQueued.resolve();
+      }
+      try {
+        return await lockHost.withBudgetLock("principal", input.abortSignal, async () => {
+          if (call === 1) {
+            firstStarted.resolve();
+            await releaseFirst.promise;
+          } else if (call === 2) {
+            secondStarted = true;
+          } else {
+            thirdStarted = true;
+          }
+          return {} as never;
+        });
+      } finally {
+        if (call === 2) secondSettled.resolve();
+      }
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+  const status = await server.start();
+
+  try {
+    const first = sendMcp(status.port, "remnic.recall");
+    await waitFor(firstStarted.promise);
+
+    const second = sendMcp(status.port, "remnic.recall");
+    second.response.catch(() => {});
+    await waitFor(secondQueued.promise);
+    second.client.destroy();
+    await waitFor(secondAborted.promise);
+    releaseFirst.resolve();
+
+    await waitFor(first.response);
+    await waitFor(secondSettled.promise);
+    assert.equal(secondStarted, false);
+
+    const third = sendMcp(status.port, "remnic.recall");
+    await waitFor(third.response);
+    assert.equal(thirdStarted, true);
+  } finally {
+    releaseFirst.resolve();
+    await server.stop();
+  }
+});