@remnic/core 9.66.3 → 9.66.5

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/activity/timeline/analysis-overlap.test.ts

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { parseOverlap } from "./analysis-overlap.js";
+
+test("overlap 0 is allowed", () => {
+  assert.equal(parseOverlap(0, 8), 0);
+  assert.equal(parseOverlap(0, 0), 0);
+});
+
+test("overlap 3 with maxBatch 8 is returned", () => {
+  assert.equal(parseOverlap(3, 8), 3);
+});
+
+test("overlap >= maxBatch throws when maxBatch > 0", () => {
+  assert.throws(() => parseOverlap(8, 8), /less than maxBatch/);
+  assert.throws(() => parseOverlap(5, 4), /less than maxBatch/);
+});
+
+test("negative overlap throws", () => {
+  assert.throws(() => parseOverlap(-1, 8), /non-negative integer/);
+});
+
+test("float overlap throws", () => {
+  assert.throws(() => parseOverlap(1.5, 8), /non-negative integer/);
+});

package/src/activity/timeline/analysis-overlap.ts

@@ -0,0 +1,17 @@
+/**
+ * Timeline analysis overlap parse (issue #2050 leftover).
+ *
+ * Pure. 0 is allowed. Negative or non-integer throws.
+ * When maxBatch > 0, overlap must be less than maxBatch.
+ */
+export function parseOverlap(value: unknown, maxBatch: number): number {
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new RangeError(
+      `analysis overlap must be a non-negative integer; got ${JSON.stringify(value)}`,
+    );
+  }
+  if (maxBatch > 0 && value >= maxBatch) {
+    throw new RangeError(`analysis overlap must be less than maxBatch; got ${value} >= ${maxBatch}`);
+  }
+  return value;
+}

package/src/activity/timeline/recap-card-count.test.ts

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { countRecapCards } from "./recap-card-count.js";
+
+test("empty list is 0", () => {
+  assert.equal(countRecapCards([]), 0);
+});
+
+test("counts unique ids", () => {
+  assert.equal(countRecapCards(["card-a", "card-b", "card-a"]), 2);
+  assert.equal(countRecapCards(["card-a", "card-b", "card-c"]), 3);
+});
+
+test("drops empty strings and does not mutate", () => {
+  const cards = ["card-a", "", "card-b", "", "card-a"];
+  assert.equal(countRecapCards(cards), 2);
+  assert.deepEqual(cards, ["card-a", "", "card-b", "", "card-a"]);
+});

package/src/activity/timeline/recap-card-count.ts

@@ -0,0 +1,13 @@
+/**
+ * Recap card counter (issue #2051 leftover).
+ *
+ * Unique ids after dropping empty strings. Does not mutate input.
+ */
+
+export function countRecapCards(cards: readonly string[]): number {
+  const unique = new Set<string>();
+  for (const id of cards) {
+    if (id !== "") unique.add(id);
+  }
+  return unique.size;
+}

package/src/activity/timeline/week-span.test.ts

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { daysBetweenIso } from "./week-span.js";
+
+test("seven-day week is [start, end)", () => {
+  assert.equal(daysBetweenIso("2026-07-13", "2026-07-20"), 7);
+});
+
+test("same day throws", () => {
+  assert.throws(() => daysBetweenIso("2026-07-13", "2026-07-13"), /end/);
+});
+
+test("inverted range throws", () => {
+  assert.throws(() => daysBetweenIso("2026-07-20", "2026-07-13"), /end/);
+});
+
+test("invalid date throws", () => {
+  assert.throws(() => daysBetweenIso("2026-02-30", "2026-03-02"), /YYYY-MM-DD/);
+  assert.throws(() => daysBetweenIso("2026-07-13", "not-a-date"), /YYYY-MM-DD/);
+});

package/src/activity/timeline/week-span.ts

@@ -0,0 +1,18 @@
+/**
+ * Half-open day span between two YYYY-MM-DD dates (issue #2052 leftover).
+ *
+ * Inclusive start, exclusive end. Invalid dates throw. end<=start throws.
+ */
+import { isValidActivityDate } from "../digest.js";
+
+export function daysBetweenIso(startIso: string, endIso: string): number {
+  if (!isValidActivityDate(startIso) || !isValidActivityDate(endIso)) {
+    throw new RangeError(`Invalid date; expected YYYY-MM-DD.`);
+  }
+  const start = Date.parse(`${startIso}T00:00:00Z`);
+  const end = Date.parse(`${endIso}T00:00:00Z`);
+  if (end <= start) {
+    throw new RangeError("end must be after start");
+  }
+  return (end - start) / 86_400_000;
+}

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/extraction-span-gap.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { spanGap } from "./extraction-span-gap.js";
+
+test("spanGap: disjoint half-open gap is b.start - a.end", () => {
+  assert.equal(spanGap({ start: 0, end: 2 }, { start: 4, end: 6 }), 2);
+  assert.equal(spanGap({ start: 0, end: 3 }, { start: 3, end: 5 }), 0);
+  assert.equal(spanGap({ start: 4, end: 6 }, { start: 0, end: 2 }), 2);
+});
+
+test("spanGap: overlap is 0", () => {
+  assert.equal(spanGap({ start: 0, end: 4 }, { start: 2, end: 6 }), 0);
+  assert.equal(spanGap({ start: 1, end: 5 }, { start: 2, end: 3 }), 0);
+});
+
+test("spanGap: inverted span throws", () => {
+  assert.throws(() => spanGap({ start: 3, end: 2 }, { start: 0, end: 1 }), /inverted/i);
+  assert.throws(() => spanGap({ start: 0, end: 1 }, { start: 5, end: 4 }), /inverted/i);
+});
+
+test("spanGap: non-integers throw", () => {
+  assert.throws(() => spanGap({ start: 1.5, end: 3 }, { start: 3, end: 5 }), /integers/);
+  assert.throws(() => spanGap({ start: 0, end: 3 }, { start: 3, end: 5.2 }), /integers/);
+  assert.throws(
+    () => spanGap({ start: Number.NaN, end: 3 }, { start: 3, end: 5 }),
+    /integers/,
+  );
+});
+

package/src/extraction-span-gap.ts

@@ -0,0 +1,25 @@
+/**
+ * Isolated span-gap helper (issue #2333 leftover).
+ *
+ * Pure. Extraction wiring waits on the Phase A bench gate.
+ */
+
+export function spanGap(
+  a: { start: number; end: number },
+  b: { start: number; end: number },
+): number {
+  if (
+    !Number.isInteger(a.start) ||
+    !Number.isInteger(a.end) ||
+    !Number.isInteger(b.start) ||
+    !Number.isInteger(b.end)
+  ) {
+    throw new TypeError("span offsets must be integers");
+  }
+  if (a.end < a.start || b.end < b.start) {
+    throw new RangeError("span offsets inverted");
+  }
+  if (a.end <= b.start) return b.start - a.end;
+  if (b.end <= a.start) return a.start - b.end;
+  return 0;
+}

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