@remnic/core 1.1.30 → 9.3.515

package/src/projection/index.test.ts

@@ -0,0 +1,253 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdir, mkdtemp, readFile, rm, symlink, writeFile } from "node:fs/promises";
+
+import { generateContextTree } from "./index.js";
+
+async function writeFact(memoryDir: string): Promise<void> {
+  const factsDir = path.join(memoryDir, "facts");
+  await mkdir(factsDir, { recursive: true });
+  await writeFile(
+    path.join(factsDir, "fact-1.md"),
+    [
+      "---",
+      "id: fact-1",
+      "category: fact",
+      "created: 2026-05-21T00:00:00.000Z",
+      "updated: 2026-05-21T00:00:00.000Z",
+      "confidence: 1",
+      "confidenceTier: explicit",
+      "tags: []",
+      "source: test",
+      "---",
+      "",
+      "Stored fact body.",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+async function writeQuestion(memoryDir: string): Promise<void> {
+  const questionsDir = path.join(memoryDir, "questions");
+  await mkdir(questionsDir, { recursive: true });
+  await writeFile(
+    path.join(questionsDir, "question-1.md"),
+    [
+      "---",
+      "id: question-1",
+      "category: question",
+      "created: 2026-05-21T00:00:00.000Z",
+      "updated: 2026-05-21T00:00:00.000Z",
+      "confidence: 1",
+      "confidenceTier: explicit",
+      "tags: []",
+      "source: test",
+      "---",
+      "",
+      "Stored question body?",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+}
+
+test("generateContextTree rejects categories that would escape the output directory", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-projection-category-"));
+  try {
+    const memoryDir = path.join(root, "memory");
+    const outputDir = path.join(root, "context-tree");
+    await writeFact(memoryDir);
+
+    await assert.rejects(
+      generateContextTree({
+        memoryDir,
+        outputDir,
+        categories: ["../escaped"],
+        includeEntities: false,
+        includeQuestions: false,
+      }),
+      /invalid context tree category/,
+    );
+    await assert.rejects(
+      readFile(path.join(root, "escaped", "fact-1.md"), "utf-8"),
+      /ENOENT/,
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("generateContextTree writes valid categories under the output directory", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-projection-valid-"));
+  try {
+    const memoryDir = path.join(root, "memory");
+    const outputDir = path.join(root, "context-tree");
+    await writeFact(memoryDir);
+
+    const result = await generateContextTree({
+      memoryDir,
+      outputDir,
+      categories: ["fact"],
+      includeEntities: false,
+      includeQuestions: false,
+    });
+
+    assert.equal(result.nodesGenerated, 1);
+    const projected = await readFile(
+      path.join(outputDir, "fact", "fact-1.md"),
+      "utf-8",
+    );
+    assert.match(projected, /Stored fact body/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("generateContextTree does not include questions when categories exclude question", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-projection-question-filter-"));
+  try {
+    const memoryDir = path.join(root, "memory");
+    const outputDir = path.join(root, "context-tree");
+    await writeFact(memoryDir);
+    await writeQuestion(memoryDir);
+
+    const result = await generateContextTree({
+      memoryDir,
+      outputDir,
+      categories: ["fact"],
+      includeEntities: false,
+      includeQuestions: true,
+    });
+
+    assert.equal(result.nodesGenerated, 1);
+    assert.deepEqual(result.categories, { fact: 1 });
+    await assert.rejects(
+      readFile(path.join(outputDir, "question", "question-1.md"), "utf-8"),
+      /ENOENT/,
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("generateContextTree rejects symlinked memory category roots", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-projection-input-symlink-"));
+  try {
+    const memoryDir = path.join(root, "memory");
+    const outsideDir = path.join(root, "outside-facts");
+    const outputDir = path.join(root, "context-tree");
+    await mkdir(memoryDir, { recursive: true });
+    await mkdir(outsideDir, { recursive: true });
+    await writeFile(path.join(outsideDir, "fact-escape.md"), "escaped", "utf-8");
+    await symlink(outsideDir, path.join(memoryDir, "facts"), "dir");
+
+    await assert.rejects(
+      generateContextTree({
+        memoryDir,
+        outputDir,
+        categories: ["fact"],
+        includeEntities: false,
+        includeQuestions: false,
+      }),
+      /symlink/,
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("generateContextTree rejects symlinked output path components", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-projection-output-symlink-"));
+  try {
+    const memoryDir = path.join(root, "memory");
+    const outputDir = path.join(root, "context-tree");
+    const outsideDir = path.join(root, "outside-output");
+    await writeFact(memoryDir);
+    await mkdir(outputDir, { recursive: true });
+    await mkdir(outsideDir, { recursive: true });
+    await symlink(outsideDir, path.join(outputDir, "fact"), "dir");
+
+    await assert.rejects(
+      generateContextTree({
+        memoryDir,
+        outputDir,
+        categories: ["fact"],
+        includeEntities: false,
+        includeQuestions: false,
+      }),
+      /symlink/,
+    );
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("generateContextTree processes explicit question category only once", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-projection-question-"));
+  try {
+    const memoryDir = path.join(root, "memory");
+    const outputDir = path.join(root, "context-tree");
+    await writeQuestion(memoryDir);
+
+    const result = await generateContextTree({
+      memoryDir,
+      outputDir,
+      categories: ["question"],
+      includeEntities: false,
+    });
+
+    assert.equal(result.nodesGenerated, 1);
+    assert.deepEqual(result.categories, { question: 1 });
+    const projected = await readFile(
+      path.join(outputDir, "question", "question-1.md"),
+      "utf-8",
+    );
+    assert.match(projected, /Stored question body/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
+test("generateContextTree preserves manual fenced blocks on regeneration", async () => {
+  const root = await mkdtemp(path.join(os.tmpdir(), "remnic-projection-manual-"));
+  try {
+    const memoryDir = path.join(root, "memory");
+    const outputDir = path.join(root, "context-tree");
+    await writeFact(memoryDir);
+
+    await generateContextTree({
+      memoryDir,
+      outputDir,
+      categories: ["fact"],
+      includeEntities: false,
+      includeQuestions: false,
+    });
+
+    const projectedPath = path.join(outputDir, "fact", "fact-1.md");
+    const generated = await readFile(projectedPath, "utf-8");
+    const manualBlock = [
+      "```manual",
+      "Keep this human note across regeneration.",
+      "```",
+    ].join("\n");
+    await writeFile(projectedPath, `${generated.trimEnd()}\n\n${manualBlock}\n`, "utf-8");
+
+    await generateContextTree({
+      memoryDir,
+      outputDir,
+      categories: ["fact"],
+      includeEntities: false,
+      includeQuestions: false,
+    });
+
+    const regenerated = await readFile(projectedPath, "utf-8");
+    assert.match(regenerated, /Stored fact body/);
+    assert.match(regenerated, /## Manual Edits/);
+    assert.match(regenerated, /Keep this human note across regeneration/);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/src/projection/index.ts

@@ -10,6 +10,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { getCategoryDir, ALL_CATEGORY_KEYS } from "../utils/category-dir.js";
 
+const VALID_PROJECTION_CATEGORIES = new Set(ALL_CATEGORY_KEYS);
+
 // ── Types ────────────────────────────────────────────────────────────────────
 
 export interface TreeNode {
@@ -85,19 +87,27 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
   let nodesGenerated = 0;
   let nodesSkipped = 0;
   const categoryCounts: Record<string, number> = {};
+  const resolvedMemoryDir = path.resolve(memoryDir);
+  const resolvedOutputDir = path.resolve(outputDir);
+  const requestedCategories = validateProjectionCategories(filterCategories);
+  const realMemoryDir = fs.realpathSync(resolvedMemoryDir);
 
   // Ensure output directory exists
-  fs.mkdirSync(outputDir, { recursive: true });
+  assertNotSymlink(resolvedOutputDir, "context tree outputDir");
+  fs.mkdirSync(resolvedOutputDir, { recursive: true });
+  const realOutputDir = fs.realpathSync(resolvedOutputDir);
 
   // Process each category (exclude 'question' — handled by separate includeQuestions pass)
-  const allCategories = filterCategories ?? ALL_CATEGORY_KEYS.filter((c) => c !== "question");
+  const allCategories = (requestedCategories ?? ALL_CATEGORY_KEYS)
+    .filter((c) => c !== "question");
 
   for (const category of allCategories) {
     const categoryDir = getCategoryDir(memoryDir, category);
     if (!fs.existsSync(categoryDir)) continue;
+    assertSafeInputRoot(realMemoryDir, categoryDir, `${category} memory category`);
 
     categoryCounts[category] = 0;
-    const files = walkR(categoryDir);
+    const files = walkR(categoryDir, realMemoryDir);
     let count = 0;
 
     for (const filePath of files) {
@@ -120,9 +130,8 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
       }
 
       // Write node to output
-      const outputPath = path.join(outputDir, node.path);
-      fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-      fs.writeFileSync(outputPath, node.content);
+      const outputPath = resolveContainedOutputPath(realOutputDir, node.path);
+      writeProjectedContent(realOutputDir, outputPath, node.content);
 
       nodesGenerated++;
       categoryCounts[category] = (categoryCounts[category] ?? 0) + 1;
@@ -134,8 +143,9 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
   if (includeEntities) {
     const entitiesDir = path.join(memoryDir, "entities");
     if (fs.existsSync(entitiesDir)) {
+      assertSafeInputRoot(realMemoryDir, entitiesDir, "entities root");
       categoryCounts["entity"] = 0;
-      const entityFiles = walkR(entitiesDir);
+      const entityFiles = walkR(entitiesDir, realMemoryDir);
       let count = 0;
 
       for (const filePath of entityFiles) {
@@ -148,9 +158,8 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
         const fileName = path.basename(filePath, ".md");
         const node = projectEntityNode(fileName, content);
 
-        const outputPath = path.join(outputDir, "entities", `${fileName}.md`);
-        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-        fs.writeFileSync(outputPath, node.content);
+        const outputPath = resolveContainedOutputPath(realOutputDir, "entities", `${fileName}.md`);
+        writeProjectedContent(realOutputDir, outputPath, node.content);
 
         nodesGenerated++;
         categoryCounts["entity"] = (categoryCounts["entity"] ?? 0) + 1;
@@ -160,11 +169,15 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
   }
 
   // Process questions
-  if (includeQuestions) {
+  const shouldIncludeQuestions =
+    includeQuestions &&
+    (requestedCategories === undefined || requestedCategories.includes("question"));
+  if (shouldIncludeQuestions) {
     const questionsDir = path.join(memoryDir, "questions");
     if (fs.existsSync(questionsDir)) {
+      assertSafeInputRoot(realMemoryDir, questionsDir, "questions root");
       categoryCounts["question"] = 0;
-      const qFiles = walkR(questionsDir);
+      const qFiles = walkR(questionsDir, realMemoryDir);
       let count = 0;
 
       for (const filePath of qFiles) {
@@ -186,9 +199,8 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
           continue;
         }
 
-        const outputPath = path.join(outputDir, node.path);
-        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
-        fs.writeFileSync(outputPath, node.content);
+        const outputPath = resolveContainedOutputPath(realOutputDir, node.path);
+        writeProjectedContent(realOutputDir, outputPath, node.content);
 
         nodesGenerated++;
         categoryCounts["question"] = (categoryCounts["question"] ?? 0) + 1;
@@ -198,8 +210,8 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
   }
 
   // Write index
-  const index = generateIndex(categoryCounts, outputDir);
-  fs.writeFileSync(path.join(outputDir, "INDEX.md"), index);
+  const index = generateIndex(categoryCounts, resolvedOutputDir);
+  writeProjectedContent(realOutputDir, resolveContainedOutputPath(realOutputDir, "INDEX.md"), index);
 
   return {
     nodesGenerated,
@@ -212,15 +224,144 @@ export async function generateContextTree(options: GenerateOptions): Promise<Gen
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+function isPathInside(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function assertNotSymlink(targetPath: string, label: string): void {
+  try {
+    if (fs.lstatSync(targetPath).isSymbolicLink()) {
+      throw new Error(`${label} must not be a symlink: ${targetPath}`);
+    }
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") return;
+    throw err;
+  }
+}
+
+function assertSafeInputRoot(realMemoryDir: string, targetPath: string, label: string): void {
+  const stat = fs.lstatSync(targetPath);
+  if (stat.isSymbolicLink()) {
+    throw new Error(`${label} must not be a symlink: ${targetPath}`);
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(`${label} must be a directory: ${targetPath}`);
+  }
+  const realTarget = fs.realpathSync(targetPath);
+  if (!isPathInside(realMemoryDir, realTarget)) {
+    throw new Error(`${label} escapes memoryDir: ${targetPath}`);
+  }
+}
 
-function walkR(dir: string): string[] {
+function assertSafeOutputTarget(realOutputDir: string, outputPath: string): void {
+  let current = realOutputDir;
+  const relative = path.relative(realOutputDir, outputPath);
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
+  }
+  for (const segment of relative.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    try {
+      const stat = fs.lstatSync(current);
+      if (stat.isSymbolicLink()) {
+        throw new Error(`context tree output path contains symlink: ${current}`);
+      }
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        break;
+      }
+      throw err;
+    }
+  }
+}
+
+function validateProjectionCategories(categories: string[] | undefined): string[] | undefined {
+  if (categories === undefined) {
+    return undefined;
+  }
+  const validated: string[] = [];
+  for (const category of categories) {
+    if (typeof category !== "string" || !VALID_PROJECTION_CATEGORIES.has(category)) {
+      throw new Error(`invalid context tree category: ${String(category)}`);
+    }
+    if (!validated.includes(category)) {
+      validated.push(category);
+    }
+  }
+  return validated;
+}
+
+function resolveContainedOutputPath(outputRoot: string, ...segments: string[]): string {
+  const resolved = path.resolve(outputRoot, ...segments);
+  const relative = path.relative(outputRoot, resolved);
+  if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+    return resolved;
+  }
+  throw new Error(`context tree output path escapes outputDir: ${segments.join("/")}`);
+}
+
+function writeProjectedContent(realOutputDir: string, outputPath: string, generatedContent: string): void {
+  assertSafeOutputTarget(realOutputDir, outputPath);
+  fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+  const realParent = fs.realpathSync(path.dirname(outputPath));
+  if (!isPathInside(realOutputDir, realParent)) {
+    throw new Error(`context tree output path escapes outputDir: ${outputPath}`);
+  }
+  const existingContent = fs.existsSync(outputPath)
+    ? fs.readFileSync(outputPath, "utf8")
+    : "";
+  fs.writeFileSync(
+    outputPath,
+    preserveManualFencedBlocks(generatedContent, existingContent),
+  );
+}
+
+function preserveManualFencedBlocks(
+  generatedContent: string,
+  existingContent: string,
+): string {
+  const manualBlocks = extractManualFencedBlocks(existingContent)
+    .filter((block) => !generatedContent.includes(block));
+  if (manualBlocks.length === 0) {
+    return generatedContent;
+  }
+  return `${generatedContent.trimEnd()}\n\n## Manual Edits\n\n${manualBlocks.join("\n\n")}\n`;
+}
+
+function extractManualFencedBlocks(content: string): string[] {
+  const blocks: string[] = [];
+  const seen = new Set<string>();
+  const fencePattern = /(?:^|\n)([`~]{3,})[^\n]*\bmanual\b[^\n]*\n[\s\S]*?\n\1[ \t]*(?=\n|$)/gi;
+  for (const match of content.matchAll(fencePattern)) {
+    const block = match[0].trim();
+    if (!seen.has(block)) {
+      seen.add(block);
+      blocks.push(block);
+    }
+  }
+  return blocks;
+}
+
+function walkR(dir: string, realMemoryDir: string): string[] {
   const results: string[] = [];
   function walk(directory: string): void {
     for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
     const fullPath = path.join(directory, entry.name);
+    if (entry.isSymbolicLink()) {
+      throw new Error(`context tree input path contains symlink: ${fullPath}`);
+    }
     if (entry.isDirectory()) {
+      const realDir = fs.realpathSync(fullPath);
+      if (!isPathInside(realMemoryDir, realDir)) {
+        throw new Error(`context tree input path escapes memoryDir: ${fullPath}`);
+      }
       walk(fullPath);
     } else if (entry.name.endsWith(".md")) {
+      const realFile = fs.realpathSync(fullPath);
+      if (!isPathInside(realMemoryDir, realFile)) {
+        throw new Error(`context tree input path escapes memoryDir: ${fullPath}`);
+      }
       results.push(fullPath);
     }
   }

package/src/qmd-client.test.ts

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { QmdClient } from "./qmd.js";
+import type { QmdSearchResult } from "./types.js";
+
+test("QmdClient rechecks daemon availability before returning unavailable", async () => {
+  const client = new QmdClient("memories", 3, {
+    daemonUrl: "stdio://qmd",
+    daemonRecheckIntervalMs: 0,
+  });
+  const internals = client as unknown as {
+    available: boolean;
+    daemonAvailable: boolean;
+    probeDaemon: () => Promise<boolean>;
+    searchViaDaemon: (
+      query: string,
+      collection: string | undefined,
+      maxResults: number,
+    ) => Promise<QmdSearchResult[]>;
+  };
+  let probeCount = 0;
+  internals.available = false;
+  internals.daemonAvailable = false;
+  internals.probeDaemon = async () => {
+    probeCount += 1;
+    internals.daemonAvailable = true;
+    return true;
+  };
+  internals.searchViaDaemon = async (query, collection, maxResults) => [
+    {
+      docid: `${collection}:${maxResults}`,
+      path: "memory.md",
+      snippet: query,
+      score: 1,
+      transport: "daemon",
+    },
+  ];
+
+  const results = await client.search("slow startup", "memories", 3);
+
+  assert.equal(probeCount, 1);
+  assert.equal(results.length, 1);
+  assert.equal(results[0]?.transport, "daemon");
+});

package/src/qmd.ts

@@ -1810,9 +1810,10 @@ export class QmdClient implements SearchBackend {
     options?: SearchQueryOptions,
     execution?: SearchExecutionOptions,
   ): Promise<QmdSearchResult[]> {
-    if (!this.isAvailable()) return [];
     const trimmed = query.trim();
     if (!trimmed) return [];
+    await this.maybeProbeDaemon();
+    if (!this.isAvailable()) return [];
 
     const col = collection ?? this.collection;
     const n = maxResults ?? this.maxResults;
@@ -1830,7 +1831,6 @@ export class QmdClient implements SearchBackend {
     }
 
     // Try daemon first (bypasses QMD_MUTEX — daemon handles its own concurrency)
-    await this.maybeProbeDaemon();
     if (this.daemonAvailable) {
       let results: QmdSearchResult[] | null;
       try {
@@ -1880,15 +1880,15 @@ export class QmdClient implements SearchBackend {
     maxResults?: number,
     execution?: SearchExecutionOptions,
   ): Promise<QmdSearchResult[]> {
-    if (!this.isAvailable()) return [];
     const trimmed = query.trim();
     if (!trimmed) return [];
+    await this.maybeProbeDaemon();
+    if (!this.isAvailable()) return [];
 
     const n = maxResults ?? 6;
     const searchOptions = this.resolveSearchOptions();
 
     // Try daemon first
-    await this.maybeProbeDaemon();
     if (this.daemonAvailable) {
       // Global search: no collection filter
       let results: QmdSearchResult[] | null;
@@ -1930,14 +1930,14 @@ export class QmdClient implements SearchBackend {
     maxResults?: number,
     execution?: SearchExecutionOptions,
   ): Promise<QmdSearchResult[]> {
-    if (!this.isAvailable()) return [];
     const trimmed = query.trim();
     if (!trimmed) return [];
+    await this.maybeProbeDaemon();
+    if (!this.isAvailable()) return [];
     const col = collection ?? this.collection;
     const n = maxResults ?? this.maxResults;
 
     // Try daemon first — BM25 via daemon is much faster than subprocess.
-    await this.maybeProbeDaemon();
     if (this.daemonAvailable && this.daemonSession) {
       let results: QmdSearchResult[] | null;
       try {
@@ -1975,14 +1975,14 @@ export class QmdClient implements SearchBackend {
     maxResults?: number,
     execution?: SearchExecutionOptions,
   ): Promise<QmdSearchResult[]> {
-    if (!this.isAvailable()) return [];
     const trimmed = query.trim();
     if (!trimmed) return [];
+    await this.maybeProbeDaemon();
+    if (!this.isAvailable()) return [];
     const col = collection ?? this.collection;
     const n = maxResults ?? this.maxResults;
 
     // Try daemon first — keeps models warm, avoids cold subprocess loads.
-    await this.maybeProbeDaemon();
     if (this.daemonAvailable && this.daemonSession) {
       let results: QmdSearchResult[] | null;
       try {

package/src/recall-disclosure.test.ts

@@ -24,7 +24,7 @@ import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure,
 } from "./types.js";
-import { recallRequestSchema, validateRequest } from "./access-schema.js";
+import { lcmSearchRequestSchema, recallRequestSchema, validateRequest } from "./access-schema.js";
 import { EngramMcpServer } from "./access-mcp.js";
 import type { EngramAccessRecallRequest, EngramAccessService } from "./access-service.js";
 
@@ -90,6 +90,20 @@ test("validateRequest('recall') surfaces disclosure validation errors with struc
   }
 });
 
+test("lcmSearchRequestSchema accepts requests without sessionPrefix", () => {
+  const result = lcmSearchRequestSchema.safeParse({
+    query: "handoff",
+    sessionKey: "agent:main",
+    namespace: "default",
+    limit: 10,
+  });
+
+  assert.strictEqual(result.success, true);
+  if (result.success) {
+    assert.strictEqual(result.data.sessionPrefix, undefined);
+  }
+});
+
 // ──────────────────────────────────────────────────────────────────────────
 // MCP handler must forward `disclosure` to the service layer.
 //