@hotmeshio/long-tail 0.1.0

package/build/services/mcp/workflow-compiler-server.js

@@ -0,0 +1,206 @@
+"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.createWorkflowCompilerServer = createWorkflowCompilerServer;
+exports.getWorkflowCompilerServer = getWorkflowCompilerServer;
+exports.stopWorkflowCompilerServer = stopWorkflowCompilerServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const logger_1 = require("../logger");
+const yamlGenerator = __importStar(require("../yaml-workflow/generator"));
+const yamlDb = __importStar(require("../yaml-workflow/db"));
+const yamlDeployer = __importStar(require("../yaml-workflow/deployer"));
+const yamlWorkers = __importStar(require("../yaml-workflow/workers"));
+let server = null;
+// ── Schemas (extracted to break TS2589 deep-instantiation in registerTool generics) ──
+const convertSchema = zod_1.z.object({
+    workflow_id: zod_1.z.string().describe('The workflow execution ID to analyze'),
+    task_queue: zod_1.z.string().describe('HotMesh task queue (e.g., "long-tail-examples")'),
+    workflow_name: zod_1.z.string().describe('Workflow name (e.g., "reviewContent")'),
+    yaml_name: zod_1.z.string().describe('Name for the generated YAML workflow'),
+    description: zod_1.z.string().optional().describe('Optional description'),
+});
+const deploySchema = zod_1.z.object({
+    yaml_workflow_id: zod_1.z.string().describe('UUID of the stored YAML workflow'),
+    activate: zod_1.z.boolean().optional().default(false)
+        .describe('Whether to activate immediately after deployment'),
+});
+const listSchema = zod_1.z.object({
+    status: zod_1.z.enum(['draft', 'deployed', 'active', 'archived']).optional()
+        .describe('Filter by status'),
+    limit: zod_1.z.number().int().min(1).max(100).optional().default(25)
+        .describe('Maximum number of results'),
+    offset: zod_1.z.number().int().min(0).optional().default(0)
+        .describe('Pagination offset'),
+});
+/**
+ * Create the Workflow Compiler MCP server.
+ *
+ * Provides tools for converting MCP tool call sequences into
+ * deterministic HotMesh YAML workflows:
+ * - convert_execution_to_yaml — analyze execution and generate YAML
+ * - deploy_yaml_workflow — deploy and optionally activate
+ * - list_yaml_workflows — list stored YAML workflows
+ */
+async function createWorkflowCompilerServer(options) {
+    if (server)
+        return server;
+    const name = options?.name || 'workflow-compiler';
+    server = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    // ── convert_execution_to_yaml ─────────────────────────────────────
+    server.registerTool('convert_execution_to_yaml', {
+        title: 'Convert Execution to YAML',
+        description: 'Analyze a completed workflow execution and convert its tool call sequence ' +
+            'into a deterministic HotMesh YAML workflow. Extracts callLLM→callDbTool pairs ' +
+            'and mcp_* activities, replacing LLM reasoning with direct tool-to-tool data piping. ' +
+            'The generated YAML is stored as a draft that can be deployed and activated.',
+        inputSchema: convertSchema,
+    }, async (args) => {
+        const result = await yamlGenerator.generateYamlFromExecution({
+            workflowId: args.workflow_id,
+            taskQueue: args.task_queue,
+            workflowName: args.workflow_name,
+            name: args.yaml_name,
+            description: args.description,
+        });
+        const record = await yamlDb.createYamlWorkflow({
+            name: args.yaml_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,
+            source_workflow_id: args.workflow_id,
+            source_workflow_type: args.workflow_name,
+            metadata: { input_field_meta: result.inputFieldMeta },
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        yaml_workflow_id: record.id,
+                        app_id: record.app_id,
+                        activity_count: result.activityManifest.filter((a) => a.type === 'worker').length,
+                        input_schema: result.inputSchema,
+                        input_field_meta: result.inputFieldMeta,
+                        yaml_preview: result.yaml.slice(0, 500),
+                        ...(result.compilationPlan ? {
+                            compilation: {
+                                intent: result.compilationPlan.intent,
+                                core_steps: result.compilationPlan.coreStepIndices.length,
+                                has_iteration: result.compilationPlan.hasIteration,
+                                llm_refined: true,
+                            },
+                        } : { compilation: { llm_refined: false } }),
+                    }),
+                }],
+        };
+    });
+    // ── deploy_yaml_workflow ──────────────────────────────────────────
+    server.registerTool('deploy_yaml_workflow', {
+        title: 'Deploy YAML Workflow',
+        description: 'Deploy a stored YAML workflow to HotMesh. Optionally activate it immediately ' +
+            'and register workers so it can receive invocations.',
+        inputSchema: deploySchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflow(args.yaml_workflow_id);
+        if (!wf)
+            throw new Error('YAML workflow not found');
+        await yamlDeployer.deployYamlWorkflow(wf.app_id, wf.yaml_content);
+        await yamlDb.updateYamlWorkflowStatus(wf.id, 'deployed');
+        let status = 'deployed';
+        if (args.activate) {
+            await yamlDeployer.activateYamlWorkflow(wf.app_id, wf.app_version);
+            await yamlWorkers.registerWorkersForWorkflow(wf);
+            await yamlDb.updateYamlWorkflowStatus(wf.id, 'active');
+            status = 'active';
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        status,
+                        app_id: wf.app_id,
+                        graph_topic: wf.graph_topic,
+                    }),
+                }],
+        };
+    });
+    // ── list_yaml_workflows ───────────────────────────────────────────
+    server.registerTool('list_yaml_workflows', {
+        title: 'List YAML Workflows',
+        description: 'List stored YAML workflows with optional status filter. ' +
+            'Returns workflow metadata including name, status, source, and activity count.',
+        inputSchema: listSchema,
+    }, async (args) => {
+        const { workflows, total } = await yamlDb.listYamlWorkflows({
+            status: args.status,
+            limit: args.limit,
+            offset: args.offset,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        total,
+                        count: workflows.length,
+                        workflows: workflows.map((wf) => ({
+                            id: wf.id,
+                            name: wf.name,
+                            app_id: wf.app_id,
+                            status: wf.status,
+                            source_workflow_type: wf.source_workflow_type,
+                            activity_count: wf.activity_manifest.filter((a) => a.type === 'worker').length,
+                            graph_topic: wf.graph_topic,
+                            created_at: wf.created_at,
+                        })),
+                    }),
+                }],
+        };
+    });
+    logger_1.loggerRegistry.info(`[lt-mcp] workflow compiler server created: ${name}`);
+    return server;
+}
+function getWorkflowCompilerServer() {
+    return server;
+}
+async function stopWorkflowCompilerServer() {
+    if (server) {
+        await server.close?.();
+        server = null;
+    }
+}

