@hotmeshio/long-tail 0.1.3 → 0.1.5

package/build/system/activities/triage/discovery.js

@@ -1,170 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTriageInputs = void 0;
 exports.findTriageWorkflows = findTriageWorkflows;
 exports.evaluateTriageMatch = evaluateTriageMatch;
-exports.extractTriageInputs = extractTriageInputs;
-const llm_1 = require("../../../services/llm");
-const defaults_1 = require("../../../modules/defaults");
-const prompts_1 = require("../../workflows/mcp-query/prompts");
-const logger_1 = require("../../../services/logger");
-const yamlDb = __importStar(require("../../../services/yaml-workflow/db"));
+const discovery_1 = require("../../workflows/shared/discovery");
+Object.defineProperty(exports, "extractTriageInputs", { enumerable: true, get: function () { return discovery_1.extractWorkflowInputs; } });
 const cache_1 = require("./cache");
-/**
- * Search for active compiled YAML workflows matching a text query.
- * Uses PostgreSQL FTS + tag overlap for ranked matching.
- */
 async function findTriageWorkflows(prompt) {
-    logger_1.loggerRegistry.debug(`[mcpTriage:findTriageWorkflows] searching: ${prompt.slice(0, 60)}`);
-    const keywords = prompt
-        .toLowerCase()
-        .replace(/[^a-z0-9\s-]/g, ' ')
-        .split(/\s+/)
-        .filter((w) => w.length > 2 && !defaults_1.STOP_WORDS.has(w));
-    logger_1.loggerRegistry.debug(`[mcpTriage:findTriageWorkflows] keywords: [${keywords.join(',')}]`);
-    let workflows;
-    try {
-        workflows = await yamlDb.discoverWorkflows(prompt, keywords, undefined, 5);
-        logger_1.loggerRegistry.info(`[mcpTriage:findTriageWorkflows] ${workflows.length} candidate(s) found`);
-    }
-    catch (err) {
-        logger_1.loggerRegistry.warn(`[mcpTriage:findTriageWorkflows] discovery failed: ${err.message}`);
-        return { inventory: '', toolIds: [], candidates: [] };
-    }
-    if (workflows.length === 0) {
-        logger_1.loggerRegistry.debug(`[mcpTriage:findTriageWorkflows] no candidates found`);
-        return { inventory: '', toolIds: [], candidates: [] };
-    }
-    const toolIds = [];
-    const inventoryLines = [];
-    const candidates = [];
-    for (const wf of workflows) {
-        const qualifiedName = `yaml__${wf.name.replace(/[^a-zA-Z0-9]/g, '_')}`;
-        cache_1.yamlWorkflowMap.set(qualifiedName, wf.name);
-        cache_1.toolDefCache.set(qualifiedName, {
-            type: 'function',
-            function: {
-                name: qualifiedName,
-                description: `[COMPILED WORKFLOW] ${wf.description || wf.name} — deterministic, no LLM needed. ` +
-                    `Tags: ${wf.tags.join(', ')}`,
-                parameters: (wf.input_schema || { type: 'object', properties: {} }),
-            },
-        });
-        toolIds.push(qualifiedName);
-        const activityCount = wf.activity_manifest.filter((a) => a.type === 'worker').length;
-        inventoryLines.push(`★ ${wf.name} [compiled, ${activityCount} steps, tags: ${wf.tags.join(', ')}]: ${wf.description || 'deterministic workflow'}`);
-        candidates.push({
-            name: wf.name,
-            description: wf.description,
-            original_prompt: wf.original_prompt,
-            category: wf.category,
-            tags: wf.tags,
-            input_schema: wf.input_schema,
-            tool_names: wf.activity_manifest
-                .filter((a) => a.type === 'worker' && a.mcp_tool_name)
-                .map((a) => a.mcp_tool_name),
-            fts_rank: wf.fts_rank || 0,
-        });
-    }
-    return { inventory: inventoryLines.join('\n'), toolIds, candidates };
+    return (0, discovery_1.findCompiledWorkflows)(prompt, { yamlWorkflowMap: cache_1.yamlWorkflowMap, toolDefCache: cache_1.toolDefCache }, 'mcpTriage');
 }
