@hotmeshio/long-tail 0.1.4 → 0.1.6

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

@@ -0,0 +1,138 @@
+"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.registerWorkflowTools = registerWorkflowTools;
+const configService = __importStar(require("../../../services/config"));
+const registry_1 = require("../../../services/workers/registry");
+const workflow_invocation_1 = require("../../../services/workflow-invocation");
+const workers_1 = require("../../../workers");
+const schemas_1 = require("./schemas");
+function registerWorkflowTools(server) {
+    // mirrors GET /api/workflows/discovered
+    server.registerTool('list_discovered_workflows', {
+        title: 'List Discovered Workflows',
+        description: 'Unified list of all known workflows: active workers, historical ' +
+            'entities, and registered configs merged together. Shows which are ' +
+            'certified (registered), active, invocable, and their roles.',
+        inputSchema: schemas_1.listDiscoveredWorkflowsSchema,
+    }, async (args) => {
+        const activeWorkers = (0, registry_1.getRegisteredWorkers)();
+        const configs = await configService.listWorkflowConfigs();
+        const configMap = new Map(configs.map((c) => [c.workflow_type, c]));
+        const allTypes = new Set();
+        for (const [name] of activeWorkers)
+            allTypes.add(name);
+        for (const c of configs)
+            allTypes.add(c.workflow_type);
+        const workflows = [...allTypes]
+            .filter((t) => args.include_system || !registry_1.SYSTEM_WORKFLOWS.has(t))
+            .sort()
+            .map((wt) => {
+            const config = configMap.get(wt);
+            const worker = activeWorkers.get(wt);
+            return {
+                workflow_type: wt,
+                task_queue: config?.task_queue ?? worker?.taskQueue ?? null,
+                registered: !!config,
+                active: !!worker,
+                invocable: config?.invocable ?? false,
+                description: config?.description ?? null,
+                roles: config?.roles ?? [],
+            };
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ count: workflows.length, workflows }),
+                }],
+        };
+    });
+    // mirrors POST /api/workflows/:type/invoke
+    server.registerTool('invoke_workflow', {
+        title: 'Invoke Workflow',
+        description: 'Start a certified workflow by type. The workflow must have invocable=true ' +
+            'in its config. Returns the workflow ID immediately; the workflow runs ' +
+            'durably in the background.',
+        inputSchema: schemas_1.invokeWorkflowSchema,
+    }, async (args) => {
+        const result = await (0, workflow_invocation_1.invokeWorkflow)({
+            workflowType: args.workflow_type,
+            data: args.data,
+            metadata: args.metadata,
+            executeAs: args.execute_as,
+            auth: { userId: 'lt-system', role: 'superadmin' },
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ workflow_id: result.workflowId, message: 'Workflow started' }),
+                }],
+        };
+    });
+    // mirrors GET /api/workflows/:workflowId/status + /result
+    server.registerTool('get_workflow_status', {
+        title: 'Get Workflow Status',
+        description: 'Check the status and result of a workflow execution. Returns ' +
+            'status (0=complete, positive=running) and the result if complete.',
+        inputSchema: schemas_1.getWorkflowStatusSchema,
+    }, async (args) => {
+        const { getTaskByWorkflowId } = await Promise.resolve().then(() => __importStar(require('../../../services/task')));
+        const task = await getTaskByWorkflowId(args.workflow_id);
+        if (!task) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Workflow not found' }) }],
+                isError: true,
+            };
+        }
+        const client = (0, workers_1.createClient)();
+        const handle = await client.workflow.getHandle(task.task_queue || 'long-tail-system', task.workflow_type, args.workflow_id);
+        const status = await handle.status();
+        if (status !== 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ workflow_id: args.workflow_id, status: 'running' }),
+                    }],
+            };
+        }
+        const result = await handle.result();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ workflow_id: args.workflow_id, status: 'complete', result }),
+                }],
+        };
+    });
+}

package/build/system/mcp-servers/admin/yaml-workflows.d.ts