package/build/services/mcp/workflow-server.d.ts

@@ -0,0 +1,24 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/**
+ * Create the Long Tail MCP Workflows server.
+ *
+ * Exposes compiled YAML workflows — hardened, deterministic pipelines
+ * that were originally discovered through dynamic MCP triage — as
+ * invocable MCP tools.
+ *
+ * Tools:
+ * - list_workflows — discover available compiled workflows
+ * - get_workflow — inspect a workflow's schema and activity manifest
+ * - invoke_workflow — run a workflow (sync or async)
+ */
+export declare function createWorkflowServer(options?: {
+    name?: string;
+}): Promise<McpServer>;
+/**
+ * Get the current workflow MCP server instance.
+ */
+export declare function getWorkflowServer(): McpServer | null;
+/**
+ * Stop the workflow MCP server.
+ */
+export declare function stopWorkflowServer(): Promise<void>;

package/build/services/mcp/workflow-server.js

@@ -0,0 +1,230 @@
+"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.createWorkflowServer = createWorkflowServer;
+exports.getWorkflowServer = getWorkflowServer;
+exports.stopWorkflowServer = stopWorkflowServer;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const zod_1 = require("zod");
+const defaults_1 = require("../../modules/defaults");
+const logger_1 = require("../logger");
+const yamlDb = __importStar(require("../yaml-workflow/db"));
+const yamlDeployer = __importStar(require("../yaml-workflow/deployer"));
+let server = null;
+// ── Schemas ─────────────────────────────────────────────────────────────────
+const listWorkflowsSchema = zod_1.z.object({
+    status: zod_1.z.enum(['active', 'deployed', 'draft', 'archived']).optional()
+        .describe('Filter by lifecycle status. Defaults to "active" (ready to invoke).'),
+});
+const invokeWorkflowSchema = zod_1.z.object({
+    workflow_name: zod_1.z.string()
+        .describe('Name of the compiled workflow to invoke (from list_workflows)'),
+    input: zod_1.z.record(zod_1.z.any()).optional().default({})
+        .describe('Input data matching the workflow input schema'),
+    async: zod_1.z.boolean().optional().default(false)
+        .describe('If true, fire-and-forget (returns job ID). If false, wait for result.'),
+    timeout: zod_1.z.number().optional()
+        .describe('Max milliseconds to wait for result (sync mode only). Default: 120000.'),
+});
+const getWorkflowSchema = zod_1.z.object({
+    workflow_name: zod_1.z.string()
+        .describe('Name of the workflow to inspect'),
+});
+/**
+ * Create the Long Tail MCP Workflows server.
+ *
+ * Exposes compiled YAML workflows — hardened, deterministic pipelines
+ * that were originally discovered through dynamic MCP triage — as
+ * invocable MCP tools.
+ *
+ * Tools:
+ * - list_workflows — discover available compiled workflows
+ * - get_workflow — inspect a workflow's schema and activity manifest
+ * - invoke_workflow — run a workflow (sync or async)
+ */
+async function createWorkflowServer(options) {
+    if (server)
+        return server;
+    const name = options?.name || 'mcp-workflows-longtail';
+    server = new mcp_js_1.McpServer({ name, version: '1.0.0' });
+    // ── list_workflows ──────────────────────────────────────────────────
+    server.registerTool('list_workflows', {
+        title: 'List Compiled Workflows',
+        description: 'List available compiled YAML workflows. These are deterministic pipelines ' +
+            'converted from successful MCP triage executions. Each workflow represents ' +
+            'a proven solution to a specific edge case (e.g., rotate-and-extract for ' +
+            'upside-down documents). Defaults to listing active (invocable) workflows.',
+        inputSchema: listWorkflowsSchema,
+    }, async (args) => {
+        const { workflows } = await yamlDb.listYamlWorkflows({
+            status: args.status || 'active',
+            limit: defaults_1.QUERY_LIMIT_MAX,
+        });
+        const items = workflows.map((wf) => ({
+            name: wf.name,
+            description: wf.description,
+            graph_topic: wf.graph_topic,
+            source_workflow_type: wf.source_workflow_type,
+            input_schema: wf.input_schema,
+            output_schema: wf.output_schema,
+            activity_count: wf.activity_manifest.filter((a) => a.type === 'worker').length,
+            status: wf.status,
+            activated_at: wf.activated_at,
+        }));
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ count: items.length, workflows: items }),
+                }],
+        };
+    });
+    // ── get_workflow ─────────────────────────────────────────────────────
+    server.registerTool('get_workflow', {
+        title: 'Get Workflow Details',
+        description: 'Inspect a compiled workflow by name. Returns the full activity manifest, ' +
+            'input/output schemas, and provenance (which execution it was compiled from).',
+        inputSchema: getWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflowByName(args.workflow_name);
+        if (!wf) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: `Workflow "${args.workflow_name}" not found` }),
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        name: wf.name,
+                        description: wf.description,
+                        app_id: wf.app_id,
+                        graph_topic: wf.graph_topic,
+                        status: wf.status,
+                        source_workflow_id: wf.source_workflow_id,
+                        source_workflow_type: wf.source_workflow_type,
+                        input_schema: wf.input_schema,
+                        output_schema: wf.output_schema,
+                        activities: wf.activity_manifest.filter((a) => a.type === 'worker').map((a) => ({
+                            title: a.title,
+                            tool_source: a.tool_source,
+                            mcp_server_id: a.mcp_server_id,
+                            mcp_tool_name: a.mcp_tool_name,
+                        })),
+                        activated_at: wf.activated_at,
+                        created_at: wf.created_at,
+                    }),
+                }],
+        };
+    });
+    // ── invoke_workflow ──────────────────────────────────────────────────
+    server.registerTool('invoke_workflow', {
+        title: 'Invoke Compiled Workflow',
+        description: 'Run a compiled YAML workflow by name. These are deterministic pipelines — ' +
+            'no LLM reasoning, just direct tool-to-tool data piping. Use list_workflows ' +
+            'to discover available workflows and their input schemas. ' +
+            'Set async=true for fire-and-forget (returns job ID), or leave false to wait for the result.',
+        inputSchema: invokeWorkflowSchema,
+    }, async (args) => {
+        const wf = await yamlDb.getYamlWorkflowByName(args.workflow_name);
+        if (!wf) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ error: `Workflow "${args.workflow_name}" not found` }),
+                    }],
+                isError: true,
+            };
+        }
+        if (wf.status !== 'active') {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `Workflow "${args.workflow_name}" is not active (status: ${wf.status})`,
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        if (args.async) {
+            const jobId = await yamlDeployer.invokeYamlWorkflow(wf.app_id, wf.graph_topic, args.input || {}, wf.graph_topic);
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            job_id: jobId,
+                            workflow: wf.name,
+                            status: 'started',
+                        }),
+                    }],
+            };
+        }
+        const { job_id, result } = await yamlDeployer.invokeYamlWorkflowSync(wf.app_id, wf.graph_topic, args.input || {}, args.timeout, wf.graph_topic);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        job_id,
+                        namespace: wf.app_id,
+                        workflow: wf.name,
+                        status: 'completed',
+                        result,
+                    }),
+                }],
+        };
+    });
+    const toolCount = 3;
+    logger_1.loggerRegistry.info(`[lt-mcp:server] ${name} ready (${toolCount} tools registered)`);
+    return server;
+}
+/**
+ * Get the current workflow MCP server instance.
+ */
+function getWorkflowServer() {
+    return server;
+}
+/**
+ * Stop the workflow MCP server.
+ */
+async function stopWorkflowServer() {
+    if (server) {
+        await server.close?.();
+        server = null;
+    }
+}