-// ── Compiled workflow matching (reused by mcpTriageRouter) ────
-/**
- * LLM-as-judge: does a compiled workflow match the triage context?
- */
 async function evaluateTriageMatch(prompt, candidates) {
-    logger_1.loggerRegistry.debug(`[mcpTriage:evaluateTriageMatch] ${candidates.length} candidate(s)`);
-    if (candidates.length === 0) {
-        return { matched: false, workflowName: null, confidence: 0 };
-    }
-    const candidateText = candidates.map((c, i) => `${i + 1}. **${c.name}** (category: ${c.category || 'general'})\n` +
-        `   Description: ${c.description || 'N/A'}\n` +
-        `   Original prompt: "${c.original_prompt || 'N/A'}"\n` +
-        `   Tools: ${c.tool_names.join(', ')}\n` +
-        `   Input: ${JSON.stringify(c.input_schema).slice(0, 300)}`).join('\n\n');
-    try {
-        const response = await (0, llm_1.callLLM)({
-            model: defaults_1.LLM_MODEL_SECONDARY,
-            max_tokens: 200,
-            temperature: 0,
-            messages: [
-                { role: 'system', content: prompts_1.WORKFLOW_MATCH_PROMPT },
-                { role: 'user', content: `## User Request\n${prompt}\n\n## Candidate Workflows\n${candidateText}` },
-            ],
-        });
-        const raw = response.content || '{}';
-        const cleaned = raw.replace(/^```(?:json)?\s*/m, '').replace(/\s*```$/m, '').trim();
-        const result = JSON.parse(cleaned);
-        if (result.match && result.confidence >= 0.7) {
-            return { matched: true, workflowName: result.workflow_name, confidence: result.confidence };
-        }
-        return { matched: false, workflowName: null, confidence: result.confidence || 0 };
-    }
-    catch {
-        return { matched: false, workflowName: null, confidence: 0 };
-    }
-}
-/**
- * Extract structured inputs from the triage context using a workflow's input schema.
- */
-async function extractTriageInputs(prompt, inputSchema, workflowName) {
-    try {
-        const response = await (0, llm_1.callLLM)({
-            model: defaults_1.LLM_MODEL_SECONDARY,
-            max_tokens: 500,
-            temperature: 0,
-            messages: [
-                { role: 'system', content: prompts_1.EXTRACT_INPUTS_PROMPT },
-                {
-                    role: 'user',
-                    content: `## User Request\n${prompt}\n\n` +
-                        `## Workflow: ${workflowName}\n` +
-                        `## Input Schema\n${JSON.stringify(inputSchema, null, 2)}`,
-                },
-            ],
-        });
-        const raw = response.content || '{}';
-        const cleaned = raw.replace(/^```(?:json)?\s*/m, '').replace(/\s*```$/m, '').trim();
-        const result = JSON.parse(cleaned);
-        if (result._extraction_failed) {
-            return { inputs: null, extracted: false };
-        }
-        delete result._extraction_failed;
-        return { inputs: result, extracted: true };
-    }
-    catch {
-        return { inputs: null, extracted: false };
-    }
+    return (0, discovery_1.evaluateWorkflowMatch)(prompt, candidates, 'mcpTriage');
 }

package/build/system/activities/triage/llm.d.ts

@@ -1,9 +1,2 @@
-import { type LLMResponse } from '../../../services/llm';
-/**
- * Call the LLM with messages and optional tool IDs.
- *
- * Uses the primary model for better tool-calling reliability.
- * Tool IDs are resolved from the module-level toolDefCache so that only
- * lightweight string arrays flow through the durable pipe.
- */
+import type { LLMResponse } from '../../../services/llm';
 export declare function callTriageLLM(messages: any[], toolIds?: string[]): Promise<LLMResponse>;

package/build/system/activities/triage/llm.js

@@ -1,34 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callTriageLLM = callTriageLLM;
-const llm_1 = require("../../../services/llm");
-const defaults_1 = require("../../../modules/defaults");
-const logger_1 = require("../../../services/logger");
+const llm_caller_1 = require("../../workflows/shared/llm-caller");
 const cache_1 = require("./cache");
