prism-mcp-server 20.2.6 → 20.2.8

package/dist/utils/nlQuery.js

@@ -7,11 +7,14 @@
  * This closes the gap where users have to learn tool syntax to query memories.
  * Instead, they ask plain English questions and get structured results.
  *
- * Pipeline:
+ * Parsing pipeline:
  *   1. Intent classification (decision, todo, file, general)
  *   2. Key phrase extraction
- *   3. Multi-strategy search (keyword + semantic)
- *   4. Answer synthesis (optional, uses local LLM)
+ *   3. Structured memory-query construction
+ *
+ * Execution, web fallback, and grounded prism_infer synthesis live in
+ * queryMemoryNaturalHandler.ts. Keeping network/model work out of this parser
+ * makes intent handling deterministic and independently testable.
  */
 import { debugLog } from "./logger.js";
 // ─── Intent Classification ───────────────────────────────────
@@ -151,34 +154,4 @@ export function parseNLQuery(query, project) {
         suggestedArgs: args,
     };
 }
-/**
- * Execute a natural language query end-to-end.
- *
- * Parses the query, executes the appropriate tool, and optionally
- * synthesizes an answer using the local LLM.
- */
-export async function executeNLQuery(query, project, synthesize = false) {
-    const parsed = parseNLQuery(query, project);
-    // Execute the search
-    let sources = [];
-    let answer = "";
-    try {
-        // Return the parsed query structure — the caller (handler) will
-        // execute the actual tool call using the suggestedTool and suggestedArgs.
-        answer =
-            `Intent: ${parsed.intent} (confidence: ${(parsed.confidence * 100).toFixed(0)}%)\n` +
-                `Keywords: ${parsed.extractedKeywords.join(", ")}\n` +
-                `Suggested tool: ${parsed.suggestedTool}\n` +
-                `Search query: "${parsed.searchQuery}"`;
-    }
-    catch (err) {
-        debugLog(`NL query execution failed: ${err}`);
-        answer = `Unable to parse query: ${err}`;
-    }
-    return {
-        ...parsed,
-        answer: answer || "No relevant memories found.",
-        sources,
-    };
-}
 debugLog("v12.2: Natural language query module loaded");

package/dist/utils/qualityGate.js

