@hotmeshio/long-tail 0.1.0

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

@@ -0,0 +1,178 @@
+"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 cache_1 = require("./cache");
+/** Base tags always included — triage always needs DB for investigation + 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 };
+}
+/**
+ * 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 };
+}

package/build/system/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * System workers and built-in MCP server factories.
+ *
+ * All MCP-powered workflows (triage, query, their routers and deterministic
+ * counterparts) require an LLM API key. They load conditionally.
+ */
+export declare function getSystemWorkers(): Array<{
+    taskQueue: string;
+    workflow: (...args: any[]) => any;
+}>;
+/**
+ * Built-in MCP server factories.
+ * Each entry maps a server name to a lazy factory that creates the McpServer instance.
+ * Registered via `registerBuiltinServer()` in `services/mcp/client.ts`.
+ */
+export declare const builtinMcpServerFactories: Record<string, () => Promise<any>>;

package/build/system/index.js

@@ -0,0 +1,100 @@
+"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.builtinMcpServerFactories = void 0;
+exports.getSystemWorkers = getSystemWorkers;
+/**
+ * System workers and built-in MCP server factories.
+ *
+ * All MCP-powered workflows (triage, query, their routers and deterministic
+ * counterparts) require an LLM API key. They load conditionally.
+ */
+function getSystemWorkers() {
+    const workers = [];
+    const hasLLM = process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY;
+    if (hasLLM) {
+        // ── Triage pipeline (router → deterministic | dynamic) ──
+        try {
+            const { mcpTriageRouter } = require('./workflows/mcp-triage-router');
+            workers.push({ taskQueue: 'long-tail-system', workflow: mcpTriageRouter });
+        }
+        catch { /* not available */ }
+        try {
+            const { mcpTriageDeterministic } = require('./workflows/mcp-triage-deterministic');
+            workers.push({ taskQueue: 'long-tail-system', workflow: mcpTriageDeterministic });
+        }
+        catch { /* not available */ }
+        try {
+            const { mcpTriage } = require('./workflows/mcp-triage');
+            workers.push({ taskQueue: 'long-tail-system', workflow: mcpTriage });
+        }
+        catch { /* not available */ }
+        // ── Query pipeline (router → deterministic | dynamic) ──
+        try {
+            const { mcpQueryRouter } = require('./workflows/mcp-query-router');
+            workers.push({ taskQueue: 'long-tail-system', workflow: mcpQueryRouter });
+        }
+        catch { /* not available */ }
+        try {
+            const { mcpQuery } = require('./workflows/mcp-query');
+            workers.push({ taskQueue: 'long-tail-system', workflow: mcpQuery });
+        }
+        catch { /* not available */ }
+        try {
+            const { mcpDeterministic } = require('./workflows/mcp-deterministic');
+            workers.push({ taskQueue: 'long-tail-system', workflow: mcpDeterministic });
+        }
+        catch { /* not available */ }
+    }
+    return workers;
+}
+/**
+ * Built-in MCP server factories.
+ * Each entry maps a server name to a lazy factory that creates the McpServer instance.
+ * Registered via `registerBuiltinServer()` in `services/mcp/client.ts`.
+ */
+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-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-claude-code': () => Promise.resolve().then(() => __importStar(require('./mcp-servers/claude-code'))).then((m) => m.createClaudeCodeServer()),
+};

package/build/system/mcp-servers/claude-code.d.ts

@@ -0,0 +1,17 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create a Claude Code MCP server.
+ *
+ * Provides 2 tools:
+ *   execute_task       — Run a Claude Code prompt, return structured output
+ *   check_availability — Verify CLI installation and API key presence
+ *
+ * Authentication by proxy:
+ *   When invoked from a workflow, `_auth` is injected automatically by the
+ *   framework. The activity uses `_auth.userId` for audit logging and
+ *   `_auth.token` (delegation JWT) for resolving per-user API keys.
+ *   Built-in tools that don't need auth simply ignore the `_auth` field.
+ */
+export declare function createClaudeCodeServer(options?: {
+    name?: string;
+}): Promise<McpServer>;

package/build/system/mcp-servers/claude-code.js