-/**
- * Call the LLM with messages and optional tool IDs.
- *
- * Uses the primary model for better tool-calling reliability.
- * Tool IDs are resolved from the module-level toolDefCache so that only
- * lightweight string arrays flow through the durable pipe.
- */
 async function callTriageLLM(messages, toolIds) {
-    let tools;
-    if (toolIds?.length) {
-        tools = toolIds
-            .map((id) => cache_1.toolDefCache.get(id))
-            .filter((t) => !!t);
-    }
-    const t0 = Date.now();
-    logger_1.loggerRegistry.debug(`[mcpTriage:callLLM] ${tools?.length || 0} tools, ${messages.length} messages`);
-    const response = await (0, llm_1.callLLM)({
-        model: defaults_1.LLM_MODEL_PRIMARY,
-        messages,
-        temperature: 0,
-        ...(tools?.length ? { tools } : {}),
-        ...(!tools?.length ? { max_tokens: defaults_1.LLM_MAX_TOKENS_DEFAULT } : {}),
-    });
-    const usage = response.usage;
-    logger_1.loggerRegistry.info(`[mcpTriage:callLLM] ${Date.now() - t0}ms | in=${usage?.prompt_tokens} out=${usage?.completion_tokens} total=${usage?.total_tokens} | tool_calls=${response.tool_calls?.length || 0}`);
-    return response;
+    return (0, llm_caller_1.callWorkflowLLM)(messages, toolIds, cache_1.toolDefCache, 'mcpTriage');
 }

package/build/system/activities/triage/tools.d.ts

@@ -1,24 +1,8 @@
-/** Base tags always included — triage always needs DB for investigation + compiled workflows */
+/** Base tags always included — triage always needs DB + compiled workflows */
 export declare const BASE_TAGS: string[];
-/**
- * Single activity that discovers, caches, and returns a lightweight summary.
- *
- * Full ChatCompletionTool definitions are cached in module-level toolDefCache
- * so they never flow through the durable pipe. Only tool IDs (qualified name
- * strings) and a compact inventory string are returned.
- *
- * Includes strategy advisor section for overlapping server categories.
- *
- * @param tags - MCP server tags to scope by (merged with BASE_TAGS).
- *               Pass undefined/empty to load all servers.
- */
 export declare function loadTriageTools(tags?: string[]): Promise<{
     toolIds: string[];
     inventory: string;
     strategy: string;
 }>;
-/**
- * Call any tool by its qualified name — handles both YAML workflows
- * (yaml__* prefix) and raw MCP tools (server_slug__tool_name).
- */
 export declare function callTriageTool(qualifiedName: string, args: Record<string, any>): Promise<any>;

package/build/system/activities/triage/tools.js

@@ -1,178 +1,19 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BASE_TAGS = void 0;
 exports.loadTriageTools = loadTriageTools;
 exports.callTriageTool = callTriageTool;
-const context_1 = require("../../../services/iam/context");
-const ephemeral_1 = require("../../../services/iam/ephemeral");
-const logger_1 = require("../../../services/logger");
-const mcpClient = __importStar(require("../../../services/mcp/client"));
-const mcpDbService = __importStar(require("../../../services/mcp/db"));
-const yamlDb = __importStar(require("../../../services/yaml-workflow/db"));
-const yamlDeployer = __importStar(require("../../../services/yaml-workflow/deployer"));
-const strategy_advisors_1 = require("../../workflows/mcp-query/strategy-advisors");
+const tool_executor_1 = require("../../workflows/shared/tool-executor");
+const tool_loader_1 = require("../../workflows/shared/tool-loader");
 const cache_1 = require("./cache");
-/** Base tags always included — triage always needs DB for investigation + compiled workflows */
+/** Base tags always included — triage always needs DB + compiled workflows */
 exports.BASE_TAGS = ['workflows', 'compiled', 'database'];