@@ -1,12 +1,4 @@
-/**
- * Quality Gate — deterministic check for obvious inference failures.
- *
- * NARROW by design: only high-precision signals that rarely false-positive.
- * Does NOT judge correctness — that's the grounding verifier's job.
- * Does NOT use refusal regex (too many false positives on legitimate output).
- *
- * Returns: { pass: boolean, reason?: string }
- */
+import { parseRouteOutput } from "./routeContract.js";
 /**
  * Signal 5 — Tool-call bleed: pipe-delimited format leaking into non-tool turns.
  * Matches <|tool_call|> and <|tool_call_end|> only — NOT angle-bracket <tool_call> variants
@@ -37,11 +29,22 @@ export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
     if (finishReason === "length") {
         return { pass: false, reason: "hard_truncation" };
     }
-    // Signal 5: Tool-call bleed — fine-tuned 4b emits <|tool_call|> format in non-tool turns.
-    // Pipe-delimited format only; angle-bracket variants are handled by normalizeToolCallFormat.
-    // False-positive guard: requires the literal pipe tokens, not the words "tool call".
+    // Signal 5: Tool-call bleed. The pipe envelope is invalid in chat/code,
+    // but it is the canonical trained output in route mode. Route mode parses
+    // the whole envelope and fails only when the contract is malformed.
     if (TOOL_CALL_BLEED_RE.test(stripped)) {
-        return { pass: false, reason: "tool_call_bleed" };
+        if (mode === "route") {
+            const parsedRoute = parseRouteOutput(stripped);
+            if (parsedRoute.kind === "tool_call") {
+                // Continue through the remaining generic loop checks.
+            }
+            else {
+                return { pass: false, reason: "route_tool_call_malformed" };
+            }
+        }
+        else {
+            return { pass: false, reason: "tool_call_bleed" };
+        }
     }
     // Signal 4: Exact-loop detection (two passes).
     //
@@ -54,7 +57,11 @@ export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
         .replace(/^#{1,6}\s+.*$/gm, "")
         .replace(/^[\s*-]*\*{1,2}[^*]+\*{1,2}:?\s*$/gm, "");
     const proseSentences = proseOnly.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
-    if (proseSentences.length >= 6) {
+    // Plain source code often repeats structural lines across methods. In code
+    // mode those are not prose loops, and splitting on "." corrupts member
+    // access (`node = self.root` becomes `node = self`). Pass B below still
+    // catches egregious repetition at the higher threshold.
+    if (mode !== "code" && proseSentences.length >= 6) {
         const counts = new Map();
         for (const s of proseSentences) {
             const key = s.toLowerCase();
@@ -68,7 +75,17 @@ export function passesQualityGate(stripped, thinkOnly, finishReason, mode) {
     // inside fake code blocks or other structural elements. Higher
     // threshold avoids false positives on legitimate code patterns
     // (e.g. `node = self.root` × 4 is fine, × 5 is suspicious).
-    const allSentences = stripped.split(/[.!?\n]+/).map(s => s.trim()).filter(s => s.length > 10);
+    // In code mode, periods are member-access operators, not sentence
+    // boundaries. Splitting `input.length` at "." made several different
+    // loops share the fragment `while (i < input` and falsely counted it as
+    // repeated output. Full-line matching still catches genuinely duplicated
+    // source while preserving valid repeated control-flow shapes.
+    const fullTextUnits = mode === "code"
+        ? stripped.split(/\n+/)
+        : stripped.split(/[.!?\n]+/);
+    const allSentences = fullTextUnits
+        .map(s => s.trim())
+        .filter(s => s.length > 10);
     if (allSentences.length >= 10) {
         const counts = new Map();
         for (const s of allSentences) {

package/dist/utils/routeContract.js

@@ -0,0 +1,319 @@
+/**
+ * Generic route-output contract for prism_infer.
+ *
+ * This module deliberately contains no intent taxonomy or benchmark-derived
+ * routing heuristics. It only parses the public Prism tool-call envelope and
+ * enforces the caller-advertised registry before a host can act on a route.
+ */
+export const DEFAULT_PRISM_ROUTE_TOOLS = new Set([
+    "session_load_context",
+    "session_save_ledger",
+    "session_save_handoff",
+    "session_compact_ledger",
+    "session_search_memory",
+    "knowledge_search",
+    "brave_web_search",
+]);
+const PIPE_START = "<|tool_call|>";
+const PIPE_END = "<|tool_call_end|>";
+const ANGLE_START = "<tool_call>";
+const ANGLE_END = "</tool_call>";
+const TOOL_NAME_RE = /^[A-Za-z][A-Za-z0-9_.:-]{0,127}$/;
+const MAX_ROUTE_OUTPUT_CHARS = 32_000;
+const MAX_ROUTE_REASON_CHARS = 256;
+const MAX_ARGUMENT_DEPTH = 32;
+const MAX_ARGUMENT_NODES = 2_048;
+const TOOL_CALL_KEYS = new Set(["name", "arguments", "args"]);
+export function isRouteToolName(value) {
+    return typeof value === "string" && TOOL_NAME_RE.test(value);
+}
+function isBoundedJsonValue(root) {
+    const stack = [{ value: root, depth: 0 }];
+    let nodes = 0;
+    while (stack.length > 0) {
+        const current = stack.pop();
+        nodes += 1;
+        if (nodes > MAX_ARGUMENT_NODES || current.depth > MAX_ARGUMENT_DEPTH) {
+            return false;
+        }
+        if (current.value === null)
+            continue;
+        if (typeof current.value === "number") {
+            if (!Number.isFinite(current.value))
+                return false;
+            continue;
+        }
+        if (typeof current.value === "string" ||
+            typeof current.value === "boolean") {
+            continue;
+        }
+        if (typeof current.value !== "object")
+            return false;
+        const values = Array.isArray(current.value)
+            ? current.value
+            : Object.values(current.value);
+        for (const value of values) {
+            stack.push({ value, depth: current.depth + 1 });
+        }
+    }
+    return true;
+}
+function primitiveLeaves(value) {
+    const leaves = [];
+    const stack = [value];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current !== null && typeof current === "object") {
+            stack.push(...(Array.isArray(current)
+                ? current
+                : Object.values(current)));
+        }
+        else {
+            leaves.push(current);
+        }
+    }
+    return leaves;
+}
+function promptContainsPrimitive(prompt, value) {
+    const rendered = String(value).toLowerCase()
+        .replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[^A-Za-z0-9_.-])${rendered}($|[^A-Za-z0-9_.-])`)
+        .test(prompt.toLowerCase());
+}
+function promptContainsString(prompt, value) {
+    const normalizedValue = value.trim().toLowerCase();
+    if (!normalizedValue)
+        return false;
+    if (/^[A-Za-z0-9_.:-]+$/.test(normalizedValue)) {
+        const escaped = normalizedValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return new RegExp(`(^|[^A-Za-z0-9_.:-])${escaped}($|[^A-Za-z0-9_.:-])`)
+            .test(prompt.toLowerCase());
+    }
+    return prompt.toLowerCase().includes(normalizedValue);
+}
+function sameJsonValue(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) &&
+            Array.isArray(right) &&
+            left.length === right.length &&
+            left.every((entry, index) => sameJsonValue(entry, right[index]));
+    }
+    if (left === null ||
+        right === null ||
+        typeof left !== "object" ||
+        typeof right !== "object") {
+        return false;
+    }
+    const leftRecord = left;
+    const rightRecord = right;
+    const leftKeys = Object.keys(leftRecord).sort();
+    const rightKeys = Object.keys(rightRecord).sort();
+    return leftKeys.length === rightKeys.length &&
+        leftKeys.every((key, index) => key === rightKeys[index] &&
+            sameJsonValue(leftRecord[key], rightRecord[key]));
+}
+function hasDerivedArguments(correctedArgs, originalArgs, originalPrompt) {
+    const originalLeaves = primitiveLeaves(originalArgs);
+    return primitiveLeaves(correctedArgs).every((leaf) => {
+        if (originalLeaves.some((candidate) => Object.is(candidate, leaf))) {
+            return true;
+        }
+        if (typeof leaf === "string") {
+            return promptContainsString(originalPrompt, leaf);
+        }
+        if (typeof leaf === "number" || typeof leaf === "boolean") {
+            return promptContainsPrimitive(originalPrompt, leaf);
+        }
+        return false;
+    });
+}
+function parseToolJson(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return { kind: "malformed" };
+        }
+        const record = value;
+        if (!isRouteToolName(record.name)) {
+            return { kind: "malformed" };
+        }
+        if (Object.keys(record).some((key) => !TOOL_CALL_KEYS.has(key))) {
+            return { kind: "malformed" };
+        }
+        const hasArguments = Object.prototype.hasOwnProperty.call(record, "arguments");
+        const hasArgs = Object.prototype.hasOwnProperty.call(record, "args");
+        if (hasArguments && hasArgs)
+            return { kind: "malformed" };
+        const rawArgs = hasArguments
+            ? record.arguments
+            : hasArgs
+                ? record.args
+                : {};
+        if (!rawArgs || typeof rawArgs !== "object" || Array.isArray(rawArgs)) {
+            return { kind: "malformed" };
+        }
+        if (!isBoundedJsonValue(rawArgs))
+            return { kind: "malformed" };
+        return {
+            kind: "tool_call",
+            name: record.name,
+            args: rawArgs,
+        };
+    }
+    catch {
+        return { kind: "malformed" };
+    }
+}
+function parseEnvelope(output, startToken, endToken) {
+    const start = output.indexOf(startToken);
+    const end = output.indexOf(endToken, start + startToken.length);
+    if (start < 0 ||
+        end < 0 ||
+        output.indexOf(startToken, start + startToken.length) >= 0 ||
+        output.indexOf(endToken, end + endToken.length) >= 0) {
+        return { kind: "malformed" };
+    }
+    const before = output.slice(0, start).trim();
+    const after = output.slice(end + endToken.length).trim();
+    if (before || after)
+        return { kind: "malformed" };
+    return parseToolJson(output.slice(start + startToken.length, end).trim());
+}
+export function parseRouteOutput(output) {
+    if (output.length > MAX_ROUTE_OUTPUT_CHARS)
+        return { kind: "malformed" };
+    const trimmed = output.trim();
+    const hasPipeMarker = trimmed.includes(PIPE_START) || trimmed.includes(PIPE_END);
+    if (hasPipeMarker)
+        return parseEnvelope(trimmed, PIPE_START, PIPE_END);
+    const hasAngleMarker = trimmed.includes(ANGLE_START) || trimmed.includes(ANGLE_END);
+    if (hasAngleMarker)
+        return parseEnvelope(trimmed, ANGLE_START, ANGLE_END);
+    // A route answer that starts like raw tool JSON is an attempted contract
+    // response. Treat invalid JSON/shape as malformed rather than returning it
+    // as ordinary prose that a host might accidentally interpret.
+    if (trimmed.startsWith("{"))
+        return parseToolJson(trimmed);
+    return { kind: "plain_text" };
+}
+export function applyLocalRouteContract(draft, allowedTools = DEFAULT_PRISM_ROUTE_TOOLS) {
+    const parsed = parseRouteOutput(draft);
+    if (parsed.kind === "plain_text") {
+        return { output: draft, action: "plain_text", source: "local" };
+    }
+    if (parsed.kind === "malformed") {
+        return {
+            output: "NO_TOOL",
+            action: "suppressed",
+            source: "local",
+            reason: "malformed_tool_call",
+        };
+    }
+    if (parsed.name === "NO_TOOL") {
+        return { output: "NO_TOOL", action: "plain_text", source: "local" };
+    }
+    if (!allowedTools.has(parsed.name)) {
+        return {
+            output: "NO_TOOL",
+            action: "suppressed",
+            source: "local",
+            original_tool: parsed.name,
+            reason: "unadvertised_tool",
+        };
+    }
+    return {
+        output: draft,
+        action: "preserved",
+        source: "local",
+        original_tool: parsed.name,
+        final_tool: parsed.name,
+    };
+}
+/**
+ * Validate a private portal correction before trusting it.
+ *
+ * The portal is an authenticated service, but the public client still treats
+ * its response as untrusted network input. The declared action must agree with
+ * the output shape and with the original draft.
+ */
+export function validatePortalRouteGuardOutcome(value, originalDraft, allowedTools, originalPrompt = "") {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (typeof record.output !== "string" ||
+        record.output.length === 0 ||
+        record.output.length > MAX_ROUTE_OUTPUT_CHARS ||
+        record.source !== "portal" ||
+        !["plain_text", "preserved", "remapped", "suppressed"].includes(typeof record.action === "string" ? record.action : "")) {
+        return null;
+    }
+    if (record.original_tool !== undefined &&
+        !isRouteToolName(record.original_tool)) {
+        return null;
+    }
+    if (record.final_tool !== undefined &&
+        !isRouteToolName(record.final_tool)) {
+        return null;
+    }
+    if (record.reason !== undefined &&
+        (typeof record.reason !== "string" ||
+            record.reason.length > MAX_ROUTE_REASON_CHARS)) {
+        return null;
+    }
+    const action = record.action;
+    const original = parseRouteOutput(originalDraft);
+    const corrected = parseRouteOutput(record.output);
+    if (action === "plain_text") {
+        if (original.kind !== "plain_text" || corrected.kind !== "plain_text") {
+            return null;
+        }
+    }
+    else if (action === "suppressed") {
+        if (original.kind !== "tool_call" ||
+            record.output.trim() !== "NO_TOOL" ||
+            (record.original_tool !== undefined &&
+                record.original_tool !== original.name) ||
+            record.final_tool !== undefined) {
+            return null;
+        }
+    }
+    else {
+        if (original.kind !== "tool_call" ||
+            corrected.kind !== "tool_call" ||
+            !allowedTools.has(corrected.name) ||
+            record.original_tool !== original.name ||
+            record.final_tool !== corrected.name) {
+            return null;
+        }
+        if (action === "preserved" && corrected.name !== original.name) {
+            return null;
+        }
+        if (action === "remapped" && corrected.name === original.name) {
+            return null;
+        }
+        if (action === "preserved" &&
+            !sameJsonValue(corrected.args, original.args)) {
+            return null;
+        }
+        if (action === "remapped" &&
+            !hasDerivedArguments(corrected.args, original.args, originalPrompt)) {
+            return null;
+        }
+    }
+    return {
+        output: record.output,
+        action,
+        source: "portal",
+        ...(record.original_tool !== undefined
+            ? { original_tool: record.original_tool }
+            : {}),
+        ...(record.final_tool !== undefined
+            ? { final_tool: record.final_tool }
+            : {}),
+        ...(record.reason !== undefined
+            ? { reason: record.reason }
+            : {}),
+    };
+}

package/dist/utils/synaluxSearch.js

@@ -69,7 +69,7 @@ async function portalPost(path, body, timeoutMs = 15_000) {
  * the shape of performWebSearch() in braveApi.ts.
  */
 export async function synaluxWebSearch(query, count = 10) {
-    debugLog(`[synaluxSearch] web search: q="${query}", limit=${count}`);
+    debugLog(`[synaluxSearch] web search: query_chars=${query.length}, limit=${count}`);
     const data = await portalPost("/api/v1/prism/search", {
         query,
         limit: Math.min(count, 20),
@@ -92,7 +92,7 @@ export async function synaluxWebSearch(query, count = 10) {
  * Used by code-mode handlers that pass raw data to the QuickJS sandbox.
  */
 export async function synaluxWebSearchRaw(query, count = 10) {
-    debugLog(`[synaluxSearch] web search raw: q="${query}", limit=${count}`);
+    debugLog(`[synaluxSearch] web search raw: query_chars=${query.length}, limit=${count}`);
     const data = await portalPost("/api/v1/prism/search", {
         query,
         limit: Math.min(count, 20),
@@ -118,7 +118,7 @@ export async function synaluxWebSearchRaw(query, count = 10) {
  * Returns formatted text matching performLocalSearch() shape.
  */
 export async function synaluxLocalSearch(query, count = 5) {
-    debugLog(`[synaluxSearch] local search: q="${query}", count=${count}`);
+    debugLog(`[synaluxSearch] local search: query_chars=${query.length}, count=${count}`);
     const data = await portalPost("/api/v1/prism/local-search", {
         query,
         count: Math.min(count, 20),
@@ -136,7 +136,7 @@ export async function synaluxLocalSearch(query, count = 5) {
  * Local/POI search raw — returns JSON string for code-mode sandbox.
  */
 export async function synaluxLocalSearchRaw(query, count = 5) {
-    debugLog(`[synaluxSearch] local search raw: q="${query}", count=${count}`);
+    debugLog(`[synaluxSearch] local search raw: query_chars=${query.length}, count=${count}`);
     const data = await portalPost("/api/v1/prism/local-search", {
         query,
         count: Math.min(count, 20),
@@ -162,7 +162,7 @@ export async function synaluxLocalSearchRaw(query, count = 5) {
  * AI-grounded answers via Synalux portal.
  */
 export async function synaluxBraveAnswers(query, model) {
-    debugLog(`[synaluxSearch] answers: q="${query}", model=${model || "default"}`);
+    debugLog(`[synaluxSearch] answers: query_chars=${query.length}, model=${model || "default"}`);
     const body = { query };
     if (model)
         body.model = model;
@@ -179,7 +179,7 @@ export async function synaluxBraveAnswers(query, model) {
  * Scrape a URL via Synalux portal. Returns the extracted content string.
  */
 export async function synaluxScrape(url, options) {
-    debugLog(`[synaluxSearch] scrape: url="${url}"`);
+    debugLog(`[synaluxSearch] scrape: url_chars=${url.length}`);
     const body = { url };
     if (options?.formats)
         body.formats = options.formats;
@@ -187,9 +187,13 @@ export async function synaluxScrape(url, options) {
         body.onlyMainContent = options.onlyMainContent;
     if (options?.waitFor !== undefined)
         body.waitFor = options.waitFor;
-    const data = await portalPost("/api/v1/prism/scrape", body);
+    const data = await portalPost("/api/v1/prism/scrape", body, options?.timeoutMs);
     if (data.status === "error") {
         throw new Error(`[synaluxSearch] scrape error: ${data.error || "unknown"}`);
     }
-    return data.content || "";
+    return data.content ||
+        data.data?.markdown ||
+        data.data?.html ||
+        data.data?.rawHtml ||
+        "";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prism-mcp-server",
-  "version": "20.2.6",
+  "version": "20.2.8",
   "mcpName": "io.github.dcostenco/prism-coder",
   "description": "Prism Coder — Cognitive memory + tool-calling intelligence for AI agents. Mind Palace persistent memory (BFCL Gold Certified, 100% Tool-Call Accuracy, 114 Agent Skills, PHI Guard, Tier Enforcement, Prompt-Based Skill Routing, Zero-Search HDC/HRR retrieval, HRR Semantic Drift Detection across BCBA/Coding/AAC domains, HIPAA-hardened local or subscription-gated Synalux storage, SLERP-optimized GRPO alignment) plus the prism-coder 1.7B–32B open-weights LLM fleet.",
   "module": "index.ts",
@@ -154,10 +154,11 @@
     "jsdom": "^29.0.1",
     "openai": "^6.32.0",
     "p-limit": "^7.3.0",
-    "postcss": "8.5.12",
+    "postcss": "8.5.23",
     "quickjs-emscripten": "^0.32.0",
     "smol-toml": "^1.7.0",
     "stream-json": "^2.0.0",
+    "tldts": "^7.0.27",
     "turndown": "^7.2.2",
     "zod": "^4.3.6"
   }

package/dist/boundaries/__tests__/boundaries.test.js

@@ -1,46 +0,0 @@
-/**
- * boundaries.ts unit tests
- *
- * Verifies structural invariants of the safety declaration:
- * - BOUNDARIES_VERSION is present and non-empty
- * - BOUNDARIES_TEXT covers safety-critical concepts
- * - Architecture/routing docs moved to server instructions (not per-call)
- */
-import { describe, it, expect } from "vitest";
-import { BOUNDARIES_VERSION, BOUNDARIES_TEXT } from "../../boundaries/boundaries.js";
-describe("BOUNDARIES_VERSION", () => {
-    it("is a non-empty string", () => {
-        expect(typeof BOUNDARIES_VERSION).toBe("string");
-        expect(BOUNDARIES_VERSION.length).toBeGreaterThan(0);
-    });
-});
-describe("BOUNDARIES_TEXT structure", () => {
-    it("is a non-empty string under 500 chars (compressed from ~2000)", () => {
-        expect(typeof BOUNDARIES_TEXT).toBe("string");
-        expect(BOUNDARIES_TEXT.length).toBeGreaterThan(50);
-        expect(BOUNDARIES_TEXT.length).toBeLessThan(600);
-    });
-    it("has no leading or trailing whitespace (trim() was applied)", () => {
-        expect(BOUNDARIES_TEXT).toBe(BOUNDARIES_TEXT.trim());
-    });
-    it("references BCBA reserved categories", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/BCBA reserved/i);
-    });
-    it("references fail-closed refusal for reserved content", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/refused/i);
-    });
-    it("states AAC access is never restricted as a consequence", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/AAC access is never restricted/i);
-    });
-    it("references restraint as reserved", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/restraint/i);
-    });
-    it("references crisis/self-harm interception", () => {
-        expect(BOUNDARIES_TEXT).toMatch(/crisis|self-harm/i);
-    });
-    it("does NOT contain architecture/routing docs (those moved to server instructions)", () => {
-        expect(BOUNDARIES_TEXT).not.toContain("session_save_ledger");
-        expect(BOUNDARIES_TEXT).not.toContain("inference routing");
-        expect(BOUNDARIES_TEXT).not.toMatch(/host note/i);
-    });
-});