@remnic/core 9.66.4 → 9.66.5

package/package.json

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

package/src/access-http.ts

@@ -70,6 +70,7 @@ import { isValidResolutionVerb, executeResolution } from "./contradiction/resolu
 import { RelayMissionStoreError } from "./relay/mission.js";
 import { ReviewDeckAccessHttpBase } from "./review/review-deck-http-base.js";
 import { serializeInlineScriptValue } from "./inline-script.js";
+import { toDottedRemnicName } from "./access-mcp-tool-names.js";
 import type { SupportPassportExternalRequestHandler } from "./support-passport/public-http.js";
 export interface AccessHttpReadinessState {
   ready: boolean;
@@ -3273,7 +3274,7 @@ export class EngramAccessHttpServer extends ReviewDeckAccessHttpBase {
       params?: Record<string, unknown>;
     };
 
-    const toolName = typeof request.params?.name === "string" ? request.params.name : "";
+    const toolName = toDottedRemnicName(typeof request.params?.name === "string" ? request.params.name : "");
     const toolArgs = request.params?.arguments;
     const dreamsRunDryRun =
       (toolName === "engram.dreams_run" || toolName === "remnic.dreams_run") &&

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

@@ -546,7 +546,7 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
 /**
  * Apply outputSchema from the registry to every tool that lacks one.
  * Suffix resolution strips the canonical or legacy prefix so both
- * `remnic.*` and `engram.*` aliases inherit the same schema.
+ * `remnic_*` and `engram.*` aliases inherit the same schema.
  * Tools that already have an explicit outputSchema are skipped.
  */
 export function applyToolOutputSchemas<T extends { name: string; outputSchema?: unknown }>(

package/src/access-mcp-tool-names.test.ts

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  CANONICAL_MCP_PREFIX,
+  toCanonicalToolName,
+  toLegacyToolName,
+  withToolAliases,
+} from "./access-mcp-tool-names.js";
+
+const ANTHROPIC_TOOL_NAME = /^[a-zA-Z0-9_-]{1,64}$/;
+
+test("toCanonicalToolName maps remnic_ / remnic. / engram. to remnic_suffix", () => {
+  assert.equal(toCanonicalToolName("remnic_recall"), "remnic_recall");
+  assert.equal(toCanonicalToolName("remnic.recall"), "remnic_recall");
+  assert.equal(toCanonicalToolName("engram.recall"), "remnic_recall");
+  assert.equal(toCanonicalToolName("unknown"), "unknown");
+});
+
+test("toLegacyToolName maps remnic_ / remnic. / engram. to engram.suffix", () => {
+  assert.equal(toLegacyToolName("remnic_recall"), "engram.recall");
+  assert.equal(toLegacyToolName("remnic.recall"), "engram.recall");
+  assert.equal(toLegacyToolName("engram.recall"), "engram.recall");
+});
+
+test("withToolAliases advertises remnic_<suffix> and optional engram.*", () => {
+  const tool = { name: "engram.recall" };
+  const both = withToolAliases(tool, true);
+  assert.deepEqual(
+    both.map((entry) => entry.name),
+    ["remnic_recall", "engram.recall"],
+  );
+  const canonicalOnly = withToolAliases(tool, false);
+  assert.deepEqual(
+    canonicalOnly.map((entry) => entry.name),
+    ["remnic_recall"],
+  );
+  assert.ok(canonicalOnly.every((entry) => ANTHROPIC_TOOL_NAME.test(entry.name)));
+  assert.equal(CANONICAL_MCP_PREFIX, "remnic_");
+});
+
+test("withToolAliases emits the engram.* alias for canonical-named tools too", () => {
+  const tool = { name: "remnic_recall" };
+  assert.deepEqual(
+    withToolAliases(tool, true).map((entry) => entry.name),
+    ["remnic_recall", "engram.recall"],
+  );
+  assert.deepEqual(
+    withToolAliases(tool, false).map((entry) => entry.name),
+    ["remnic_recall"],
+  );
+  assert.deepEqual(
+    withToolAliases({ name: "remnic.recall" }, true).map((entry) => entry.name),
+    ["remnic_recall", "engram.recall"],
+  );
+});

package/src/access-mcp-tool-names.ts

@@ -0,0 +1,45 @@
+/**
+ * MCP tool-name prefixes (issue #2705).
+ *
+ * Anthropic tool names must match `^[a-zA-Z0-9_-]{1,64}$`.
+ * Advertised canonical form is `remnic_<suffix>`.
+ * `remnic.` and `engram.` stay callable.
+ */
+export const CANONICAL_MCP_PREFIX = "remnic_";
+export const LEGACY_MCP_PREFIX = "engram.";
+export const DOTTED_REMNIC_PREFIX = "remnic.";
+
+const KNOWN_PREFIXES = [CANONICAL_MCP_PREFIX, DOTTED_REMNIC_PREFIX, LEGACY_MCP_PREFIX] as const;
+
+export function toolNameSuffix(name: string): string | null {
+  for (const prefix of KNOWN_PREFIXES) {
+    if (name.startsWith(prefix)) return name.slice(prefix.length);
+  }
+  return null;
+}
+
+export function toCanonicalToolName(name: string): string {
+  const suffix = toolNameSuffix(name);
+  return suffix === null ? name : `${CANONICAL_MCP_PREFIX}${suffix}`;
+}
+
+export function toLegacyToolName(name: string): string {
+  const suffix = toolNameSuffix(name);
+  return suffix === null ? name : `${LEGACY_MCP_PREFIX}${suffix}`;
+}
+
+export function toDottedRemnicName(name: string): string {
+  const suffix = toolNameSuffix(name);
+  return suffix === null ? name : `${DOTTED_REMNIC_PREFIX}${suffix}`;
+}
+
+export function withToolAliases<T extends { name: string }>(tool: T, emitLegacyTools = true): T[] {
+  const suffix = toolNameSuffix(tool.name);
+  if (suffix === null) return [tool];
+  const canonicalName = `${CANONICAL_MCP_PREFIX}${suffix}`;
+  const canonicalTool = canonicalName === tool.name ? tool : { ...tool, name: canonicalName };
+  if (!emitLegacyTools) return [canonicalTool];
+  const legacyName = `${LEGACY_MCP_PREFIX}${suffix}`;
+  const legacyTool = legacyName === tool.name ? tool : { ...tool, name: legacyName };
+  return [canonicalTool, legacyTool];
+}

package/src/access-mcp.test.ts

@@ -910,9 +910,9 @@ test("MCP tools/list exposes LCM compaction tools under remnic aliases", async (
     (tool) => tool.name,
   );
 
-  assert.ok(listed.includes("remnic.lcm_compaction_flush"));
+  assert.ok(listed.includes("remnic_lcm_compaction_flush"));
   assert.ok(listed.includes("engram.lcm_compaction_flush"));
-  assert.ok(listed.includes("remnic.lcm_compaction_record"));
+  assert.ok(listed.includes("remnic_lcm_compaction_record"));
   assert.ok(listed.includes("engram.lcm_compaction_record"));
 });
 