-// ── LLM + MCP tool activities ────────────────────────────────
-/**
- * Single activity that discovers, caches, and returns a lightweight summary.
- *
- * Full ChatCompletionTool definitions are cached in module-level toolDefCache
- * so they never flow through the durable pipe. Only tool IDs (qualified name
- * strings) and a compact inventory string are returned.
- *
- * Includes strategy advisor section for overlapping server categories.
- *
- * @param tags - MCP server tags to scope by (merged with BASE_TAGS).
- *               Pass undefined/empty to load all servers.
- */
 async function loadTriageTools(tags) {
-    logger_1.loggerRegistry.debug(`[mcpTriage:loadTriageTools] tags: ${tags?.join(',') || 'all'}`);
-    let servers;
-    if (tags?.length) {
-        const combinedTags = [...new Set([...exports.BASE_TAGS, ...tags])];
-        servers = await mcpDbService.findServersByTags(combinedTags, 'any');
-    }
-    else {
-        const result = await mcpDbService.listMcpServers({ limit: 100 });
-        servers = result.servers;
-    }
-    const toolIds = [];
-    const inventoryLines = [];
-    const serverInfos = [];
-    for (const server of servers) {
-        const manifest = server.tool_manifest || [];
-        const slug = server.name.replace(/[^a-zA-Z0-9]/g, '_');
-        const serverTags = server.tags?.length ? server.tags.join(', ') : 'general';
-        const toolNames = [];
-        for (const t of manifest) {
-            const qualifiedName = `${slug}__${t.name}`;
-            cache_1.toolServerMap.set(qualifiedName, server.name);
-            cache_1.toolDefCache.set(qualifiedName, {
-                type: 'function',
-                function: {
-                    name: qualifiedName,
-                    description: `[${server.name}] ${t.description || ''}`,
-                    parameters: (t.inputSchema || { type: 'object', properties: {} }),
-                },
-            });
-            toolIds.push(qualifiedName);
-            toolNames.push(t.name);
-        }
-        inventoryLines.push(`• ${server.name} [${serverTags}] (${manifest.length} tools): ${toolNames.join(', ')}`);
-        serverInfos.push({
-            name: server.name,
-            description: server.description || null,
-            tags: server.tags || [],
-            metadata: server.metadata || null,
-            toolNames,
-            toolCount: manifest.length,
-            slug,
-        });
-    }
-    const strategy = (0, strategy_advisors_1.generateStrategySection)(serverInfos);
-    logger_1.loggerRegistry.info(`[mcpTriage:loadTriageTools] ${servers.length} servers, ${toolIds.length} tools loaded`);
-    return { toolIds, inventory: inventoryLines.join('\n'), strategy };
+    return (0, tool_loader_1.loadToolsFromServers)(tags, { toolServerMap: cache_1.toolServerMap, toolDefCache: cache_1.toolDefCache }, {
+        baseTags: exports.BASE_TAGS,
+        logPrefix: 'mcpTriage',
+    });
 }