@@ -0,0 +1,110 @@
+"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.createClaudeCodeServer = createClaudeCodeServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../../services/logger");
+const claudeCode = __importStar(require("../activities/claude-code"));
+// ── Schemas ──────────────────────────────────────────────────────────────────
+const executeTaskSchema = zod_1.z.object({
+    prompt: zod_1.z.string().describe('The task prompt for Claude Code. Be specific and actionable. ' +
+        'Claude Code has access to terminal, file system, and code editing tools.'),
+    working_directory: zod_1.z.string().optional().describe('Working directory for the task. Defaults to the server process cwd.'),
+    allowed_tools: zod_1.z.array(zod_1.z.string()).optional().describe('Restrict which tools Claude Code can use (e.g., ["Read", "Grep", "Glob"]). ' +
+        'Omit for unrestricted access.'),
+    max_turns: zod_1.z.number().optional().describe('Maximum agentic turns (tool calls) before stopping. Default: model default.'),
+    model: zod_1.z.string().optional().describe('Override the Claude model (e.g., "claude-sonnet-4-6"). Default: CLI default.'),
+    system_prompt: zod_1.z.string().optional().describe('Additional system prompt to append to Claude Code\'s defaults.'),
+    timeout_ms: zod_1.z.number().optional().describe('Execution timeout in milliseconds. Default: 120000 (2 min), max: 300000 (5 min).'),
+    credential_label: zod_1.z.string().optional().describe('Label of the stored Anthropic credential to use (e.g., "subscription", "api-batch"). ' +
+        'Default: "default". Use when the user has multiple Anthropic credentials.'),
+});
+const checkAvailabilitySchema = zod_1.z.object({});
+// ── Factory ──────────────────────────────────────────────────────────────────
+/**
+ * Create a Claude Code MCP server.
+ *
+ * Provides 2 tools:
+ *   execute_task       — Run a Claude Code prompt, return structured output
+ *   check_availability — Verify CLI installation and API key presence
+ *
+ * Authentication by proxy:
+ *   When invoked from a workflow, `_auth` is injected automatically by the
+ *   framework. The activity uses `_auth.userId` for audit logging and
+ *   `_auth.token` (delegation JWT) for resolving per-user API keys.
+ *   Built-in tools that don't need auth simply ignore the `_auth` field.
+ */
+async function createClaudeCodeServer(options) {
+    const name = options?.name || 'long-tail-claude-code';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    instance.registerTool('execute_task', {
+        title: 'Execute Claude Code Task',
+        description: 'Run a task using Claude Code CLI on the server. Claude Code is an agentic ' +
+            'coding assistant with terminal access, file I/O, code search, and editing. ' +
+            'Use for: code generation, refactoring, file analysis, running shell commands, ' +
+            'searching codebases, and multi-step development tasks. ' +
+            'The task runs in a subprocess with a scoped API key and optional tool restrictions. ' +
+            'When called from a workflow, the requesting user\'s identity is propagated via delegation.',
+        inputSchema: executeTaskSchema,
+    }, async (args) => {
+        try {
+            const result = await claudeCode.executeTask(args);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result) }],
+                isError: result.is_error,
+            };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: err.message }) }],
+                isError: true,
+            };
+        }
+    });
+    instance.registerTool('check_availability', {
+        title: 'Check Claude Code Availability',
+        description: 'Verify that the Claude Code CLI is installed and an Anthropic API key is available. ' +
+            'Returns version info and key availability. Use before execute_task to verify readiness.',
+        inputSchema: checkAvailabilitySchema,
+    }, async (args) => {
+        const result = await claudeCode.checkAvailability(args);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result) }],
+        };
+    });
+    logger_1.loggerRegistry.info(`[lt-mcp:claude-code] ${name} ready (2 tools registered)`);
+    return instance;
+}

package/build/system/mcp-servers/db-query/index.d.ts

@@ -0,0 +1,25 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create the Long Tail DB Query MCP server.
+ *
+ * Provides read-only query tools against the lt_* tables:
+ * - find_tasks — search tasks by status, workflow type, or origin
+ * - find_escalations — search escalations by status, role, type
+ * - get_process_summary — aggregate process view grouped by origin_id
+ * - get_escalation_stats — real-time escalation statistics
+ * - get_workflow_types — list registered workflow configurations
+ * - get_system_health — overall system health snapshot
+ */
+export declare function createDbServer(options?: {
+    name?: string;
+    /** When true, skip the singleton cache and create a dedicated instance. */
+    fresh?: boolean;
+}): Promise<McpServer>;
+/**
+ * Get the current DB MCP server instance.
+ */
+export declare function getDbServer(): McpServer | null;
+/**
+ * Stop the DB MCP server and release resources.
+ */
+export declare function stopDbServer(): Promise<void>;

package/build/system/mcp-servers/db-query/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDbServer = createDbServer;
+exports.getDbServer = getDbServer;
+exports.stopDbServer = stopDbServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const logger_1 = require("../../../services/logger");
+const tools_1 = require("./tools");
+let server = null;
+/**
+ * Create the Long Tail DB Query MCP server.
+ *
+ * Provides read-only query tools against the lt_* tables:
+ * - find_tasks — search tasks by status, workflow type, or origin
+ * - find_escalations — search escalations by status, role, type
+ * - get_process_summary — aggregate process view grouped by origin_id
+ * - get_escalation_stats — real-time escalation statistics
+ * - get_workflow_types — list registered workflow configurations
+ * - get_system_health — overall system health snapshot
+ */
+async function createDbServer(options) {
+    if (server && !options?.fresh)
+        return server;
+    const name = options?.name || 'long-tail-db-query';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    // Only cache as the singleton when not a fresh (dedicated) instance
+    if (!options?.fresh) {
+        server = instance;
+    }
+    (0, tools_1.registerTools)(instance);
+    logger_1.loggerRegistry.info(`[lt-mcp:db-server] ${name} ready (6 tools registered)`);
+    return instance;
+}
+/**
+ * Get the current DB MCP server instance.
+ */
+function getDbServer() {
+    return server;
+}
+/**
+ * Stop the DB MCP server and release resources.
+ */
+async function stopDbServer() {
+    if (server) {
+        await server.close();
+        server = null;
+        logger_1.loggerRegistry.info('[lt-mcp:db-server] stopped');
+    }
+}