@@ -977,10 +977,10 @@ function listToolNames(response: unknown): string[] {
 
 const TOOLS_LIST_REQUEST = { jsonrpc: "2.0", id: 1, method: "tools/list", params: {} };
 
-test("tools/list advertises both remnic.* and engram.* by default (back-compat)", async () => {
+test("tools/list advertises remnic_* and engram.* by default (back-compat)", async () => {
   const server = new EngramMcpServer(makeMockService());
   const names = listToolNames(await server.handleRequest(TOOLS_LIST_REQUEST));
-  assert.ok(names.includes("remnic.recall"), "canonical name present");
+  assert.ok(names.includes("remnic_recall"), "canonical name present");
   assert.ok(names.includes("engram.recall"), "legacy alias present by default");
   const legacyCount = names.filter((n) => n.startsWith("engram.")).length;
   assert.ok(legacyCount > 0, "legacy aliases advertised by default");
@@ -989,26 +989,31 @@ test("tools/list advertises both remnic.* and engram.* by default (back-compat)"
 test("tools/list omits engram.* aliases when emitLegacyTools is false", async () => {
   const server = new EngramMcpServer(makeMockService(), { emitLegacyTools: false });
   const names = listToolNames(await server.handleRequest(TOOLS_LIST_REQUEST));
-  assert.ok(names.includes("remnic.recall"), "canonical name still present");
+  assert.ok(names.includes("remnic_recall"), "canonical name still present");
   assert.equal(
     names.filter((n) => n.startsWith("engram.")).length,
     0,
     "no engram.* aliases advertised when opted out",
   );
-  // Every advertised tool uses the canonical prefix; the surface is halved.
-  assert.ok(names.every((n) => n.startsWith("remnic.")), "all advertised tools are canonical");
+  // Every advertised tool uses the Anthropic-safe remnic_* prefix.
+  assert.ok(names.every((n) => n.startsWith("remnic_")), "all advertised tools are canonical");
+  assert.ok(names.every((n) => /^[a-zA-Z0-9_-]{1,64}$/.test(n)), "Anthropic tool-name pattern");
 });
 
 test("emitLegacyTools=false still allows calling tools under BOTH names (advertising-only opt-out)", async () => {
   const server = new EngramMcpServer(makeMockService(), { emitLegacyTools: false });
-  // Canonical call works.
-  const canonical = await server.handleRequest(makeToolRequest("remnic.recall", { query: "hello" }));
+  const advertised = await server.handleRequest(makeToolRequest("remnic_recall", { query: "hello" }));
   assert.notEqual(
-    (canonical as { result?: { isError?: boolean } }).result?.isError,
+    (advertised as { result?: { isError?: boolean } }).result?.isError,
     true,
-    "canonical remnic.recall call succeeds",
+    "advertised remnic_recall call succeeds",
+  );
+  const dotted = await server.handleRequest(makeToolRequest("remnic.recall", { query: "hello" }));
+  assert.notEqual(
+    (dotted as { result?: { isError?: boolean } }).result?.isError,
+    true,
+    "dotted remnic.recall call still dispatches",
   );
-  // Legacy call still dispatches even though it is no longer advertised.
   const legacy = await server.handleRequest(makeToolRequest("engram.recall", { query: "hello" }));
   assert.notEqual(
     (legacy as { result?: { isError?: boolean } }).result?.isError,
@@ -1034,10 +1039,10 @@ test("tools/list: ops-scoped token sees ONLY its permitted tools (issue #1850 fi
   const names = await tokenCapabilityStore.run({ version: 1, ops: ["recall", "memory_get"] }, async () =>
     listToolNames(await server.handleRequest(TOOLS_LIST_REQUEST)),
   );
-  assert.ok(names.includes("remnic.recall"), "permitted recall tool advertised");
-  assert.ok(names.includes("remnic.memory_get"), "permitted memory_get tool advertised");
-  assert.ok(!names.includes("remnic.memory_store"), "non-permitted tool must NOT be advertised");
-  assert.ok(!names.includes("remnic.observe"), "non-permitted tool must NOT be advertised");
+  assert.ok(names.includes("remnic_recall"), "permitted recall tool advertised");
+  assert.ok(names.includes("remnic_memory_get"), "permitted memory_get tool advertised");
+  assert.ok(!names.includes("remnic_memory_store"), "non-permitted tool must NOT be advertised");
+  assert.ok(!names.includes("remnic_observe"), "non-permitted tool must NOT be advertised");
   assert.equal(names.length, 2, "exactly the two permitted tools advertised");
 });
 
@@ -1330,11 +1335,11 @@ test("MCP external_wiki_search exposes aliases and dispatches the stable result"
         ? [tool.name]
         : []
     );
-    assert.ok(toolNames.includes("remnic.external_wiki_search"));
+    assert.ok(toolNames.includes("remnic_external_wiki_search"));
     assert.ok(toolNames.includes("engram.external_wiki_search"));
 
     let canonicalResult: unknown;
-    for (const name of ["remnic.external_wiki_search", "engram.external_wiki_search"]) {
+    for (const name of ["remnic_external_wiki_search", "engram.external_wiki_search", "remnic.external_wiki_search"]) {
       const response = await server.handleRequest(makeToolRequest(name, {
         query: "hybrid retrieval",
         limit: 3,

package/src/access-mcp.ts

@@ -42,6 +42,14 @@ import { readEnvVar } from "./runtime/env.js";
 import type { RecallDisclosure, RecallPlanMode } from "./types.js";
 import { expandTildePath } from "./utils/path.js";
 import { applyToolOutputSchemas } from "./access-mcp-output-schemas.js";
+import {
+  CANONICAL_MCP_PREFIX,
+  LEGACY_MCP_PREFIX,
+  toCanonicalToolName,
+  toLegacyToolName,
+  toolNameSuffix,
+  withToolAliases,
+} from "./access-mcp-tool-names.js";
 import { MCP_READ_ONLY_TOOL_SUFFIXES } from "./mcp-read-only-tools.js";
 import { MEETINGS_MCP_TOOLS } from "./meetings/mcp-tools.js";
 import { WEARABLES_MCP_TOOLS } from "./wearables/mcp-tools.js";
@@ -119,42 +127,15 @@ type McpResource = {
  */
 export const MCP_SUPPORTED_PROTOCOL_VERSIONS: readonly string[] = ["2025-06-18", "2025-03-26", "2024-11-05"];
 const MCP_DEFAULT_PROTOCOL_VERSION: string = MCP_SUPPORTED_PROTOCOL_VERSIONS[0] ?? "2025-06-18";
-const LEGACY_MCP_PREFIX = "engram.";
-const CANONICAL_MCP_PREFIX = "remnic.";
-
-function toCanonicalToolName(name: string): string {
-  return name.startsWith(LEGACY_MCP_PREFIX) ? `${CANONICAL_MCP_PREFIX}${name.slice(LEGACY_MCP_PREFIX.length)}` : name;
-}
-function toLegacyToolName(name: string): string {
-  return name.startsWith(CANONICAL_MCP_PREFIX)
-    ? `${LEGACY_MCP_PREFIX}${name.slice(CANONICAL_MCP_PREFIX.length)}`
-    : name;
-}
-
 /**
  * Suffix-based allowlist matcher. Returns true for tools whose canonical
- * suffix (after stripping `remnic.` or `engram.`) is in
+ * suffix (after stripping `remnic_`, `remnic.`, or `engram.`) is in
  * {@link MCP_READ_ONLY_TOOL_SUFFIXES}. Unprefixed names are treated as
  * unannotated.
  */
 function isReadOnlyToolName(name: string): boolean {
-  for (const prefix of [CANONICAL_MCP_PREFIX, LEGACY_MCP_PREFIX]) {
-    if (name.startsWith(prefix)) {
-      return MCP_READ_ONLY_TOOL_SUFFIXES[name.slice(prefix.length)] === true;
-    }
-  }
-  return false;
-}
-
-function withToolAliases(tool: McpTool, emitLegacyTools = true): McpTool[] {
-  const canonicalName = toCanonicalToolName(tool.name);
-  const canonicalTool = canonicalName === tool.name ? tool : { ...tool, name: canonicalName };
-  if (canonicalName === tool.name) return [canonicalTool];
-  // Issue #1427: when legacy aliases are opted out, advertise only the
-  // canonical `remnic.*` name and drop the `engram.*` duplicate. Tool *calls*
-  // still accept both names (the dispatch canonicalizes), so suppressing the
-  // alias only trims `tools/list`, not callability.
-  return emitLegacyTools ? [canonicalTool, tool] : [canonicalTool];
+  const suffix = toolNameSuffix(name);
+  return suffix !== null && MCP_READ_ONLY_TOOL_SUFFIXES[suffix] === true;
 }
 
 export const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
@@ -2247,7 +2228,7 @@ export class EngramMcpServer {
     // allowlist. Done as a final pass so every spread (chat, codegraph,
     // coding_*, correction, etc.) inherits the annotation without
     // scattering the same logic across every `withToolAliases` call site.
-    // Suffix-based matching covers both the `remnic.*` and `engram.*`
+    // Suffix-based matching covers both the `remnic_*` and `engram.*`
     // naming forms emitted by `withToolAliases`.
     this.tools = this.tools.map((tool) =>
       isReadOnlyToolName(tool.name) && tool.annotations?.readOnlyHint !== true
@@ -2256,7 +2237,7 @@ export class EngramMcpServer {
     );
     // Apply `outputSchema` declarations from the registry. Like the
     // readOnlyHint pass above, this is a final suffix-based pass so every
-    // tool (including both `remnic.*` and `engram.*` aliases) gets a
+    // tool (including both `remnic_*` and `engram.*` aliases) gets a
     // schema. Tools that already declare an outputSchema (e.g.
     // chatgpt_memory_inspector) are left untouched.
     this.tools = applyToolOutputSchemas(this.tools, CANONICAL_MCP_PREFIX, LEGACY_MCP_PREFIX);
@@ -2589,9 +2570,9 @@ export class EngramMcpServer {
 
   private toolAcceptsArgument(name: string, key: string): boolean {
     // Match by canonical name so argument validation resolves whether the
-    // caller used the `engram.*` or `remnic.*` name and regardless of whether
-    // legacy aliases are advertised (issue #1427) — a tool stays callable under
-    // both names even when only the canonical alias appears in `tools/list`.
+    // caller used `engram.*`, `remnic.*`, or `remnic_*` and regardless of
+    // whether legacy aliases are advertised (issue #1427) — a tool stays
+    // callable under those names even when only remnic_* appears in tools/list.
     const target = toCanonicalToolName(name);
     const tool = this.tools.find((entry) => toCanonicalToolName(entry.name) === target);
     const inputSchema = getObjectProperties(tool?.inputSchema);

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

@@ -53,9 +53,9 @@ void getOperation;
 // ---------------------------------------------------------------------------
 
 const LEGACY_PREFIX = "engram.";
-const CANONICAL_PREFIX = "remnic.";
+const CANONICAL_PREFIX = "remnic_";
 
-/** Strip the `engram.`/`remnic.` prefix to get the canonical short name. */
+/** Strip the `engram.`/`remnic_` prefix to get the canonical short name. */
 function shortToolName(advertised: string): string {
   if (advertised.startsWith(LEGACY_PREFIX)) return advertised.slice(LEGACY_PREFIX.length);
   if (advertised.startsWith(CANONICAL_PREFIX)) return advertised.slice(CANONICAL_PREFIX.length);

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

@@ -543,7 +543,7 @@ test("tools/list: engram.coding_architecture absent when gate off (byte-identica
   const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
   const names = extractToolNames(response);
   assert.equal(names.has("engram.coding_architecture"), false, "tool must be absent when gate is off");
-  assert.equal(names.has("remnic.coding_architecture"), false, "alias must be absent when gate is off");
+  assert.equal(names.has("remnic_coding_architecture"), false, "alias must be absent when gate is off");
 });
 
 test("tools/list: engram.coding_architecture present when gate on", async () => {
@@ -552,7 +552,7 @@ test("tools/list: engram.coding_architecture present when gate on", async () =>
   const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
   const names = extractToolNames(response);
   assert.equal(names.has("engram.coding_architecture"), true, "tool must be advertised when gate is on");
-  assert.equal(names.has("remnic.coding_architecture"), true, "alias must be advertised when gate is on");
+  assert.equal(names.has("remnic_coding_architecture"), true, "alias must be advertised when gate is on");
 });
 
 // ──────────────────────────────────────────────────────────────────────────

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

@@ -277,9 +277,9 @@ test("tools/list gate: all 14 codegraph tools absent when codegraphVisible off (
       `engram.codegraph_${suffix} must be absent when gate is off`,
     );
     assert.equal(
-      names.has(`remnic.codegraph_${suffix}`),
+      names.has(`remnic_codegraph_${suffix}`),
       false,
-      `remnic.codegraph_${suffix} must be absent when gate is off`,
+      `remnic_codegraph_${suffix} must be absent when gate is off`,
     );
   }
 });
@@ -296,9 +296,9 @@ test("tools/list gate: all 14 codegraph tools present when codegraphVisible on",
       `engram.codegraph_${suffix} must be present when gate is on`,
     );
     assert.equal(
-      names.has(`remnic.codegraph_${suffix}`),
+      names.has(`remnic_codegraph_${suffix}`),
       true,
-      `remnic.codegraph_${suffix} alias must be present when gate is on`,
+      `remnic_codegraph_${suffix} alias must be present when gate is on`,
     );
   }
 });

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

@@ -168,7 +168,7 @@ test("tools/list: engram.coding_decision absent when gate off (byte-identical to
   const tools = (response as { result?: { tools?: Array<{ name: string }> } }).result?.tools ?? [];
   const names = new Set(tools.map((t) => t.name));
   assert.equal(names.has("engram.coding_decision"), false, "tool must be absent when gate is off");
-  assert.equal(names.has("remnic.coding_decision"), false, "alias must be absent when gate is off");
+  assert.equal(names.has("remnic_coding_decision"), false, "alias must be absent when gate is off");
 });
 
 // ──────────────────────────────────────────────────────────────────────────

package/src/correction/correction-surfaces.test.ts

@@ -114,8 +114,8 @@ test("tools/list gate: correction tools absent when correctionVisible off (byte-
   const names = extractToolNames(response);
   assert.equal(names.has("engram.memory_correct_plan"), false, "plan tool must be absent when gate off");
   assert.equal(names.has("engram.memory_correct_apply"), false, "apply tool must be absent when gate off");
-  assert.equal(names.has("remnic.memory_correct_plan"), false, "plan alias must be absent when gate off");
-  assert.equal(names.has("remnic.memory_correct_apply"), false, "apply alias must be absent when gate off");
+  assert.equal(names.has("remnic_memory_correct_plan"), false, "plan alias must be absent when gate off");
+  assert.equal(names.has("remnic_memory_correct_apply"), false, "apply alias must be absent when gate off");
 });
 
 test("tools/list gate: correction tools present when correctionVisible on (default)", async () => {
@@ -126,8 +126,8 @@ test("tools/list gate: correction tools present when correctionVisible on (defau
   const names = extractToolNames(response);
   assert.equal(names.has("engram.memory_correct_plan"), true, "plan tool must be present by default");
   assert.equal(names.has("engram.memory_correct_apply"), true, "apply tool must be present by default");
-  assert.equal(names.has("remnic.memory_correct_plan"), true, "plan alias must be present");
-  assert.equal(names.has("remnic.memory_correct_apply"), true, "apply alias must be present");
+  assert.equal(names.has("remnic_memory_correct_plan"), true, "plan alias must be present");
+  assert.equal(names.has("remnic_memory_correct_apply"), true, "apply alias must be present");
 });
 
 // ---------------------------------------------------------------------------

package/src/mcp-memory-inspector-app.ts

@@ -7,7 +7,7 @@ import type { RetrievedMemoryProvenance } from "./memory-provenance.js";
 export const REMNIC_CHATGPT_MEMORY_INSPECTOR_TOOL =
   "engram.chatgpt_memory_inspector" as const;
 export const REMNIC_CHATGPT_MEMORY_INSPECTOR_CANONICAL_TOOL =
-  "remnic.chatgpt_memory_inspector" as const;
+  "remnic_chatgpt_memory_inspector" as const;
 export const REMNIC_CHATGPT_MEMORY_INSPECTOR_WIDGET_URI =
   "ui://remnic/memory-inspector.v1.html" as const;
 export const REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE =

package/src/support-passport/mcp-tools.test.ts

@@ -42,10 +42,10 @@ test("support passport MCP tools are hidden until the feature is enabled", async
     false
   );
   assert.equal(enabledNames.filter((name) => name.includes("support_passport")).length, 22);
-  assert.ok(enabledNames.includes("remnic.support_passport_memory_preview"));
-  assert.ok(enabledNames.includes("remnic.support_passport_cards_list"));
+  assert.ok(enabledNames.includes("remnic_support_passport_memory_preview"));
+  assert.ok(enabledNames.includes("remnic_support_passport_cards_list"));
   assert.ok(enabledNames.includes("engram.support_passport_grant_revoke"));
-  for (const name of ["remnic.support_passport_memory_preview", "engram.support_passport_memory_preview"]) {
+  for (const name of ["remnic_support_passport_memory_preview", "engram.support_passport_memory_preview"]) {
     assert.equal(enabledTools.find((tool) => tool.name === name)?.annotations?.readOnlyHint, true);
   }
 });