package/build/services/mcp-runs/enrichment.d.ts

@@ -0,0 +1,12 @@
+import type { ActivityDetail } from './types';
+/**
+ * Fetch enriched activity inputs from HotMesh's stream history.
+ * Returns a lookup map keyed by `name:dimension` for merging into events.
+ * Best-effort — returns empty map on failure.
+ */
+export declare function fetchActivityInputs(jobId: string, appId: string): Promise<Map<string, Record<string, any>>>;
+/**
+ * Fetch the structured ActivityDetail array from HotMesh export.
+ * Returns undefined if enrichment fails or produces no results.
+ */
+export declare function fetchActivityDetails(jobId: string, appId: string): Promise<ActivityDetail[] | undefined>;

package/build/services/mcp-runs/enrichment.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchActivityInputs = fetchActivityInputs;
+exports.fetchActivityDetails = fetchActivityDetails;
+const controlplane_1 = require("../controlplane");
+/**
+ * Fetch enriched activity inputs from HotMesh's stream history.
+ * Returns a lookup map keyed by `name:dimension` for merging into events.
+ * Best-effort — returns empty map on failure.
+ */
+async function fetchActivityInputs(jobId, appId) {
+    const map = new Map();
+    try {
+        const engine = await (0, controlplane_1.getEngine)(appId);
+        const exported = await engine.export(jobId, { enrich_inputs: true });
+        for (const activity of exported.activities ?? []) {
+            map.set(`${activity.name}:${activity.dimension}`, activity.input ?? {});
+        }
+    }
+    catch {
+        // enrichment is best-effort; continue without inputs
+    }
+    return map;
+}
+/**
+ * Fetch the structured ActivityDetail array from HotMesh export.
+ * Returns undefined if enrichment fails or produces no results.
+ */
+async function fetchActivityDetails(jobId, appId) {
+    try {
+        const engine = await (0, controlplane_1.getEngine)(appId);
+        const exported = await engine.export(jobId, { enrich_inputs: true });
+        const activities = exported.activities;
+        return activities?.length ? activities : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/build/services/mcp-runs/events.d.ts

@@ -0,0 +1,6 @@
+import type { ExecutionEvent, JobContext } from './types';
+/**
+ * Transform raw activities + job context into a chronological event list
+ * with back-references linking completions to their scheduled events.
+ */
+export declare function buildEvents(ctx: JobContext, inputByNameDim: Map<string, Record<string, any>>): ExecutionEvent[];

package/build/services/mcp-runs/events.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildEvents = buildEvents;
+const hotmesh_utils_1 = require("../hotmesh-utils");
+/**
+ * Transform raw activities + job context into a chronological event list
+ * with back-references linking completions to their scheduled events.
+ */
+function buildEvents(ctx, inputByNameDim) {
+    const events = [];
+    let nextId = 1;
+    events.push(workflowStartedEvent(nextId++, ctx));
+    for (let i = 0; i < ctx.activities.length; i++) {
+        const act = ctx.activities[i];
+        const input = inputByNameDim.get(`${act.name}:${act.dimensions}`) ?? undefined;
+        const timelineKey = `${act.dimensions}/${act.name}`;
+        if (act.ac) {
+            events.push(scheduledEvent(nextId++, act, input, timelineKey, i));
+        }
+        if (act.au) {
+            events.push(completionEvent(nextId++, act, input, timelineKey, i));
+        }
+    }
+    appendWorkflowTerminalEvent(events, nextId, ctx);
+    sortAndLinkEvents(events);
+    return events;
+}
+// ── Event factories ──────────────────────────────────────────────────────────
+function workflowStartedEvent(id, ctx) {
+    return {
+        event_id: id,
+        event_type: 'workflow_execution_started',
+        category: 'workflow',
+        event_time: ctx.startTime || ctx.job.created_at?.toISOString() || '',
+        duration_ms: null,
+        is_system: false,
+        attributes: {
+            kind: 'workflow_execution_started',
+            workflow_type: ctx.workflowName,
+            task_queue: ctx.appId,
+            trace_id: ctx.traceId,
+        },
+    };
+}
+function scheduledEvent(id, act, input, timelineKey, index) {
+    return {
+        event_id: id,
+        event_type: 'activity_task_scheduled',
+        category: 'activity',
+        event_time: (0, hotmesh_utils_1.hmshTimestampToISO)(act.ac),
+        duration_ms: null,
+        is_system: act.type === 'trigger',
+        attributes: {
+            kind: 'activity_task_scheduled',
+            activity_type: input?.workflowName || act.step || act.name,
+            input,
+            timeline_key: timelineKey,
+            execution_index: index,
+            trace_id: act.traceId,
+            span_id: act.spanId,
+        },
+    };
+}
+function completionEvent(id, act, input, timelineKey, index) {
+    const failed = !!act.error;
+    return {
+        event_id: id,
+        event_type: failed ? 'activity_task_failed' : 'activity_task_completed',
+        category: 'activity',
+        event_time: (0, hotmesh_utils_1.hmshTimestampToISO)(act.au),
+        duration_ms: (0, hotmesh_utils_1.computeDuration)(act.ac ?? undefined, act.au ?? undefined),
+        is_system: act.type === 'trigger',
+        attributes: {
+            kind: failed ? 'activity_task_failed' : 'activity_task_completed',
+            activity_type: input?.workflowName || act.step || act.name,
+            input,
+            ...(failed ? { failure: act.error } : {}),
+            result: act.data,
+            timeline_key: timelineKey,
+            execution_index: index,
+            trace_id: act.traceId,
+            span_id: act.spanId,
+        },
+    };
+}
+function appendWorkflowTerminalEvent(events, nextId, ctx) {
+    const status = ctx.job.status > 0 ? 'running' : ctx.job.status === 0 ? 'completed' : 'failed';
+    if (status === 'completed') {
+        events.push({
+            event_id: nextId,
+            event_type: 'workflow_execution_completed',
+            category: 'workflow',
+            event_time: ctx.closeTime || '',
+            duration_ms: null,
+            is_system: false,
+            attributes: { kind: 'workflow_execution_completed', result: ctx.workflowResult },
+        });
+    }
+    else if (status === 'failed') {
+        events.push({
+            event_id: nextId,
+            event_type: 'workflow_execution_failed',
+            category: 'workflow',
+            event_time: ctx.closeTime || '',
+            duration_ms: null,
+            is_system: false,
+            attributes: { kind: 'workflow_execution_failed', failure: ctx.metadata?.['err'] ?? null },
+        });
+    }
+}
+// ── Post-processing ──────────────────────────────────────────────────────────
+function sortAndLinkEvents(events) {
+    events.sort((a, b) => a.event_time.localeCompare(b.event_time) || a.event_id - b.event_id);
+    for (let i = 0; i < events.length; i++)
+        events[i].event_id = i + 1;
+    const scheduledMap = new Map();
+    for (const e of events) {
+        const a = e.attributes;
+        if (e.event_type === 'activity_task_scheduled' && a.timeline_key) {
+            scheduledMap.set(a.timeline_key, e.event_id);
+        }
+        if ((e.event_type === 'activity_task_completed' || e.event_type === 'activity_task_failed') && a.timeline_key) {
+            a.scheduled_event_id = scheduledMap.get(a.timeline_key) ?? null;
+        }
+    }
+}

package/build/services/mcp-runs/execution-builder.d.ts

@@ -0,0 +1,12 @@
+import type { ExecutionExport } from './types';
+/**
+ * Build a complete execution export for a YAML engine workflow job.
+ *
+ * Pipeline:
+ *   1. Load job record and inflate symbolic attributes
+ *   2. Extract metadata and activity hierarchy
+ *   3. Enrich activities with input data from stream history
+ *   4. Construct chronological event timeline
+ *   5. Assemble final export with summary statistics
+ */
+export declare function buildExecution(jobId: string, appId: string, schema: string): Promise<ExecutionExport>;