package/build/system/mcp-servers/db-query/schemas.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+export declare const findTasksSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["pending", "in_progress", "needs_intervention", "completed", "failed"]>>;
+    workflow_type: z.ZodOptional<z.ZodString>;
+    workflow_id: z.ZodOptional<z.ZodString>;
+    origin_id: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
+    workflow_type?: string | undefined;
+    workflow_id?: string | undefined;
+    origin_id?: string | undefined;
+}, {
+    status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
+    workflow_type?: string | undefined;
+    limit?: number | undefined;
+    workflow_id?: string | undefined;
+    origin_id?: string | undefined;
+}>;
+export declare const findEscalationsSchema: z.ZodObject<{
+    status: z.ZodOptional<z.ZodEnum<["pending", "resolved"]>>;
+    role: z.ZodOptional<z.ZodString>;
+    type: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    role?: string | undefined;
+    status?: "pending" | "resolved" | undefined;
+    type?: string | undefined;
+    priority?: number | undefined;
+}, {
+    role?: string | undefined;
+    status?: "pending" | "resolved" | undefined;
+    type?: string | undefined;
+    priority?: number | undefined;
+    limit?: number | undefined;
+}>;
+export declare const getProcessSummarySchema: z.ZodObject<{
+    workflow_type: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    workflow_type?: string | undefined;
+}, {
+    workflow_type?: string | undefined;
+    limit?: number | undefined;
+}>;
+export declare const getEscalationStatsSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const getWorkflowTypesSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+export declare const getSystemHealthSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;

package/build/system/mcp-servers/db-query/schemas.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSystemHealthSchema = exports.getWorkflowTypesSchema = exports.getEscalationStatsSchema = exports.getProcessSummarySchema = exports.findEscalationsSchema = exports.findTasksSchema = void 0;
+const zod_1 = require("zod");
+const defaults_1 = require("../../../modules/defaults");
+// Schemas extracted to break TS2589 deep-instantiation in registerTool generics
+exports.findTasksSchema = zod_1.z.object({
+    status: zod_1.z.enum(['pending', 'in_progress', 'needs_intervention', 'completed', 'failed'])
+        .optional().describe('Filter by task status'),
+    workflow_type: zod_1.z.string().optional().describe('Filter by workflow type (e.g. "reviewContent")'),
+    workflow_id: zod_1.z.string().optional().describe('Filter by workflow execution ID'),
+    origin_id: zod_1.z.string().optional().describe('Filter by origin/process ID to see all tasks in a process'),
+    limit: zod_1.z.number().int().min(1).max(defaults_1.QUERY_LIMIT_MAX).optional().default(defaults_1.QUERY_LIMIT_DEFAULT)
+        .describe('Maximum number of results'),
+});
+exports.findEscalationsSchema = zod_1.z.object({
+    status: zod_1.z.enum(['pending', 'resolved']).optional()
+        .describe('Filter by escalation status'),
+    role: zod_1.z.string().optional().describe('Filter by assigned role (e.g. "reviewer", "engineer")'),
+    type: zod_1.z.string().optional().describe('Filter by escalation type'),
+    priority: zod_1.z.number().int().min(1).max(4).optional()
+        .describe('Filter by priority (1=critical, 4=low)'),
+    limit: zod_1.z.number().int().min(1).max(defaults_1.QUERY_LIMIT_MAX).optional().default(defaults_1.QUERY_LIMIT_DEFAULT)
+        .describe('Maximum number of results'),
+});
+exports.getProcessSummarySchema = zod_1.z.object({
+    workflow_type: zod_1.z.string().optional()
+        .describe('Filter processes to those containing this workflow type'),
+    limit: zod_1.z.number().int().min(1).max(defaults_1.QUERY_LIMIT_MAX).optional().default(defaults_1.QUERY_LIMIT_DEFAULT)
+        .describe('Maximum number of processes'),
+});
+exports.getEscalationStatsSchema = zod_1.z.object({});
+exports.getWorkflowTypesSchema = zod_1.z.object({});
+exports.getSystemHealthSchema = zod_1.z.object({});

package/build/system/mcp-servers/db-query/tools.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Register all six read-only query tools on the given MCP server instance.
+ */
+export declare function registerTools(instance: McpServer): void;