-/**
- * Call any tool by its qualified name — handles both YAML workflows
- * (yaml__* prefix) and raw MCP tools (server_slug__tool_name).
- */
 async function callTriageTool(qualifiedName, args) {
-    // Check if this is a compiled YAML workflow
-    const yamlWorkflowName = cache_1.yamlWorkflowMap.get(qualifiedName);
-    if (yamlWorkflowName) {
-        try {
-            const wf = await yamlDb.getYamlWorkflowByName(yamlWorkflowName);
-            if (!wf || wf.status !== 'active') {
-                return { error: `Compiled workflow "${yamlWorkflowName}" is not active` };
-            }
-            // Inject _scope from the current ToolContext so YAML workers get IAM
-            const toolCtx = (0, context_1.getToolContext)();
-            const scopedArgs = toolCtx?.principal.id
-                ? {
-                    ...args,
-                    _scope: {
-                        principal: toolCtx.principal,
-                        ...(toolCtx.initiatingPrincipal ? { initiatingPrincipal: toolCtx.initiatingPrincipal } : {}),
-                        scopes: toolCtx.credentials.scopes,
-                    },
-                }
-                : args;
-            const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, scopedArgs, undefined, wf.graph_topic);
-            return { job_id, workflow: yamlWorkflowName, status: 'completed', result };
-        }
-        catch (err) {
-            return { error: err.message, tool: qualifiedName, args };
-        }
-    }
-    // Exchange ephemeral credential tokens (eph:v1:...) right before the MCP call
-    args = await (0, ephemeral_1.exchangeTokensInArgs)(args);
-    // Standard MCP tool routing
-    const serverName = cache_1.toolServerMap.get(qualifiedName);
-    const separatorIdx = qualifiedName.indexOf('__');
-    const toolName = separatorIdx >= 0
-        ? qualifiedName.slice(separatorIdx + 2)
-        : qualifiedName;
-    // Build auth context from ToolContext (set by interceptor via IAM service)
-    const toolCtx = (0, context_1.getToolContext)();
-    const authContext = toolCtx?.principal.id
-        ? { userId: toolCtx.principal.id, delegationToken: toolCtx.credentials.delegationToken }
-        : undefined;
-    if (serverName) {
-        try {
-            return await mcpClient.callServerTool(serverName, toolName, args, authContext);
-        }
-        catch (err) {
-            return { error: err.message, tool: qualifiedName, args };
-        }
-    }
-    // Fallback: try the tool name directly against all connected servers
-    const { servers } = await mcpDbService.listMcpServers({ limit: 100 });
-    for (const server of servers) {
-        const manifest = server.tool_manifest || [];
-        if (manifest.some((t) => t.name === toolName)) {
-            try {
-                return await mcpClient.callServerTool(server.name, toolName, args, authContext);
-            }
-            catch (err) {
-                return { error: err.message, tool: qualifiedName, args };
-            }
-        }
-    }
-    return { error: `Unknown tool: ${qualifiedName} (no server found)`, tool: qualifiedName };
+    return (0, tool_executor_1.callTool)(qualifiedName, args, { toolServerMap: cache_1.toolServerMap, yamlWorkflowMap: cache_1.yamlWorkflowMap });
 }

package/build/system/index.js

