santismm-knowledge-mcp 0.3.0 → 0.4.1

package/README.md

@@ -2,8 +2,8 @@
 
 [![santismm-knowledge-mcp MCP server](https://glama.ai/mcp/servers/santismm/santismm-knowledge-mcp/badges/card.svg)](https://glama.ai/mcp/servers/santismm/santismm-knowledge-mcp)
 
-> MCP server for the Santismm Knowledge Platform — harness engineering, agentic
-> AI patterns, reference architectures, AI governance and the agent taxonomy.
+> MCP server for the Santismm Knowledge Platform — five core knowledge domains,
+> first-party essays, Homeric Atlas datasets and epistemic claims.
 
 **This repository is generated** from the platform at [santismm.com](https://santismm.com).
 Do not edit it by hand; changes are overwritten on the next sync. Corrections go
@@ -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
@@ -68,7 +82,7 @@ is not a software licence and MIT is not a content licence.
 
 ## What it exposes
 
-24 read-only tools over knowledge, patterns, architectures, governance, the
+30 read-only tools over knowledge, patterns, architectures, governance, the
 Harness Engineering Handbook and first-party Articles, each declaring an
 `outputSchema` and returning validated `structuredContent`. Every tool is
 annotated `readOnlyHint: true`, `destructiveHint: false` and

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.3.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

@@ -0,0 +1,138 @@
+import { norm, queryTerms } from "./shape.js";
+/**
+ * Federated SANTISMM Labs catalogue and deterministic calculators.
+ *
+ * Labs owns the formulas and executes them. The knowledge MCP deliberately
+ * proxies the canonical API instead of copying arithmetic into this package:
+ * one formula version serves the interactive UI, REST callers and MCP agents.
+ */
+export const LABS_API_URL = process.env.SANTISMM_LABS_API_URL ?? 'https://labs.santismm.com/api/labs';
+const LABS_SERVICE_ORIGIN = new URL(LABS_API_URL).origin;
+const LABS_CANONICAL_ORIGIN = 'https://labs.santismm.com';
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let cache;
+let pending;
+function strings(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function validLab(value) {
+    const lab = value;
+    return Boolean(lab &&
+        typeof lab.slug === 'string' &&
+        ['calculator', 'converter', 'experiment', 'educational-game'].includes(String(lab.kind)) &&
+        typeof lab.label === 'string' &&
+        typeof lab.title === 'string' &&
+        typeof lab.description === 'string' &&
+        strings(lab.inputs) &&
+        strings(lab.outputs) &&
+        (lab.formulas === undefined || strings(lab.formulas)) &&
+        strings(lab.assumptions) &&
+        typeof lab.version === 'string' &&
+        typeof lab.updated === 'string' &&
+        typeof lab.canonical_url === 'string' &&
+        lab.canonical_url.startsWith(`${LABS_CANONICAL_ORIGIN}/`) &&
+        typeof lab.api_url === 'string' &&
+        lab.api_url.startsWith(`${LABS_CANONICAL_ORIGIN}/api/labs/`) &&
+        (lab.calculation_url === undefined || lab.calculation_url.startsWith(`${LABS_CANONICAL_ORIGIN}/api/calculate/`)));
+}
+async function fetchCorpus() {
+    const response = await fetch(LABS_API_URL, {
+        headers: { Accept: 'application/json', 'User-Agent': 'santismm-knowledge-mcp/0.4.1' },
+        signal: AbortSignal.timeout(8_000),
+        cache: 'no-store',
+    });
+    if (!response.ok)
+        throw new Error(`Labs API returned HTTP ${response.status}`);
+    const raw = await response.json();
+    if (raw.source !== 'SANTISMM Labs' ||
+        typeof raw.canonical_url !== 'string' ||
+        !Array.isArray(raw.results) ||
+        !raw.results.every(validLab) ||
+        raw.count !== raw.results.length) {
+        throw new Error('Labs API returned an invalid catalogue contract');
+    }
+    return raw;
+}
+export async function loadLabs() {
+    if (cache && cache.expiresAt > Date.now())
+        return cache.corpus.results;
+    if (!pending) {
+        pending = fetchCorpus()
+            .then((corpus) => {
+            cache = { expiresAt: Date.now() + CACHE_TTL_MS, corpus };
+            return corpus;
+        })
+            .finally(() => {
+            pending = undefined;
+        });
+    }
+    return (await pending).results;
+}
+export function searchLabCorpus(labs, query, limit) {
+    const terms = queryTerms(query);
+    const phrase = norm(query).trim();
+    if (terms.length === 0)
+        return [];
+    const fields = [
+        ['title', 8], ['slug', 7], ['description', 6], ['inputs', 4], ['outputs', 4],
+        ['formulas', 3], ['assumptions', 2], ['kind', 1],
+    ];
+    return labs
+        .map((lab) => {
+        const matchedFields = new Set();
+        const matchedTerms = new Set();
+        let score = 0;
+        for (const [field, weight] of fields) {
+            const raw = lab[field];
+            const value = norm(Array.isArray(raw) ? raw.join(' ') : String(raw ?? ''));
+            for (const term of terms) {
+                if (!value.includes(term))
+                    continue;
+                score += weight;
+                matchedFields.add(field);
+                matchedTerms.add(term);
+            }
+            if (phrase.length > 2 && value.includes(phrase))
+                score += weight * 2;
+        }
+        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, 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.1',
+        },
+        body: JSON.stringify(inputs),
+        signal: AbortSignal.timeout(8_000),
+        cache: 'no-store',
+    });
+    const raw = await response.json();
+    if (!response.ok) {
+        const message = typeof raw.error === 'string' ? raw.error : `HTTP ${response.status}`;
+        throw new Error(`Labs calculator ${slug} failed: ${message}`);
+    }
+    if (raw.slug !== slug ||
+        typeof raw.version !== 'string' ||
+        typeof raw.canonical_url !== 'string' ||
+        typeof raw.api_url !== 'string' ||
+        typeof raw.inputs !== 'object' ||
+        typeof raw.results !== 'object' ||
+        !Array.isArray(raw.assumptions) ||
+        !Array.isArray(raw.warnings)) {
+        throw new Error(`Labs calculator ${slug} returned an invalid result contract`);
+    }
+    return raw;
+}

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