@@ -0,0 +1,8 @@
+/**
+ * YAML workflow (pipeline) tools — mirrors routes/yaml-workflows/
+ *
+ * Replaces both the workflow-compiler server (compile + deploy)
+ * and the mcp-workflows server (list + get + invoke).
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerYamlWorkflowTools(server: McpServer): void;

package/build/system/mcp-servers/admin/yaml-workflows.js

@@ -0,0 +1,237 @@
+"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.registerYamlWorkflowTools = registerYamlWorkflowTools;
+const yamlDb = __importStar(require("../../../services/yaml-workflow/db"));
+const yamlGenerator = __importStar(require("../../../services/yaml-workflow/generator"));
+const yamlDeployer = __importStar(require("../../../services/yaml-workflow/deployer"));
+const yamlWorkers = __importStar(require("../../../services/yaml-workflow/workers"));
+const task_1 = require("../../../services/task");
+const schemas_1 = require("./schemas");
+function registerYamlWorkflowTools(server) {
+    // mirrors GET /api/yaml-workflows
+    server.registerTool('list_yaml_workflows', {
+        title: 'List Pipeline Workflows',
+        description: 'List compiled YAML workflows with optional filters by status, ' +
+            'namespace, or search term. Returns name, status, source, and activity count.',
+        inputSchema: schemas_1.listYamlWorkflowsSchema,
+    }, async (args) => {
+        const { workflows, total } = await yamlDb.listYamlWorkflows({
+            status: args.status,
+            app_id: args.app_id,
+            search: args.search,
+            source_workflow_id: args.source_workflow_id,
+            limit: args.limit,
+            offset: args.offset,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: workflows.length,
+                        workflows: workflows.map((w) => ({
+                            id: w.id,
+                            name: w.name,
+                            app_id: w.app_id,
+                            status: w.status,
+                            source_workflow_type: w.source_workflow_type,
+                            graph_topic: w.graph_topic,
+                            activity_count: w.activity_manifest?.filter((a) => a.type === 'worker').length ?? 0,
+                            tags: w.tags,
+                            created_at: w.created_at,
+                        })),
+                    }),
+                }],
+        };
+    });
+    // mirrors GET /api/yaml-workflows/:id
+    server.registerTool('get_yaml_workflow', {
+        title: 'Get Pipeline Workflow',
+        description: 'Inspect a compiled workflow by ID. Returns the activity manifest, ' +
+            'input/output schemas, YAML content, and provenance.',
+        inputSchema: schemas_1.getYamlWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflow(args.id);
+        if (!wf) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'YAML workflow not found' }) }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify(wf) }],
+        };
+    });
+    // mirrors POST /api/yaml-workflows
+    server.registerTool('create_yaml_workflow', {
+        title: 'Compile Execution to Pipeline',
+        description: 'Generate a deterministic YAML workflow from a completed execution. ' +
+            'Extracts the tool call sequence and replaces LLM reasoning with ' +
+            'direct tool-to-tool data piping. Stored as a draft.',
+        inputSchema: schemas_1.createYamlWorkflowSchema,
+    }, async (args) => {
+        // Reject incomplete executions (same check as route)
+        const task = await (0, task_1.getTaskByWorkflowId)(args.workflow_id);
+        if (task) {
+            const milestones = task.milestones ?? [];
+            if (milestones.some((m) => m.name === 'rounds_exhausted')) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                error: 'Cannot compile: source execution exhausted its tool rounds without completing.',
+                            }),
+                        }],
+                    isError: true,
+                };
+            }
+        }
+        const result = await yamlGenerator.generateYamlFromExecution({
+            workflowId: args.workflow_id,
+            taskQueue: args.task_queue,
+            workflowName: args.workflow_name,
+            name: args.name,
+            description: args.description,
+            compilationFeedback: args.compilation_feedback,
+        });
+        const mergedTags = [...new Set([
+                ...(result.tags || []),
+                ...(args.tags || []),
+            ])];
+        const record = await yamlDb.createYamlWorkflow({
+            name: args.name,
+            description: args.description,
+            app_id: result.appId,
+            yaml_content: result.yaml,
+            graph_topic: result.graphTopic,
+            input_schema: result.inputSchema,
+            output_schema: result.outputSchema,
+            activity_manifest: result.activityManifest,
+            tags: mergedTags,
+            source_workflow_id: args.workflow_id,
+            source_workflow_type: args.workflow_name,
+            original_prompt: result.originalPrompt || undefined,
+            category: result.category || undefined,
+            metadata: {
+                input_field_meta: result.inputFieldMeta,
+                ...(result.validationIssues?.length ? { validation_warnings: result.validationIssues } : {}),
+            },
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        id: record.id,
+                        name: record.name,
+                        app_id: record.app_id,
+                        status: record.status,
+                        activity_count: record.activity_manifest?.filter((a) => a.type === 'worker').length ?? 0,
+                    }),
+                }],
+        };
+    });
+    // mirrors POST /api/yaml-workflows/:id/deploy
+    server.registerTool('deploy_yaml_workflow', {
+        title: 'Deploy Pipeline Workflow',
+        description: 'Deploy a compiled YAML workflow to HotMesh, activate it, and ' +
+            'register workers. All sibling workflows sharing the same app_id ' +
+            'are deployed together.',
+        inputSchema: schemas_1.deployYamlWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflow(args.id);
+        if (!wf) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'YAML workflow not found' }) }],
+                isError: true,
+            };
+        }
+        const deployVersion = wf.app_version || '1';
+        const siblings = await yamlDb.listYamlWorkflowsByAppId(wf.app_id);
+        await yamlDeployer.deployAppId(wf.app_id, deployVersion);
+        for (const sibling of siblings) {
+            await yamlDb.updateYamlWorkflowVersion(sibling.id, deployVersion);
+            await yamlWorkers.registerWorkersForWorkflow(sibling);
+            if (sibling.status === 'draft' || sibling.status === 'deployed') {
+                await yamlDb.updateYamlWorkflowStatus(sibling.id, 'active');
+            }
+        }
+        await yamlDb.markAppIdContentDeployed(wf.app_id);
+        const updated = await yamlDb.getYamlWorkflow(args.id);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        deployed: true,
+                        id: updated?.id,
+                        name: updated?.name,
+                        status: updated?.status,
+                        app_id: updated?.app_id,
+                    }),
+                }],
+        };
+    });
+    // mirrors POST /api/yaml-workflows/:id/invoke
+    server.registerTool('invoke_yaml_workflow', {
+        title: 'Invoke Pipeline Workflow',
+        description: 'Run a compiled YAML workflow. Deterministic — no LLM reasoning, ' +
+            'just direct tool-to-tool data piping. Set sync=true to wait for result.',
+        inputSchema: schemas_1.invokeYamlWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflow(args.id);
+        if (!wf) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'YAML workflow not found' }) }],
+                isError: true,
+            };
+        }
+        if (wf.status !== 'active') {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: 'Workflow must be active to invoke' }) }],
+                isError: true,
+            };
+        }
+        if (args.sync) {
+            const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, args.data, args.timeout, wf.graph_topic);
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ job_id, result }) }],
+            };
+        }
+        const jobId = await yamlDeployer.invokeYamlWorkflow(wf.app_id, wf.graph_topic, args.data, wf.graph_topic);
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ job_id: jobId }) }],
+        };
+    });
+}

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

@@ -36,7 +36,7 @@ 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 logger_1 = require("../../lib/logger");
 const claudeCode = __importStar(require("../activities/claude-code"));
 // ── Schemas ──────────────────────────────────────────────────────────────────
 const executeTaskSchema = zod_1.z.object({

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

@@ -4,7 +4,7 @@ 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 logger_1 = require("../../../lib/logger");
 const tools_1 = require("./tools");
 let server = null;
 /**

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

@@ -14,8 +14,8 @@ export declare const findTasksSchema: z.ZodObject<{
 }, {
     status?: "pending" | "in_progress" | "completed" | "needs_intervention" | "failed" | undefined;
     workflow_type?: string | undefined;
-    limit?: number | undefined;
     workflow_id?: string | undefined;
+    limit?: number | undefined;
     origin_id?: string | undefined;
 }>;
 export declare const findEscalationsSchema: z.ZodObject<{
@@ -34,8 +34,8 @@ export declare const findEscalationsSchema: z.ZodObject<{
     role?: string | undefined;
     status?: "pending" | "resolved" | undefined;
     type?: string | undefined;
-    priority?: number | undefined;
     limit?: number | undefined;
+    priority?: number | undefined;
 }>;
 export declare const getProcessSummarySchema: z.ZodObject<{
     workflow_type: z.ZodOptional<z.ZodString>;

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

@@ -34,7 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerTools = registerTools;
-const db_1 = require("../../../services/db");
+const db_1 = require("../../../lib/db");
 const taskService = __importStar(require("../../../services/task"));
 const escalationService = __importStar(require("../../../services/escalation"));
 const configService = __importStar(require("../../../services/config"));
@@ -190,16 +190,22 @@ function registerTools(instance) {
     // ── get_system_health ──────────────────────────────────────────
     instance.registerTool('get_system_health', {
         title: 'Get System Health',
-        description: 'Overall system health snapshot: task counts by status, escalation counts by status, ' +
-            'active workflow types, and recent activity window.',
+        description: 'Full system overview: durable workflow execution counts by type (active/completed), ' +
+            'task counts by status, escalation counts by status, recent activity window, ' +
+            'MCP servers (with tool counts and tags), compiled workflow totals, and workflow configurations.',
         inputSchema: schemas_1.getSystemHealthSchema,
     }, async (_args) => {
         const pool = (0, db_1.getPool)();
-        const [taskCounts, escalationCounts, activeTypes, recentActivity] = await Promise.all([
+        const [taskCounts, escalationCounts, activeTypes, recentActivity, mcpServers, mcpServerList, compiledWorkflows, workflowConfigs, durableWorkflows,] = await Promise.all([
             pool.query(sql_1.HEALTH_TASK_COUNTS),
             pool.query(sql_1.HEALTH_ESCALATION_COUNTS),
             pool.query(sql_1.HEALTH_ACTIVE_WORKFLOW_TYPES),
             pool.query(sql_1.HEALTH_RECENT_ACTIVITY),
+            pool.query(sql_1.HEALTH_MCP_SERVERS),
+            pool.query(sql_1.HEALTH_MCP_SERVER_LIST),
+            pool.query(sql_1.HEALTH_COMPILED_WORKFLOWS),
+            pool.query(sql_1.HEALTH_WORKFLOW_CONFIGS),
+            pool.query(sql_1.HEALTH_DURABLE_WORKFLOWS),
         ]);
         const tasksByStatus = {};
         for (const row of taskCounts.rows) {
@@ -213,10 +219,17 @@ function registerTools(instance) {
             content: [{
                     type: 'text',
                     text: JSON.stringify({
+                        durable_workflows: durableWorkflows.rows,
                         tasks: tasksByStatus,
                         escalations: escalationsByStatus,
                         active_workflow_types: activeTypes.rows.map((r) => r.workflow_type),
                         recent_activity: recentActivity.rows[0],
+                        mcp_servers: {
+                            ...mcpServers.rows[0],
+                            servers: mcpServerList.rows,
+                        },
+                        compiled_workflows: compiledWorkflows.rows[0],
+                        workflow_configs: workflowConfigs.rows,
                     }),
                 }],
         };

package/build/system/mcp-servers/docs.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createDocsServer(options?: {
+    name?: string;
+}): Promise<McpServer>;
+export declare function stopDocsServer(): Promise<void>;

package/build/system/mcp-servers/docs.js

@@ -0,0 +1,147 @@
+"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.createDocsServer = createDocsServer;
+exports.stopDocsServer = stopDocsServer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../../lib/logger");
+// Resolve docs directory (works from ts-node root and compiled build/)
+function docsDir() {
+    const candidates = [
+        path.join(__dirname, '..', '..', 'docs'),
+        path.join(__dirname, '..', '..', '..', 'docs'),
+    ];
+    for (const dir of candidates) {
+        if (fs.existsSync(dir))
+            return dir;
+    }
+    return candidates[0];
+}
+function listMarkdownFiles(dir, prefix = '') {
+    if (!fs.existsSync(dir))
+        return [];
+    const results = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            results.push(...listMarkdownFiles(path.join(dir, entry.name), rel));
+        }
+        else if (entry.name.endsWith('.md')) {
+            const content = fs.readFileSync(path.join(dir, entry.name), 'utf-8');
+            const firstLine = content.split('\n').find(l => l.startsWith('# '));
+            const title = firstLine ? firstLine.replace(/^#\s+/, '') : entry.name;
+            results.push({ path: rel, title });
+        }
+    }
+    return results;
+}
+const listDocsSchema = zod_1.z.object({});
+const searchDocsSchema = zod_1.z.object({
+    query: zod_1.z.string().describe('Search term or phrase to find in documentation'),
+});
+const readDocSchema = zod_1.z.object({
+    path: zod_1.z.string().describe('Document path relative to docs/ (e.g. "mcp.md" or "api/tasks.md")'),
+});
+function registerTools(srv) {
+    srv.registerTool('list_docs', {
+        title: 'List Documentation',
+        description: 'List all available documentation files with their titles.',
+        inputSchema: listDocsSchema,
+    }, async () => {
+        const docs = listMarkdownFiles(docsDir());
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ docs }) }],
+        };
+    });
+    srv.registerTool('search_docs', {
+        title: 'Search Documentation',
+        description: 'Search across all documentation for a keyword or phrase. Returns matching files with line context.',
+        inputSchema: searchDocsSchema,
+    }, async (args) => {
+        const dir = docsDir();
+        const files = listMarkdownFiles(dir);
+        const query = args.query.toLowerCase();
+        const matches = [];
+        for (const file of files) {
+            const content = fs.readFileSync(path.join(dir, file.path), 'utf-8');
+            const fileLines = content.split('\n');
+            const hits = [];
+            for (let i = 0; i < fileLines.length; i++) {
+                if (fileLines[i].toLowerCase().includes(query)) {
+                    // Include surrounding context
+                    const start = Math.max(0, i - 1);
+                    const end = Math.min(fileLines.length, i + 2);
+                    hits.push(fileLines.slice(start, end).join('\n'));
+                }
+            }
+            if (hits.length > 0) {
+                matches.push({ path: file.path, title: file.title, lines: hits.slice(0, 5) });
+            }
+        }
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ query: args.query, matches }) }],
+        };
+    });
+    srv.registerTool('read_doc', {
+        title: 'Read Documentation',
+        description: 'Read the full content of a documentation file.',
+        inputSchema: readDocSchema,
+    }, async (args) => {
+        const filePath = path.join(docsDir(), args.path);
+        if (!fs.existsSync(filePath)) {
+            return {
+                content: [{ type: 'text', text: JSON.stringify({ error: `Document not found: ${args.path}` }) }],
+            };
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ path: args.path, content }) }],
+        };
+    });
+}
+async function createDocsServer(options) {
+    const name = options?.name || 'long-tail-docs';
+    const instance = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    registerTools(instance);
+    const docs = listMarkdownFiles(docsDir());
+    logger_1.loggerRegistry.info(`[lt-mcp:docs] ${name} ready (3 tools, ${docs.length} docs indexed)`);
+    return instance;
+}
+async function stopDocsServer() {
+    logger_1.loggerRegistry.info('[lt-mcp:docs] stopped');
+}

package/build/system/mcp-servers/file-storage.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFileStorageServer = createFileStorageServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const fileStorage = __importStar(require("../activities/file-storage"));
 const writeFileSchema = zod_1.z.object({
     path: zod_1.z.string().describe('File path relative to storage root'),

package/build/system/mcp-servers/http-fetch.js

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createHttpFetchServer = createHttpFetchServer;
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const http = __importStar(require("../activities/http"));
 const httpRequestSchema = zod_1.z.object({
     url: zod_1.z.string().describe('URL to request'),

package/build/system/mcp-servers/human-queue.js

@@ -39,7 +39,7 @@ exports.stopServer = stopServer;
 const crypto = __importStar(require("crypto"));
 const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
-const logger_1 = require("../../services/logger");
+const logger_1 = require("../../lib/logger");
 const escalationService = __importStar(require("../../services/escalation"));
 let server = null;
 // ── Schemas (extracted to break TS2589 deep-instantiation in registerTool generics) ──

package/build/system/mcp-servers/knowledge.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function createKnowledgeServer(options?: {
+    name?: string;
+}): Promise<McpServer>;