@@ -87,14 +87,15 @@ function getSystemWorkers() {
  */
 exports.builtinMcpServerFactories = {
     'long-tail-human-queue': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/human-queue'))).then((m) => m.createHumanQueueServer()),
-    'long-tail-db': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/db-query'))).then((m) => m.createDbServer()),
-    'long-tail-document-vision': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/document-vision'))).then((m) => m.createVisionServer()),
-    'mcp-workflows-longtail': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/workflow'))).then((m) => m.createWorkflowServer()),
-    'long-tail-workflow-compiler': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/workflow-compiler'))).then((m) => m.createWorkflowCompilerServer()),
+    'long-tail-translation': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/translation'))).then((m) => m.createTranslationServer()),
+    'long-tail-vision': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/vision'))).then((m) => m.createVisionServer()),
     'long-tail-playwright': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/playwright'))).then((m) => m.createPlaywrightServer()),
     'long-tail-playwright-cli': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/playwright-cli'))).then((m) => m.createPlaywrightCliServer()),
     'long-tail-file-storage': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/file-storage'))).then((m) => m.createFileStorageServer()),
     'long-tail-http-fetch': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/http-fetch'))).then((m) => m.createHttpFetchServer()),
     'long-tail-oauth': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/oauth'))).then((m) => m.createOAuthServer()),
+    'long-tail-docs': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/docs'))).then((m) => m.createDocsServer()),
     'long-tail-claude-code': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/claude-code'))).then((m) => m.createClaudeCodeServer()),
+    'long-tail-admin': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/admin'))).then((m) => m.createAdminServer()),
+    'long-tail-knowledge': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/knowledge'))).then((m) => m.createKnowledgeServer()),
 };

package/build/system/mcp-servers/admin/escalations.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Escalation tools — mirrors routes/escalations/
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerEscalationTools(server: McpServer): void;

package/build/system/mcp-servers/admin/escalations.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEscalationTools = registerEscalationTools;
+const escalationService = __importStar(require("../../../services/escalation"));
+const schemas_1 = require("./schemas");
+function registerEscalationTools(server) {
+    // mirrors GET /api/escalations
+    server.registerTool('find_escalations', {
+        title: 'Find Escalations',
+        description: 'Search escalations with optional filters. Returns records with ' +
+            'type, role, priority, status, description, and assignment info.',
+        inputSchema: schemas_1.findEscalationsSchema,
+    }, async (args) => {
+        const { escalations, total } = await escalationService.listEscalations({
+            status: args.status,
+            role: args.role,
+            type: args.type,
+            priority: args.priority,
+            limit: args.limit,
+            offset: args.offset,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: escalations.length,
+                        escalations: escalations.map((e) => ({
+                            id: e.id,
+                            type: e.type,
+                            subtype: e.subtype,
+                            role: e.role,
+                            priority: e.priority,
+                            status: e.status,
+                            description: e.description,
+                            workflow_type: e.workflow_type,
+                            assigned_to: e.assigned_to,
+                            created_at: e.created_at,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // mirrors GET /api/escalations/stats
+    server.registerTool('get_escalation_stats', {
+        title: 'Get Escalation Stats',
+        description: 'Aggregated escalation statistics: pending, claimed, created, ' +
+            'resolved counts with breakdown by role and type.',
+        inputSchema: schemas_1.getEscalationStatsSchema,
+    }, async (args) => {
+        const stats = await escalationService.getEscalationStats(undefined, args.period);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(stats),
+                }],
+        };
+    });
+    // mirrors POST /api/escalations/:id/claim
+    server.registerTool('claim_escalation', {
+        title: 'Claim Escalation',
+        description: 'Claim an escalation for a time-boxed lock. The escalation is ' +
+            'reserved so no one else picks it up. If the claim expires, ' +
+            'the escalation returns to the queue.',
+        inputSchema: schemas_1.claimEscalationSchema,
+    }, async (args) => {
+        const escalation = await escalationService.getEscalation(args.id);
+        if (!escalation) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Escalation not found' }) }],
+                isError: true,
+            };
+        }
+        const result = await escalationService.claimEscalation(args.id, 'lt-system', args.duration_minutes);
+        if (!result) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Escalation not available for claim' }) }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+        };
+    });
+    // mirrors POST /api/escalations/release-expired
+    server.registerTool('release_expired_claims', {
+        title: 'Release Expired Claims',
+        description: 'Release all escalation claims that exceeded their lock duration. ' +
+            'Expired escalations return to the available queue.',
+        inputSchema: schemas_1.releaseExpiredClaimsSchema,
+    }, async (_args) => {
+        const released = await escalationService.releaseExpiredClaims();
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ released }) }],
+        };
+    });
+    // mirrors POST /api/escalations/bulk-triage
+    server.registerTool('bulk_triage', {
+        title: 'Bulk Triage',
+        description: 'Resolve escalations for triage and start mcpTriage workflows. ' +
+            'Each escalation is marked resolved with needsTriage=true, then ' +
+            'a triage workflow is started to remediate the issue.',
+        inputSchema: schemas_1.bulkTriageSchema,
+    }, async (args) => {
+        const resolved = await escalationService.bulkResolveForTriage(args.ids, args.hint);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        triaged: resolved.length,
+                        escalation_ids: resolved.map((e) => e.id),
+                    }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/admin/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Long Tail Admin MCP Server
+ *
+ * Unified system management — every tool maps directly to a REST API
+ * route handler. The tools are organized by route file:
+ *
+ *   tasks.ts           — routes/tasks.ts
+ *   escalations.ts     — routes/escalations/
+ *   workflow-config.ts  — routes/workflows/config.ts
+ *   workflows.ts       — routes/workflows/discovery.ts + invocation.ts
+ *   mcp-servers.ts     — routes/mcp.ts
+ *   yaml-workflows.ts  — routes/yaml-workflows/
+ *   users.ts           — routes/users.ts + routes/roles.ts
+ *   maintenance.ts     — routes/dba.ts
+ *
+ * This server replaces three previously separate servers:
+ *   - long-tail-db-query (read-only task/escalation/health queries)
+ *   - long-tail-workflow-compiler (compile + deploy)
+ *   - mcp-workflows-longtail (list + get + invoke compiled workflows)
+ *
+ * The long-tail-human-queue server remains separate because
+ * escalate_and_wait has special durable signal semantics that
+ * are deeply wired into the YAML worker infrastructure.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createAdminServer(options?: {
+    name?: string;
+    fresh?: boolean;
+}): Promise<McpServer>;
+export declare function getAdminServer(): McpServer | null;
+export declare function stopAdminServer(): Promise<void>;