santismm-knowledge-mcp 0.4.0 → 0.4.1

package/README.md

@@ -20,6 +20,20 @@ repository:
 
 Docs: https://santismm.com/en/mcp · Registry: `com.santismm/knowledge`
 
+## Where this server is listed
+
+Derived from the same list the site renders on its own MCP page, so a registry
+added there is linked from here too — and a directory that checks for a backlink
+before ranking a server finds one without anybody remembering to add it.
+
+- [registry.modelcontextprotocol.io](https://registry.modelcontextprotocol.io/v0/servers?search=com.santismm/knowledge)
+- [npmjs.com](https://www.npmjs.com/package/santismm-knowledge-mcp)
+- [pypi.org](https://pypi.org/project/santismm-knowledge-mcp/)
+- [github.com](https://github.com/santismm/santismm-knowledge-mcp)
+- [smithery.ai](https://smithery.ai/servers/santismm/knowledge)
+- [glama.ai](https://glama.ai/mcp/servers/santismm/santismm-knowledge-mcp)
+- [mcpservers.org](https://mcpservers.org/servers/santismm/santismm-knowledge-mcp)
+
 ## Run it locally (stdio)
 
 ```bash

package/content/labs/catalogue.json

@@ -0,0 +1,205 @@
+{
+  "source": "SANTISMM Labs catalogue",
+  "count": 21,
+  "results": [
+    {
+      "slug": "homeric-atlas",
+      "category": "experiments",
+      "status": "live",
+      "title": "Homeric Atlas",
+      "summary": "A probabilistic map of where the episodes of the Iliad and the Odyssey might have happened — each location classed as accepted, plausible, speculative or mythical, scored 0–12 against a published rubric, with sources, rival theories and reusable JSON/GeoJSON.",
+      "canonical_url": "https://santismm.com/en/labs/homeric-atlas",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "control-sandbox",
+      "category": "simulators",
+      "status": "live",
+      "title": "Agentic control sandbox",
+      "summary": "Interactive sandbox: configure an agent on six axes, pick an OWASP LLM Top 10 threat, switch the eighteen controls of the Agentic Control Matrix on and off, and read the coverage — quadrants filled, quadrants left empty, frameworks answered. Deliberately without a residual-risk score.",
+      "canonical_url": "https://santismm.com/en/labs/control-sandbox",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "agent-taxonomy",
+      "category": "experiments",
+      "status": "live",
+      "title": "Taxonomy of autonomous agents",
+      "summary": "An interactive taxonomy that encodes 24 AI agents — from OpenAI, Anthropic, Google, Microsoft, Amazon and SpaceXAI to the open-source frontier — as vectors across six orthogonal axes plus an action surface, with a filterable table, an A×T×I governance-risk matrix and a machine-readable JSON API.",
+      "canonical_url": "https://santismm.com/en/labs/agent-taxonomy",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "agent-economics",
+      "category": "calculators",
+      "status": "live",
+      "title": "The real economics of an AI agent",
+      "summary": "Estimate monthly operating cost, cost per correct outcome, savings, ROI and break-even from workload volume, token prices, tools, retries, human review and rework.",
+      "canonical_url": "https://labs.santismm.com/agent-economics",
+      "api_url": "https://labs.santismm.com/api/labs/agent-economics",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "evaluation-sample-size",
+      "category": "calculators",
+      "status": "live",
+      "title": "How many evaluations do I need?",
+      "summary": "Calculate how many cases you need to detect at least one failure at a chosen confidence level and to estimate its frequency with an explicit margin.",
+      "canonical_url": "https://labs.santismm.com/evaluation-sample-size",
+      "api_url": "https://labs.santismm.com/api/labs/evaluation-sample-size",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "human-supervision-capacity",
+      "category": "calculators",
+      "status": "live",
+      "title": "Human oversight capacity",
+      "summary": "Size review hours, escalations, FTE, cost, sustainable volume and backlog before putting an AI system into production.",
+      "canonical_url": "https://labs.santismm.com/human-supervision-capacity",
+      "api_url": "https://labs.santismm.com/api/labs/human-supervision-capacity",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "agent-vector",
+      "category": "converters",
+      "status": "live",
+      "title": "Use case → agentic vector",
+      "summary": "Classify a system across six behavioural axes and its action surfaces, estimate its governance-risk band, surface control signals and find its nearest neighbours among 24 mapped agents.",
+      "canonical_url": "https://labs.santismm.com/agent-vector",
+      "api_url": "https://labs.santismm.com/api/labs/agent-vector",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "control-framework-translator",
+      "category": "converters",
+      "status": "live",
+      "title": "Control and framework translator",
+      "summary": "Crosswalk the 18 Agentic Control Matrix controls to the EU AI Act, ISO 42001, NIST AI RMF, OWASP LLM Top 10 and MITRE ATLAS—with an explicit caveat: mapping is not compliance.",
+      "canonical_url": "https://labs.santismm.com/control-framework-translator",
+      "api_url": "https://labs.santismm.com/api/labs/control-framework-translator",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "llm-context-converter",
+      "category": "converters",
+      "status": "live",
+      "title": "LLM context in human terms",
+      "summary": "Convert tokens into words, pages, documents, reading and speaking minutes, context-window usage and approximate input cost.",
+      "canonical_url": "https://labs.santismm.com/llm-context-converter",
+      "api_url": "https://labs.santismm.com/api/labs/llm-context-converter",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "close-the-gap",
+      "category": "games",
+      "status": "live",
+      "title": "Close the gap",
+      "summary": "A five-round educational game: choose the right governance controls under a limited budget, close each agent's essential gaps and learn from immediate explanations.",
+      "canonical_url": "https://labs.santismm.com/close-the-gap",
+      "api_url": "https://labs.santismm.com/api/labs/close-the-gap",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "model-agent-harness",
+      "category": "games",
+      "status": "live",
+      "title": "Model, agent or harness?",
+      "summary": "Twelve cases to distinguish the base capability, the entity pursuing goals and the infrastructure connecting context, memory, tools and controls.",
+      "canonical_url": "https://labs.santismm.com/model-agent-harness",
+      "api_url": "https://labs.santismm.com/api/labs/model-agent-harness",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "benchmark-detective",
+      "category": "games",
+      "status": "live",
+      "title": "Benchmark detective",
+      "summary": "Investigate AI claims, choose the evidence that actually tests them and spot saturation, contamination, uncertainty and misleading metrics.",
+      "canonical_url": "https://labs.santismm.com/benchmark-detective",
+      "api_url": "https://labs.santismm.com/api/labs/benchmark-detective",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "world-exam-challenge",
+      "category": "games",
+      "status": "live",
+      "title": "World exam challenge",
+      "summary": "A twelve-round game about 18 university-entrance systems: compare demandingness, identify countries and separate cognitive profile from selective pressure.",
+      "canonical_url": "https://labs.santismm.com/world-exam-challenge",
+      "api_url": "https://labs.santismm.com/api/labs/world-exam-challenge",
+      "owner_server": "labs.santismm.com"
+    },
+    {
+      "slug": "profesiones-ia",
+      "category": "experiments",
+      "status": "live",
+      "title": "The professions most exposed to AI",
+      "summary": "An interactive map of the 22 occupational groups, comparing AI's theoretical capability against its observed real-world use (as of June 2026), with a category ranking, the most-exposed occupations and the macro figures — rigorously sourced.",
+      "canonical_url": "https://santismm.com/en/labs/profesiones-ia",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "ai-agent-benchmarks",
+      "category": "benchmarks",
+      "status": "snapshot",
+      "title": "AI Agent Benchmarks",
+      "summary": "A saturation tracker for AI-agent benchmarks: what they measure, SOTA, headroom, the human gap and research priority.",
+      "canonical_url": "https://benchmarks.santismm.com/",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "exigencia",
+      "category": "benchmarks",
+      "status": "live",
+      "title": "How demanding is each exam in the world?",
+      "summary": "An interactive benchmark comparing the academic demandingness of 18 university-entrance exams (PAES, PAU, IB, SAT, Gaokao, Suneung, JEE…) across 7 dimensions, with a world map, radars and ranking.",
+      "canonical_url": "https://santismm.com/labs/exigencia",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "paes-pau-ib",
+      "category": "benchmarks",
+      "status": "live",
+      "title": "PAES vs PAU vs IB",
+      "summary": "An interactive benchmark comparing the academic demandingness of Chile's PAES, Spain's PAU and the IB Diploma across 6 cognitive dimensions and 8 subjects, with radar charts.",
+      "canonical_url": "https://santismm.com/labs/paes-pau-ib",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "mundial-del-dinero",
+      "category": "experiments",
+      "status": "live",
+      "title": "The money World Cup",
+      "summary": "Which national team punches above its squad value at the 2026 World Cup. A live efficiency index — points vs €-value — team by team.",
+      "canonical_url": "https://santismm.com/en/labs/mundial-del-dinero",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "surf-atlas",
+      "category": "experiments",
+      "status": "live",
+      "title": "World Surf Atlas",
+      "summary": "An interactive atlas of 100+ world-class waves — wave direction (left / right / both), break type, level and month-by-month average wave height, plotted on a world map.",
+      "canonical_url": "https://santismm.com/en/sports/surf",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "ski-atlas",
+      "category": "experiments",
+      "status": "live",
+      "title": "World Ski Atlas",
+      "summary": "130+ ski resorts on a world map — skiable km, runs by difficulty, snow quality, monthly snowfall, temperature and sun, plus lift-pass prices.",
+      "canonical_url": "https://santismm.com/en/sports/ski",
+      "owner_server": "santismm.com"
+    },
+    {
+      "slug": "ebike-atlas",
+      "category": "experiments",
+      "status": "live",
+      "title": "World Bike Park Atlas",
+      "summary": "40+ lift-served MTB / e-bike parks worldwide — trails by difficulty, vertical drop, km, season window and day-pass prices, on a world map.",
+      "canonical_url": "https://santismm.com/en/sports/ebike",
+      "owner_server": "santismm.com"
+    }
+  ]
+}

package/content/library/devready-ep108-ai-customer-experiences.md

@@ -10,5 +10,4 @@ thumbnail: "https://i.ytimg.com/vi/eC66YJDR8yA/hqdefault.jpg"
 canonicalUrl: "https://www.youtube.com/watch?v=eC66YJDR8yA"
 links:
   - { platform: "youtube", lang: "en", url: "https://www.youtube.com/watch?v=eC66YJDR8yA" }
-  - { platform: "spotify", lang: "en", url: "https://open.spotify.com/show/4ESPCD6LXZGHsbYbV9KSQ7", label: "Listen on Spotify" }
 ---

package/content/patterns/reflection.json

@@ -1,5 +1,6 @@
 {
   "slug": "reflection",
+  "aliases": ["PAT-003"],
   "category": "reliability",
   "updated": "2026-06-21",
   "version": "1.0",

package/dist/articles.js

@@ -1,3 +1,4 @@
+import { norm, queryTerms } from "./shape.js";
 /**
  * Federated first-party article corpus.
  *
@@ -30,7 +31,7 @@ function validArticle(value) {
 }
 async function fetchCorpus() {
     const response = await fetch(ARTICLES_API_URL, {
-        headers: { Accept: "application/json", "User-Agent": "santismm-knowledge-mcp/0.4.0" },
+        headers: { Accept: "application/json", "User-Agent": "santismm-knowledge-mcp/0.4.1" },
         signal: AbortSignal.timeout(8_000),
         cache: "no-store",
     });
@@ -71,16 +72,10 @@ export function articlesForLocale(articles, locale) {
         return articles;
     return articles.filter((article) => article.language.toLowerCase().split("-")[0] === locale);
 }
-function normalise(value) {
-    return value
-        .normalize("NFD")
-        .replace(/[\u0300-\u036f]/g, "")
-        .toLowerCase();
-}
 /** Ranked accent-insensitive full-text search over the canonical API payload. */
 export function searchArticleCorpus(articles, query, limit) {
-    const terms = [...new Set(normalise(query).split(/[^a-z0-9]+/).filter((term) => term.length > 1))];
-    const phrase = normalise(query).trim();
+    const terms = queryTerms(query);
+    const phrase = norm(query).trim();
     if (terms.length === 0)
         return [];
     const weights = [
@@ -96,7 +91,7 @@ export function searchArticleCorpus(articles, query, limit) {
         const matchedTerms = new Set();
         let score = 0;
         for (const [field, weight] of weights) {
-            const value = normalise(Array.isArray(article[field]) ? article.topics.join(" ") : String(article[field]));
+            const value = norm(Array.isArray(article[field]) ? article.topics.join(" ") : String(article[field]));
             for (const term of terms) {
                 if (!value.includes(term))
                     continue;
@@ -107,9 +102,10 @@ export function searchArticleCorpus(articles, query, limit) {
             if (phrase.length > 2 && value.includes(phrase))
                 score += weight * 2;
         }
+        const coverage = matchedTerms.size / terms.length;
         return {
             ...articleCard(article),
-            score,
+            score: Math.round(score * coverage * coverage * 100) / 100,
             matchedFields: [...matchedFields],
             matchedTerms: [...matchedTerms],
         };

package/dist/content.js

@@ -191,4 +191,19 @@ function loadClaims() {
         .filter((f) => f.endsWith(".json"))
         .map((f) => JSON.parse(fs.readFileSync(path.join(dir, f), "utf8")));
 }
-export const fsContent = makeContent(loadAll, loadHandbook, loadHomeric, loadClaims);
+/**
+ * El catálogo de labs, desde la copia generada que viaja con el corpus.
+ *
+ * El paquete publicado no ve `lib/labs.ts`, así que sin este fichero el CLI
+ * serviría diez labs mientras el ápice anuncia veintiuno. Un catálogo ausente
+ * se lee como cero, no como error: por eso el validador comprueba que existe
+ * y que coincide con lo que saldría de regenerarlo.
+ */
+function loadSiteLabs() {
+    const file = path.join(CONTENT_ROOT, "labs", "catalogue.json");
+    if (!fs.existsSync(file))
+        return [];
+    const raw = JSON.parse(fs.readFileSync(file, "utf8"));
+    return Array.isArray(raw.results) ? raw.results : [];
+}
+export const fsContent = makeContent(loadAll, loadHandbook, loadHomeric, loadClaims, loadSiteLabs);

package/dist/labs.js

@@ -1,3 +1,4 @@
+import { norm, queryTerms } from "./shape.js";
 /**
  * Federated SANTISMM Labs catalogue and deterministic calculators.
  *
@@ -36,7 +37,7 @@ function validLab(value) {
 }
 async function fetchCorpus() {
     const response = await fetch(LABS_API_URL, {
-        headers: { Accept: 'application/json', 'User-Agent': 'santismm-knowledge-mcp/0.4.0' },
+        headers: { Accept: 'application/json', 'User-Agent': 'santismm-knowledge-mcp/0.4.1' },
         signal: AbortSignal.timeout(8_000),
         cache: 'no-store',
     });
@@ -67,12 +68,9 @@ export async function loadLabs() {
     }
     return (await pending).results;
 }
-function normalise(value) {
-    return value.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
-}
 export function searchLabCorpus(labs, query, limit) {
-    const terms = [...new Set(normalise(query).split(/[^a-z0-9]+/).filter((term) => term.length > 1))];
-    const phrase = normalise(query).trim();
+    const terms = queryTerms(query);
+    const phrase = norm(query).trim();
     if (terms.length === 0)
         return [];
     const fields = [
@@ -86,7 +84,7 @@ export function searchLabCorpus(labs, query, limit) {
         let score = 0;
         for (const [field, weight] of fields) {
             const raw = lab[field];
-            const value = normalise(Array.isArray(raw) ? raw.join(' ') : String(raw ?? ''));
+            const value = norm(Array.isArray(raw) ? raw.join(' ') : String(raw ?? ''));
             for (const term of terms) {
                 if (!value.includes(term))
                     continue;
@@ -97,19 +95,25 @@ export function searchLabCorpus(labs, query, limit) {
             if (phrase.length > 2 && value.includes(phrase))
                 score += weight * 2;
         }
-        return { ...lab, score, matchedFields: [...matchedFields], matchedTerms: [...matchedTerms] };
+        const coverage = matchedTerms.size / terms.length;
+        return {
+            ...lab,
+            score: Math.round(score * coverage * coverage * 100) / 100,
+            matchedFields: [...matchedFields],
+            matchedTerms: [...matchedTerms],
+        };
     })
         .filter((lab) => lab.score > 0)
         .sort((a, b) => b.score - a.score || b.updated.localeCompare(a.updated) || a.slug.localeCompare(b.slug))
         .slice(0, limit);
 }
-export async function executeLabCalculator(slug, inputs) {
-    const response = await fetch(`${LABS_SERVICE_ORIGIN}/api/calculate/${slug}`, {
+export async function executeLabCalculator(slug, inputs, locale = 'en') {
+    const response = await fetch(`${LABS_SERVICE_ORIGIN}/api/calculate/${slug}?locale=${locale}`, {
         method: 'POST',
         headers: {
             Accept: 'application/json',
             'Content-Type': 'application/json',
-            'User-Agent': 'santismm-knowledge-mcp/0.4.0',
+            'User-Agent': 'santismm-knowledge-mcp/0.4.1',
         },
         body: JSON.stringify(inputs),
         signal: AbortSignal.timeout(8_000),

package/dist/outcomes.js

@@ -0,0 +1,163 @@
+/**
+ * MCP result semantics, independent of the analytics backend.
+ *
+ * A transport can observe a handler result without importing Redis, and the
+ * stdio server can keep using the same registry without recording anything.
+ * The important boundary is the handler's FINAL result: a federated
+ * `search_all` is successful when any selected surface returned a hit, even
+ * when the local core sub-search was empty.
+ */
+import { SEARCH_SURFACES } from "./surfaces.js";
+export const MCP_OUTCOMES = ["ok", "partial", "empty", "not_found", "error"];
+export const MCP_DEMAND_CLASSES = [
+    "answered",
+    "partial_answer",
+    "content_gap",
+    "wrong_tool",
+    "invalid_identifier",
+    "surface_unavailable",
+    "catalogue_empty",
+    "execution_error",
+];
+const GET_DETAIL = {
+    get_knowledge: { domain: "knowledge", argument: "slug" },
+    get_pattern: { domain: "patterns", argument: "slug" },
+    get_architecture: { domain: "architectures", argument: "slug" },
+    get_governance: { domain: "governance", argument: "slug" },
+    get_handbook: { domain: "handbook", argument: "id" },
+    get_article: { domain: "articles", argument: "slug" },
+    get_lab: { domain: "labs", argument: "slug" },
+    get_homeric_place: { domain: "homeric/places", argument: "slug" },
+    get_homeric_episode: { domain: "homeric/episodes", argument: "slug" },
+    get_homeric_route: { domain: "homeric/routes", argument: "slug" },
+    get_claim: { domain: "claims", argument: "id" },
+};
+export function lookupRequestForTool(tool, args) {
+    if (tool === "get_related") {
+        const domain = boundedText(args.domain);
+        const identifier = boundedText(args.slug);
+        return domain && identifier ? { domain, identifier } : undefined;
+    }
+    const descriptor = GET_DETAIL[tool];
+    if (!descriptor)
+        return undefined;
+    const identifier = boundedText(args[descriptor.argument]);
+    return identifier ? { domain: descriptor.domain, identifier } : undefined;
+}
+function record(value) {
+    return value && typeof value === "object" ? value : undefined;
+}
+function errorBody(result) {
+    const first = result.content?.find((part) => part.type === "text" && typeof part.text === "string");
+    if (!first?.text)
+        return undefined;
+    try {
+        return record(JSON.parse(first.text));
+    }
+    catch {
+        return undefined;
+    }
+}
+function boundedText(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const clean = value.trim();
+    return clean ? clean.slice(0, 100) : undefined;
+}
+/** The privacy-bounded label stored for consumption and unresolved rankings. */
+export function detailForTool(tool, args) {
+    if (tool.startsWith("search")) {
+        const query = boundedText(args.query);
+        return query ? `search: ${query}` : undefined;
+    }
+    const lookup = lookupRequestForTool(tool, args);
+    return lookup ? `${lookup.domain}/${lookup.identifier}` : undefined;
+}
+function globalSearchDetail(args, structured) {
+    const selected = Array.isArray(args.surfaces)
+        ? args.surfaces.filter((surface) => typeof surface === "string")
+        : [...SEARCH_SURFACES];
+    const results = Array.isArray(structured?.results) ? structured.results : [];
+    const top = record(results[0]);
+    const unavailableRows = Array.isArray(structured?.unavailable_surfaces)
+        ? structured.unavailable_surfaces
+        : [];
+    return {
+        queried: selected,
+        topSurface: typeof top?.surface === "string" ? top.surface : undefined,
+        suggestedTool: typeof top?.suggested_tool === "string" ? top.suggested_tool : undefined,
+        unavailable: unavailableRows
+            .map((row) => record(row)?.surface)
+            .filter((surface) => typeof surface === "string"),
+    };
+}
+/**
+ * Classify the response the caller received. No sub-search, loader or counter
+ * is consulted here; the final handler payload is the source of truth.
+ */
+export function summarizeToolResult(event) {
+    const detail = detailForTool(event.tool, event.args);
+    if (event.error !== undefined) {
+        return { tool: event.tool, outcome: "error", demandClass: "execution_error", detail };
+    }
+    const result = record(event.result);
+    if (!result) {
+        return { tool: event.tool, outcome: "error", demandClass: "execution_error", detail };
+    }
+    const structured = record(result.structuredContent);
+    const globalSearch = event.tool === "search_all" ? globalSearchDetail(event.args, structured) : undefined;
+    if (result.isError) {
+        const body = errorBody(result);
+        const code = typeof body?.error === "string" ? body.error : "error";
+        const foundIn = record(body?.found_in);
+        if (code === "not_found") {
+            const exact = typeof foundIn?.domain === "string" &&
+                typeof foundIn?.id === "string" &&
+                typeof foundIn?.tool === "string"
+                ? { domain: foundIn.domain, id: foundIn.id, tool: foundIn.tool }
+                : undefined;
+            return {
+                tool: event.tool,
+                outcome: "not_found",
+                demandClass: exact ? "wrong_tool" : "invalid_identifier",
+                detail,
+                foundIn: exact,
+                globalSearch,
+            };
+        }
+        if (code.includes("unavailable") || code.includes("failed")) {
+            return { tool: event.tool, outcome: "error", demandClass: "surface_unavailable", detail, globalSearch };
+        }
+        return { tool: event.tool, outcome: "error", demandClass: "execution_error", detail, globalSearch };
+    }
+    const count = typeof structured?.count === "number" ? structured.count : undefined;
+    const unavailable = globalSearch?.unavailable.length ?? 0;
+    if (event.tool === "search_all" && unavailable > 0) {
+        if (!count || count === 0) {
+            return {
+                tool: event.tool,
+                outcome: "error",
+                demandClass: "surface_unavailable",
+                detail,
+                globalSearch,
+            };
+        }
+        return {
+            tool: event.tool,
+            outcome: "partial",
+            demandClass: "partial_answer",
+            detail,
+            globalSearch,
+        };
+    }
+    if (count === 0) {
+        return {
+            tool: event.tool,
+            outcome: "empty",
+            demandClass: event.tool.startsWith("search") ? "content_gap" : "catalogue_empty",
+            detail,
+            globalSearch,
+        };
+    }
+    return { tool: event.tool, outcome: "ok", demandClass: "answered", detail, globalSearch };
+}

package/dist/shape.js

@@ -1,3 +1,4 @@
+import { SURFACE_TOOLS } from "./surfaces.js";
 /**
  * Framework-agnostic shaping layer for the MCP corpus.
  *
@@ -161,14 +162,19 @@ const STOPWORDS = new Set([
     // en
     "the", "a", "an", "of", "for", "and", "or", "to", "in", "on", "with", "is",
     "are", "what", "how", "why", "when", "that", "this", "it", "as", "by", "from",
-    "at", "be", "can", "do", "does",
+    "at", "be", "can", "do", "does", "where", "who", "which", "would",
+    "could", "should", "need", "was", "were", "has", "have", "had", "my",
+    "your", "their", "about", "into", "than", "then",
     // es
     "el", "la", "los", "las", "un", "una", "unos", "unas", "de", "del", "y", "o",
     "para", "por", "con", "en", "que", "es", "son", "como", "cual", "cuando",
-    "sobre", "al", "se", "su", "sus", "antes", "despues", "mas",
+    "sobre", "al", "se", "su", "sus", "antes", "despues", "mas", "donde",
+    "quien", "necesito", "necesita", "hay", "ha", "han", "mi", "tu", "este",
+    "esta", "estos", "estas",
     // pt
     "o", "os", "as", "um", "uma", "e", "ou", "para", "por", "com", "em", "que",
     "sao", "como", "quando", "sobre", "ao", "dos", "das", "no", "na", "se", "seu",
+    "onde", "quem", "preciso", "precisa", "ha", "meu", "minha", "este", "esta",
 ]);
 /**
  * Very light stemming: trims a common plural ending so a query term matches the
@@ -183,6 +189,20 @@ function stem(token) {
         return token.slice(0, -1);
     return token;
 }
+/**
+ * One query parser for every MCP search surface.
+ *
+ * The core search already discarded function words, but Articles, Labs,
+ * claims and the Homeric Atlas each tokenised the raw question independently.
+ * In `search_all`, a Lab matching only "to" and "do" could therefore outrank
+ * the calculator named by the informative terms. Keeping the parser here
+ * makes the five surfaces agree on what a term is and prevents that drift.
+ */
+export function queryTerms(query) {
+    const all = norm(query).split(/[^a-z0-9]+/).filter((token) => token.length >= 2);
+    const meaningful = all.filter((token) => !STOPWORDS.has(token));
+    return [...new Set((meaningful.length > 0 ? meaningful : all).map(stem))];
+}
 /** Relative importance of each field when scoring a search hit. */
 /**
  * Cuánto puede sumar como mucho la centralidad. Por debajo del peso de un
@@ -457,8 +477,36 @@ function summarizeHomeric(kind, e, locale) {
         api_url: `${SITE_URL}/api/homeric/${kind}/${e.slug}`,
     };
 }
-export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims) {
-    const getOne = (domain, slug) => loadAll(domain).find((e) => e.slug === slug);
+export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims, loadSiteLabs) {
+    /**
+     * Una unidad se alcanza por su slug, por el identificador que ella misma
+     * declara (`ARCH-001`, `GOV-004`) y por los alias que arrastra del manual
+     * (`PAT-001`). El corpus publicaba esos identificadores —en el JSON, en el
+     * frontmatter y en la prosa de los capítulos— y después los rechazaba:
+     * `get_pattern("PAT-001")`, `get_governance("GOV-001")` y
+     * `get_architecture("ARCH-001")` devolvían `not_found` sobre unidades que
+     * existen. Es la misma inferencia por analogía que la analítica midió
+     * (`handbook/arch-001`, 15 veces): el agente no se lo inventaba, se lo
+     * habíamos anunciado nosotros.
+     *
+     * Sin distinguir mayúsculas, porque la prosa cita `PAT-001` y una URL trae
+     * `pat-001`, y el espacio de identificadores no debería depender de eso.
+     */
+    const getOne = (domain, slug) => {
+        const entries = loadAll(domain);
+        const exact = entries.find((e) => e.slug === slug);
+        if (exact)
+            return exact;
+        const needle = slug.toUpperCase();
+        return entries.find((e) => {
+            const r = e;
+            if (typeof r.id === "string" && r.id.toUpperCase() === needle)
+                return true;
+            if (Array.isArray(r.aliases))
+                return r.aliases.some((a) => typeof a === "string" && a.toUpperCase() === needle);
+            return false;
+        }) ?? entries.find((e) => e.slug.toUpperCase() === needle);
+    };
     /**
      * Enlaces entrantes por unidad — la única señal de centralidad que este
      * corpus ya tiene, y la que decide un empate de puntuación.
@@ -554,7 +602,7 @@ export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims) {
                     {
                         surface: "articles",
                         description: "Federated first-party long-form essays, read from their canonical Articles API at call time.",
-                        tools: ["list_articles", "get_article", "search_articles"],
+                        tools: [...SURFACE_TOOLS.articles],
                         source: "https://articles.santismm.com/api/articles.json",
                         lookup: "article slug",
                         citation: "Each result carries canonical_url.",
@@ -562,11 +610,7 @@ export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims) {
                     {
                         surface: "homeric_atlas",
                         description: "Places, episodes and rival route reconstructions using the atlas identification vocabulary and 0–12 rubric.",
-                        tools: [
-                            "list_homeric_places", "get_homeric_place",
-                            "list_homeric_episodes", "get_homeric_episode",
-                            "list_homeric_routes", "get_homeric_route",
-                        ],
+                        tools: [...SURFACE_TOOLS.homeric_atlas],
                         source: `${SITE_URL}/api/homeric-atlas.json`,
                         lookup: "place, episode or route slug",
                         citation: "Each content result carries canonical_url and api_url.",
@@ -574,7 +618,7 @@ export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims) {
                     {
                         surface: "claims",
                         description: "The corpus's load-bearing claims with epistemic type, confidence, basis, limitations and falsification criteria.",
-                        tools: ["list_claims", "get_claim"],
+                        tools: [...SURFACE_TOOLS.claims],
                         source: "bundled claim registry",
                         lookup: "claim id (for example HE-CLAIM-001) or slug",
                         citation: "Claims have no public page; cite their stable id and the MCP endpoint.",
@@ -582,12 +626,7 @@ export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims) {
                     {
                         surface: "labs",
                         description: "Interactive calculators, converters, experiments and educational games; three calculators execute deterministic, versioned formulas through the canonical Labs API.",
-                        tools: [
-                            "list_labs", "get_lab",
-                            "calculate_agent_economics",
-                            "calculate_evaluation_sample_size",
-                            "calculate_human_supervision_capacity",
-                        ],
+                        tools: [...SURFACE_TOOLS.labs],
                         source: "https://labs.santismm.com/api/labs",
                         lookup: "Lab slug; executable tools take typed numeric assumptions",
                         citation: "Definitions and calculation results carry canonical_url, api_url, version, assumptions and warnings.",
@@ -650,10 +689,7 @@ export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims) {
         search(query, domains = [...DOMAINS, "handbook"], limit = 20, locale = "en") {
             // norm() has already stripped diacritics, so a plain alphanumeric split
             // is enough (and avoids needing Unicode property escapes).
-            const all = norm(query).split(/[^a-z0-9]+/).filter((t) => t.length >= 2);
-            // Drop function words — unless that would leave nothing to search for.
-            const meaningful = all.filter((t) => !STOPWORDS.has(t));
-            const tokens = [...new Set((meaningful.length > 0 ? meaningful : all).map(stem))];
+            const tokens = queryTerms(query);
             if (tokens.length === 0)
                 return [];
             // Collect the candidate documents first, so term specificity (IDF) can be
@@ -706,6 +742,13 @@ export function makeContent(loadAll, loadHandbook, loadHomeric, loadClaims) {
             scored.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
             return scored.slice(0, limit);
         },
+        /**
+         * El catálogo de labs del sitio. Vacío cuando nadie lo inyecta, igual que
+         * el manual o el Atlas: el proveedor decide qué superficies existen.
+         */
+        listSiteLabs() {
+            return loadSiteLabs ? loadSiteLabs() : [];
+        },
         /**
          * Claims (ADR 0003). The card carries the type and the confidence, because
          * that is the whole point: an agent must be able to tell an observed fact

package/dist/surfaces.js

@@ -0,0 +1,65 @@
+/**
+ * A qué superficie pertenece cada herramienta — declarado una vez.
+ *
+ * `get_overview` ya enumeraba las superficies de extensión con sus
+ * herramientas, y la analítica contaba por herramienta y nada más. Cruzar las
+ * dos cosas exigía una tabla escrita a mano, que es la clase de cifra que
+ * acaba estando mal: cada herramienta nueva la habría dejado incompleta en
+ * silencio, y una superficie sin datos se lee como «nadie la usa».
+ *
+ * Aquí no sobra nada por descarte: el núcleo se declara igual que las
+ * extensiones. `meta` son las dos transversales —`get_overview` y
+ * `search_all`— y separarlas no es cosmético: la lectura de 90 días encontró
+ * que ~16.400 de 39.499 peticiones eran saludo y catálogo, así que mezclarlas
+ * con el consumo de contenido es justo lo que hace que el volumen parezca
+ * tracción.
+ *
+ * `SURFACE_TOOLS` es la fuente; `get_overview` sirve las extensiones desde
+ * ella y la analítica deriva su vocabulario de la misma constante. Una
+ * herramienta que no aparezca aquí pone rojo `npm run validate`.
+ */
+export const SURFACE_TOOLS = {
+    core: [
+        "list_knowledge", "get_knowledge",
+        "list_patterns", "get_pattern",
+        "list_architectures", "get_architecture",
+        "list_governance", "get_governance",
+        "list_handbook", "get_handbook",
+        "get_related", "search",
+    ],
+    meta: ["get_overview", "search_all"],
+    articles: ["list_articles", "get_article", "search_articles"],
+    homeric_atlas: [
+        "list_homeric_places", "get_homeric_place",
+        "list_homeric_episodes", "get_homeric_episode",
+        "list_homeric_routes", "get_homeric_route",
+    ],
+    claims: ["list_claims", "get_claim"],
+    labs: [
+        "list_labs", "get_lab",
+        "calculate_agent_economics",
+        "calculate_evaluation_sample_size",
+        "calculate_human_supervision_capacity",
+    ],
+};
+/** Las superficies, en orden estable. */
+export const SURFACES = Object.keys(SURFACE_TOOLS);
+/**
+ * Surfaces queried by the federated search, shared by its schemas, handler and
+ * final-outcome observer. Keeping this beside the import-free surface registry
+ * avoids a tools.ts <-> outcomes.ts cycle and makes a search-surface change
+ * atomic for both execution and measurement.
+ */
+export const SEARCH_SURFACES = ["core", "articles", "labs", "claims", "homeric_atlas"];
+/**
+ * Las tres primitivas del protocolo. Hoy todo se expresa con `tool`, y por eso
+ * el eje se registra desde el principio: si Resources y Prompts (REG-19,
+ * REG-20) llegaran a una analítica que solo cuenta herramientas, dos semanas
+ * de datos dirían que nadie los usa cuando lo que pasa es que nadie los mide.
+ */
+export const PRIMITIVES = ["tool", "resource", "prompt"];
+const BY_TOOL = new Map(SURFACES.flatMap((s) => SURFACE_TOOLS[s].map((t) => [t, s])));
+/** La superficie de una herramienta, o `undefined` si no está declarada. */
+export function surfaceOf(tool) {
+    return BY_TOOL.get(tool);
+}

package/dist/tools.js

@@ -1,6 +1,9 @@
 import { z } from "zod";
+import { norm, queryTerms } from "./shape.js";
 import { ARTICLES_API_URL, articleCard, articlesForLocale, loadArticles, searchArticleCorpus, } from "./articles.js";
 import { LABS_API_URL, executeLabCalculator, loadLabs, searchLabCorpus, } from "./labs.js";
+import { lookupRequestForTool, summarizeToolResult, } from "./outcomes.js";
+import { SEARCH_SURFACES } from "./surfaces.js";
 /**
  * Single, framework-agnostic definition of the Santismm Knowledge MCP server:
  * its identity and the tool registry. Both transports — the stdio CLI
@@ -10,7 +13,7 @@ import { LABS_API_URL, executeLabCalculator, loadLabs, searchLabCorpus, } from "
  * `McpContent` provider); both providers read the same canonical repository
  * data, while Article tools deliberately read the first-party Articles API.
  */
-export const SERVER_INFO = { name: "santismm-knowledge", version: "0.4.0" };
+export const SERVER_INFO = { name: "santismm-knowledge", version: "0.4.1" };
 /**
  * Core tools read a static local corpus, so all four hints are literally true:
  * nothing mutates, the same arguments produce the same answer, and no core
@@ -293,6 +296,77 @@ function distancia(a, b, tope) {
 function normalizar(s) {
     return s.toLowerCase().replace(/[\s_]+/g, "-");
 }
+function urlSlug(value) {
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return new URL(value).pathname.split("/").filter(Boolean).at(-1);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Enrich a direct lookup miss without delaying the tool response itself.
+ *
+ * Local recovery payloads already carry `found_in`. Federated Articles and
+ * Labs cannot be inspected synchronously by `noEncontrado`, so the hosted
+ * analytics callback runs this after the response and checks their cached
+ * canonical catalogues. A Portuguese Article slug sent to
+ * `get_architecture`, for example, is a wrong-tool event, not a content gap.
+ */
+export async function observeToolResult(event, content) {
+    const observation = summarizeToolResult(event);
+    if (observation.demandClass !== "invalid_identifier")
+        return observation;
+    const lookup = lookupRequestForTool(event.tool, event.args);
+    if (!lookup)
+        return observation;
+    const wanted = normalizar(lookup.identifier);
+    for (const space of ESPACIOS) {
+        if (space.domain === lookup.domain || space.domain === "articles" || space.domain === "labs")
+            continue;
+        try {
+            const exact = cardsDe(content, space.domain, "en").find((candidate) => {
+                const item = candidate;
+                return [item?.id, item?.slug].some((identifier) => typeof identifier === "string" && normalizar(identifier) === wanted);
+            });
+            const id = exact && (typeof exact.slug === "string" ? exact.slug : exact.id);
+            if (typeof id === "string") {
+                return {
+                    ...observation,
+                    demandClass: "wrong_tool",
+                    foundIn: { domain: space.domain, id, tool: space.getTool },
+                };
+            }
+        }
+        catch {
+            // One optional recovery surface cannot hide the original observation.
+        }
+    }
+    const [articleLoad, labLoad] = await Promise.allSettled([loadArticles(), loadLabs()]);
+    if (lookup.domain !== "articles" && articleLoad.status === "fulfilled") {
+        const article = articleLoad.value.find((candidate) => [candidate.slug, urlSlug(candidate.canonical_url), urlSlug(candidate.api_url)].some((identifier) => typeof identifier === "string" && normalizar(identifier) === wanted));
+        if (article) {
+            return {
+                ...observation,
+                demandClass: "wrong_tool",
+                foundIn: { domain: "articles", id: article.slug, tool: "get_article" },
+            };
+        }
+    }
+    if (lookup.domain !== "labs" && labLoad.status === "fulfilled") {
+        const lab = labLoad.value.find((candidate) => normalizar(candidate.slug) === wanted);
+        if (lab) {
+            return {
+                ...observation,
+                demandClass: "wrong_tool",
+                foundIn: { domain: "labs", id: lab.slug, tool: "get_lab" },
+            };
+        }
+    }
+    return observation;
+}
 /** Most identifiers a not-found payload will spell out before summarising. */
 const MUESTRA_MAXIMA = 30;
 /**
@@ -481,7 +555,22 @@ const relatedContentSchema = z.object({
     url: z.string(),
     relationship: z.string(),
 });
-const labCardSchema = z.object({
+/**
+ * Un lab es una de dos cosas y el contrato lo dice en vez de difuminarlo.
+ *
+ * Las diez que ejecuta el servicio federado traen fórmulas, entradas, salidas
+ * y supuestos: eso es lo que hace verificable un cálculo y no se afloja a
+ * opcional para que quepan las otras. Las once del ápice son páginas que se
+ * leen —el Atlas Homérico, el sandbox, la taxonomía, los benchmarks, los
+ * atlas deportivos— y declararles `inputs: []` sería mentir con la forma.
+ *
+ * `executable` es el discriminante, y responde la única pregunta que un
+ * agente necesita antes de decidir qué hacer con la unidad: ¿esto se calcula
+ * o esto se lee?
+ */
+const executableLabSchema = z.object({
+    executable: z.literal(true),
+    owner_server: z.string().describe("Host that serves and versions this unit."),
     slug: z.string(),
     kind: z.enum(["calculator", "converter", "experiment", "educational-game"]),
     label: z.string(),
@@ -498,6 +587,17 @@ const labCardSchema = z.object({
     calculation_url: z.string().optional(),
     related_content: z.array(relatedContentSchema).optional(),
 });
+const pageLabSchema = z.object({
+    executable: z.literal(false),
+    owner_server: z.string().describe("Host that serves this unit."),
+    slug: z.string(),
+    category: z.string().describe("benchmarks, simulators, experiments, games…"),
+    status: z.string(),
+    title: z.string(),
+    summary: z.string().optional(),
+    canonical_url: z.string().describe("Cite this URL."),
+});
+const labCardSchema = z.discriminatedUnion("executable", [executableLabSchema, pageLabSchema]);
 const labListOutput = { count: z.number(), results: z.array(labCardSchema) };
 const calculationBaseSchema = z.object({
     schema_version: z.string(),
@@ -537,7 +637,7 @@ const humanSupervisionOutput = calculationBaseSchema.extend({
     }),
 });
 const globalSearchCard = z.object({
-    surface: z.enum(["core", "articles", "labs", "claims"]),
+    surface: z.enum(SEARCH_SURFACES),
     score: z.number(),
     source_score: z.number(),
     rank_within_surface: z.number(),
@@ -623,47 +723,147 @@ function labNotFound(labs, slug) {
     return { content: [{ type: "text", text: JSON.stringify(body, null, 2) }], isError: true };
 }
 function termsFor(query) {
-    return [...new Set(query.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().split(/[^a-z0-9]+/).filter((term) => term.length > 1))];
+    return queryTerms(query);
+}
+/**
+ * Puntuación por campos con peso, compartida por las superficies que no
+ * tienen scorer propio. Este corpus ya arrastra cuatro implementaciones del
+ * ranking (núcleo, artículos, labs y claims) y la lección de REG-12 vale
+ * igual aquí: dos implementaciones del scoring divergirían. La homérica no
+ * añade una quinta — reutiliza ésta.
+ */
+function fieldScore(record, fields, terms) {
+    let score = 0;
+    const matchedFields = new Set();
+    const matchedTerms = new Set();
+    for (const [field, weight] of fields) {
+        const value = norm(String(record[field] ?? ""));
+        for (const term of terms) {
+            if (!value.includes(term))
+                continue;
+            score += weight;
+            matchedFields.add(field);
+            matchedTerms.add(term);
+        }
+    }
+    const coverage = terms.length > 0 ? matchedTerms.size / terms.length : 0;
+    return {
+        score: Math.round(score * coverage * coverage * 100) / 100,
+        matchedFields: [...matchedFields],
+        matchedTerms: [...matchedTerms],
+    };
 }
 function claimSearch(content, query, locale, limit) {
     const terms = termsFor(query);
+    const fields = [["statement", 7], ["slug", 6], ["id", 5], ["claim_type", 4]];
     return content.listClaims(undefined, locale)
-        .map((claim) => {
-        const fields = [["statement", 7], ["slug", 6], ["id", 5], ["claim_type", 4]];
-        let score = 0;
-        const matchedFields = new Set();
-        const matchedTerms = new Set();
-        for (const [field, weight] of fields) {
-            const value = String(claim[field] ?? "").normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
-            for (const term of terms) {
-                if (!value.includes(term))
-                    continue;
-                score += weight;
-                matchedFields.add(field);
-                matchedTerms.add(term);
-            }
-        }
-        return { claim, score, matchedFields: [...matchedFields], matchedTerms: [...matchedTerms] };
-    })
+        .map((claim) => ({ claim, ...fieldScore(claim, fields, terms) }))
         .filter((hit) => hit.score > 0)
         .sort((a, b) => b.score - a.score || String(a.claim.id).localeCompare(String(b.claim.id)))
         .slice(0, limit);
 }
+/**
+ * El Atlas Homérico tiene seis herramientas propias desde hace semanas, así
+ * que su contenido SÍ es alcanzable — pero `search_all` declaraba cuatro
+ * superficies y ninguna era la suya. Quien preguntase por Ítaca en la
+ * búsqueda global no encontraba nada y no tenía por qué saber que existe un
+ * `list_homeric_places` al que llamar. Es el hueco que REG-17 nombra: no
+ * falta contenido, falta que el catálogo represente la superficie entera.
+ */
+const HOMERIC_TOOL = {
+    places: "get_homeric_place",
+    episodes: "get_homeric_episode",
+    routes: "get_homeric_route",
+};
+function homericSearch(content, query, locale, limit) {
+    const terms = termsFor(query);
+    const fields = [
+        ["name", 8], ["slug", 7], ["summary", 6], ["identification", 5],
+        ["region", 4], ["work", 3], ["citation", 2], ["kind", 1],
+    ];
+    const hits = [];
+    for (const kind of ["places", "episodes", "routes"])
+        for (const raw of content.listHomeric(kind, locale)) {
+            const scored = fieldScore(raw, fields, terms);
+            // A natural question often adds generic qualifiers ("how strong is the
+            // evidence?") after naming the entity. Those words may occur together
+            // in another entry's prose; an exact slug/name still has to win because
+            // it is the object the caller explicitly named.
+            const identifiers = [raw.slug, raw.name, raw.id]
+                .map((value) => norm(String(value ?? "")))
+                .filter(Boolean);
+            const exactIdentifier = identifiers.some((identifier) => identifier.split(" ").every((part) => terms.includes(part)));
+            const score = scored.score + (exactIdentifier ? 12 : 0);
+            if (score > 0)
+                hits.push({ ...raw, ...scored, score, kind });
+        }
+    return hits
+        .sort((a, b) => b.score - a.score || String(a.slug).localeCompare(String(b.slug)))
+        .slice(0, limit);
+}
 const GET_TOOL_FOR_DOMAIN = {
     knowledge: "get_knowledge", patterns: "get_pattern", architectures: "get_architecture",
     governance: "get_governance", handbook: "get_handbook",
 };
 function intentBoost(query, surface) {
-    const normal = termsFor(query).join(" ");
+    // Intent words such as "how many" are useful for routing even though they
+    // are deliberately removed from lexical relevance scoring.
+    const normal = norm(query);
     if (surface === "labs" && /\b(calcul\w*|how many|cuant\w*|sample|muestra|roi|cost\w*|coste\w*|supervis\w*|fte|capacity|capacidad|break even|token\w*|pages|paginas)\b/.test(normal))
         return 30;
     if (surface === "claims" && /\b(claim|claims|evidence|fact|thesis|tesis|hypothesis|hipotesis|falsif|refut)\b/.test(normal))
         return 25;
+    if (surface === "homeric_atlas" && /\b(homer\w*|homér\w*|iliad\w*|ilíad\w*|odyssey|odisea|odisseia|ithaca|itaca|ítaca|troy|troya|ulysses|ulises|odysseus|odiseo)\b/.test(normal))
+        return 25;
     if (surface === "articles" && /\b(article|articles|essay|essays|articulo|artículo|ensayo|recent|latest|nuevo|reciente)\b/.test(normal))
         return 20;
     return 0;
 }
-export function registerTools(server, content) {
+/**
+ * Wrap the registry once, rather than remembering telemetry in 30 handlers.
+ *
+ * The callback receives the handler's final value and runs only when a hosted
+ * transport injects it. The stdio package passes no telemetry and remains a
+ * local, analytics-free server. Telemetry is best-effort: observing a result
+ * can never turn that result into an error for the caller.
+ */
+function withToolResultTelemetry(server, telemetry) {
+    if (!telemetry?.toolResult)
+        return server;
+    return {
+        registerTool(name, config, handler) {
+            return server.registerTool(name, config, async (rawArgs) => {
+                const args = rawArgs && typeof rawArgs === "object"
+                    ? rawArgs
+                    : {};
+                try {
+                    const result = await handler(rawArgs);
+                    try {
+                        telemetry.toolResult?.({ tool: name, args, result });
+                    }
+                    catch {
+                        // Analytics can never break a tool response.
+                    }
+                    return result;
+                }
+                catch (error) {
+                    try {
+                        telemetry.toolResult?.({ tool: name, args, error });
+                    }
+                    catch {
+                        // Preserve the original tool error.
+                    }
+                    throw error;
+                }
+            });
+        },
+    };
+}
+export function registerTools(server, content, telemetry) {
+    // Reassign the structural adapter so the existing registry remains the
+    // single list every validator derives from. Every registerTool below now
+    // gains the same final-result boundary without 30 hand-written callbacks.
+    server = withToolResultTelemetry(server, telemetry);
     // ── Orientation ────────────────────────────────────────────────────────────
     server.registerTool("get_overview", {
         title: "Corpus Overview — Start Here",
@@ -709,18 +909,18 @@ export function registerTools(server, content) {
     server.registerTool("search_all", {
         title: "Search every SANTISMM knowledge surface",
         annotations: READ_ONLY_REMOTE,
-        description: "Search the core corpus, first-party essays, executable Labs and epistemic claims in one call. Use this first when a natural-language question might require a calculation, a long-form essay or a claim audit rather than only a core knowledge unit. Results name the next tool to call; calculator-shaped questions are routed toward Labs.",
+        description: "Search the core corpus, first-party essays, executable Labs, epistemic claims and the Homeric Atlas in one call. Use this first when a natural-language question might require a calculation, a long-form essay or a claim audit rather than only a core knowledge unit. Results name the next tool to call; calculator-shaped questions are routed toward Labs.",
         inputSchema: z.object({
             query: querySchema.describe("Question or topic, in English, Spanish or Portuguese."),
-            surfaces: z.array(z.enum(["core", "articles", "labs", "claims"])).min(1).optional()
-                .describe("Restrict the search. Omit to search all four surfaces."),
+            surfaces: z.array(z.enum(SEARCH_SURFACES)).min(1).optional()
+                .describe("Restrict the search. Omit to search all five surfaces."),
             limit_per_surface: z.number().int().positive().max(10).optional().describe("Maximum hits from each surface. Default: 5."),
             locale: localeSchema,
         }),
         outputSchema: z.object(globalSearchOutput),
     }, async ({ query, surfaces, limit_per_surface, locale }) => {
         try {
-            const selected = new Set(surfaces ?? ["core", "articles", "labs", "claims"]);
+            const selected = new Set(surfaces ?? SEARCH_SURFACES);
             const limit = limit_per_surface ?? 5;
             const lang = (locale ?? "en");
             const [articleLoad, labLoad] = await Promise.allSettled([
@@ -804,6 +1004,19 @@ export function registerTools(server, content) {
                     });
                 }
             }
+            if (selected.has("homeric_atlas")) {
+                const boost = intentBoost(query, "homeric_atlas");
+                for (const [index, raw] of homericSearch(content, query, lang, limit).entries()) {
+                    hits.push({
+                        surface: "homeric_atlas", score: raw.score + boost, source_score: raw.score,
+                        rank_within_surface: index + 1, slug: raw.slug, kind: raw.kind,
+                        title: String(raw.name ?? raw.slug), summary: raw.summary,
+                        canonical_url: raw.canonical_url, api_url: raw.api_url,
+                        suggested_tool: HOMERIC_TOOL[raw.kind],
+                        matchedFields: raw.matchedFields, matchedTerms: raw.matchedTerms,
+                    });
+                }
+            }
             hits.sort((a, b) => Number(b.score) - Number(a.score) || Number(a.rank_within_surface) - Number(b.rank_within_surface));
             return out({ query, count: hits.length, results: hits, unavailable_surfaces: unavailableSurfaces }, hits);
         }
@@ -986,6 +1199,44 @@ export function registerTools(server, content) {
             return articleFailure(error);
         }
     });
+    /**
+     * Las 21 unidades que el sitio llama lab, en un solo listado.
+     *
+     * Eran dos catálogos con el mismo nombre: `labs.santismm.com/api/labs` sirve
+     * las diez que ejecuta —con fórmulas, entradas, salidas y endpoint de cálculo—
+     * y el ápice publica esas diez más once páginas propias: el Atlas Homérico, el
+     * sandbox de control, la taxonomía, los benchmarks y los tres atlas
+     * deportivos. `ai-index.json` anunciaba `count: 21` y `list_labs` devolvía 10,
+     * así que un agente que leyera el índice y llamara a la herramienta no podía
+     * alcanzar once de ellas por ninguna vía.
+     *
+     * La definición ejecutable gana cuando existe: trae todo lo que trae la
+     * entrada del catálogo y además las fórmulas. `owner_server` dice quién sirve
+     * cada unidad, que es lo que distingue «esto se calcula» de «esto se lee».
+     *
+     * Deliberadamente sin `resource_uri`: los Resources de MCP no existen todavía
+     * (REG-19), y anunciar un identificador que no resuelve es el fallo que SEG-06
+     * documentó — cuesta más que una función que falta.
+     */
+    const LABS_HOST = new URL(LABS_API_URL).host;
+    async function mergedLabs(content, kind) {
+        const ejecutables = await loadLabs();
+        const porSlug = new Map();
+        for (const entrada of content.listSiteLabs())
+            porSlug.set(String(entrada.slug), { ...entrada, executable: false });
+        for (const lab of ejecutables) {
+            // Sin heredar la entrada del catálogo: `category`/`status`/`summary`
+            // dirían con otras palabras lo que `kind`/`description` ya dicen, y dos
+            // vocabularios para un concepto es justo lo que SEG-07 limpió.
+            porSlug.set(lab.slug, {
+                ...lab,
+                owner_server: LABS_HOST,
+                executable: true,
+            });
+        }
+        const todos = [...porSlug.values()];
+        return kind ? todos.filter((lab) => lab.kind === kind) : todos;
+    }
     // ── SANTISMM Labs (federated metadata + deterministic execution) ─────────
     server.registerTool("list_labs", {
         title: "List calculators, converters, experiments and educational Labs",
@@ -997,8 +1248,7 @@ export function registerTools(server, content) {
         outputSchema: z.object(labListOutput),
     }, async ({ kind }) => {
         try {
-            const labs = await loadLabs();
-            return outList(kind ? labs.filter((lab) => lab.kind === kind) : labs);
+            return outList(await mergedLabs(content, kind));
         }
         catch (error) {
             return labsFailure(error);
@@ -1012,9 +1262,11 @@ export function registerTools(server, content) {
         outputSchema: labCardSchema,
     }, async ({ slug }) => {
         try {
-            const labs = await loadLabs();
+            const labs = await mergedLabs(content);
             const lab = labs.find((candidate) => candidate.slug === slug);
-            return lab ? out(lab) : labNotFound(labs, slug);
+            return lab
+                ? out(lab)
+                : labNotFound(labs, slug);
         }
         catch (error) {
             return labsFailure(error);
@@ -1038,11 +1290,12 @@ export function registerTools(server, content) {
             reviewRate: z.number().min(0).max(100).describe("Share of cases reviewed by a person."),
             reviewMinutes: z.number().min(0).max(10_080).describe("Human review minutes per reviewed case."),
             reworkMinutes: z.number().min(0).max(10_080).describe("Human rework minutes per failed case."),
+            locale: localeSchema.describe("Language for interpretations, assumptions, formulas and warnings (default en)."),
         }),
         outputSchema: agentEconomicsOutput,
-    }, async (inputs) => {
+    }, async ({ locale, ...inputs }) => {
         try {
-            return out(await executeLabCalculator("agent-economics", inputs));
+            return out(await executeLabCalculator("agent-economics", inputs, (locale ?? "en")));
         }
         catch (error) {
             return labsFailure(error);
@@ -1057,11 +1310,12 @@ export function registerTools(server, content) {
             confidence: z.union([z.literal(90), z.literal(95), z.literal(99)]).describe("Confidence level, in percent."),
             margin: z.number().min(0.1).max(50).describe("Margin for estimating the failure rate, in percentage points."),
             population: z.number().min(1).max(1_000_000_000).describe("Number of distinct evaluable cases."),
+            locale: localeSchema.describe("Language for interpretations, assumptions, formulas and warnings (default en)."),
         }),
         outputSchema: evaluationSampleOutput,
-    }, async (inputs) => {
+    }, async ({ locale, ...inputs }) => {
         try {
-            return out(await executeLabCalculator("evaluation-sample-size", inputs));
+            return out(await executeLabCalculator("evaluation-sample-size", inputs, (locale ?? "en")));
         }
         catch (error) {
             return labsFailure(error);
@@ -1082,11 +1336,12 @@ export function registerTools(server, content) {
             utilization: z.number().min(1).max(100).describe("Share of paid time available for review and escalation, in percent."),
             reviewers: z.number().min(0.1).max(1_000_000).describe("Available reviewer FTE."),
             hourlyCost: z.number().min(0).max(1_000_000).describe("Fully loaded reviewer hourly cost, in the chosen currency."),
+            locale: localeSchema.describe("Language for interpretations, assumptions, formulas and warnings (default en)."),
         }),
         outputSchema: humanSupervisionOutput,
-    }, async (inputs) => {
+    }, async ({ locale, ...inputs }) => {
         try {
-            return out(await executeLabCalculator("human-supervision-capacity", inputs));
+            return out(await executeLabCalculator("human-supervision-capacity", inputs, (locale ?? "en")));
         }
         catch (error) {
             return labsFailure(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "santismm-knowledge-mcp",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "license": "MIT",
   "description": "MCP server for the Santismm Knowledge Platform — core knowledge, first-party essays, Homeric Atlas datasets and epistemic claims. Ships the core corpus; the hosted endpoint at https://santismm.com/mcp is the always-fresh alternative.",
   "type": "module",