@hotmeshio/long-tail 0.1.0

package/build/services/yaml-workflow/pipeline/compile/llm-call.js

@@ -0,0 +1,153 @@
+"use strict";
+/**
+ * LLM compilation call and server tool inventory gathering.
+ *
+ * Calls the LLM with summarized execution steps and parses the
+ * response into an EnhancedCompilationPlan.
+ */
+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.callCompilationLLM = callCompilationLLM;
+const llm_1 = require("../../../llm");
+const defaults_1 = require("../../../../modules/defaults");
+const prompts_1 = require("../prompts");
+const summarize_1 = require("./summarize");
+const parse_plan_1 = require("./parse-plan");
+/**
+ * Gather the full tool inventory and compile hints for MCP servers used in the execution trace.
+ * Returns both the tool inventory (for substitution) and per-server compile hints (for context).
+ */
+async function gatherServerToolInventory(steps) {
+    const serverIds = new Set();
+    for (const step of steps) {
+        if (step.mcpServerId)
+            serverIds.add(step.mcpServerId);
+    }
+    if (serverIds.size === 0)
+        return { inventory: '', compileHints: '' };
+    try {
+        const mcpDbService = await Promise.resolve().then(() => __importStar(require('../../../mcp/db')));
+        const { servers } = await mcpDbService.listMcpServers({ limit: 100 });
+        const relevant = servers.filter((s) => serverIds.has(s.name));
+        const inventoryLines = [];
+        const hintLines = [];
+        for (const server of relevant) {
+            const tools = (server.tool_manifest || []).map((t) => {
+                const params = t.inputSchema?.properties
+                    ? Object.entries(t.inputSchema.properties)
+                        .map(([k, v]) => `${k}: ${v.type || '?'}`)
+                        .join(', ')
+                    : '';
+                return `    - ${t.name}(${params}): ${(t.description || '').slice(0, 120)}`;
+            });
+            inventoryLines.push(`  ${server.name}:`);
+            inventoryLines.push(...tools);
+            if (server.compile_hints) {
+                hintLines.push(`  **${server.name}**: ${server.compile_hints}`);
+            }
+        }
+        return {
+            inventory: inventoryLines.join('\n'),
+            compileHints: hintLines.join('\n'),
+        };
+    }
+    catch {
+        return { inventory: '', compileHints: '' };
+    }
+}
+/**
+ * Call the LLM to produce an EnhancedCompilationPlan.
+ * Returns null if the LLM is unavailable or the call fails.
+ */
+async function callCompilationLLM(steps, originalPrompt, naiveInputs, patternAnnotations, retryHint) {
+    if (!(0, llm_1.hasLLMApiKey)(defaults_1.LLM_MODEL_PRIMARY))
+        return null;
+    const summaries = (0, summarize_1.summarizeSteps)(steps);
+    const { inventory: toolInventory, compileHints } = await gatherServerToolInventory(steps);
+    const naiveClassification = naiveInputs.map(f => ({
+        key: f.key,
+        type: f.type,
+        classification: f.classification,
+        description: f.description,
+        source_tool: f.source_tool,
+        ...(f.default !== undefined ? { default_preview: (0, summarize_1.truncateValue)(f.default) } : {}),
+    }));
+    const userMessage = [
+        `## Original Prompt`,
+        `"${originalPrompt}"`,
+        ``,
+        `## Execution Steps`,
+        JSON.stringify(summaries, null, 2),
+        ``,
+        ...(patternAnnotations.length > 0 ? [
+            `## Pattern Annotations (pre-detected by static analysis)`,
+            JSON.stringify(patternAnnotations, null, 2),
+            ``,
+        ] : []),
+        `## Naive Input Classification`,
+        JSON.stringify(naiveClassification, null, 2),
+        ``,
+        ...(compileHints ? [
+            `## Tool-Specific Compilation Hints`,
+            `These hints come from the MCP server definitions and describe tool-specific constraints you MUST follow:`,
+            compileHints,
+            ``,
+        ] : []),
+        ...(toolInventory ? [
+            `## Available Tools (full inventory from servers used in this execution)`,
+            `Use these to substitute simpler tools for iterations when the executed tool is too complex.`,
+            toolInventory,
+        ] : []),
+        ...(retryHint ? [retryHint] : []),
+    ].join('\n');
+    try {
+        const response = await (0, llm_1.callLLM)({
+            model: defaults_1.LLM_MODEL_PRIMARY,
+            max_tokens: 4000,
+            temperature: 0,
+            messages: [
+                { role: 'system', content: prompts_1.COMPILATION_PROMPT },
+                { role: 'user', content: userMessage },
+            ],
+        });
+        const raw = response.content || '';
+        return (0, parse_plan_1.parsePlan)(raw, steps.length);
+    }
+    catch (err) {
+        const { loggerRegistry } = await Promise.resolve().then(() => __importStar(require('../../../logger')));
+        loggerRegistry.warn(`[yaml-workflow] LLM compilation failed, using mechanical fallback: ${err}`);
+        return null;
+    }
+}

package/build/services/yaml-workflow/pipeline/compile/parse-plan.d.ts

@@ -0,0 +1,12 @@
+/**
+ * LLM response parsing for compilation plans.
+ *
+ * Parses raw JSON from the LLM into a typed EnhancedCompilationPlan,
+ * handling missing or malformed fields gracefully.
+ */
+import type { EnhancedCompilationPlan } from '../../types';
+/**
+ * Parse the LLM's JSON response into an EnhancedCompilationPlan.
+ * Handles missing/malformed fields gracefully.
+ */
+export declare function parsePlan(raw: string, stepCount: number): EnhancedCompilationPlan;

package/build/services/yaml-workflow/pipeline/compile/parse-plan.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * LLM response parsing for compilation plans.
+ *
+ * Parses raw JSON from the LLM into a typed EnhancedCompilationPlan,
+ * handling missing or malformed fields gracefully.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePlan = parsePlan;
+/**
+ * Parse the LLM's JSON response into an EnhancedCompilationPlan.
+ * Handles missing/malformed fields gracefully.
+ */
+function parsePlan(raw, stepCount) {
+    const cleaned = raw
+        .replace(/^```(?:json)?\s*/m, '')
+        .replace(/\s*```$/m, '')
+        .trim();
+    const parsed = JSON.parse(cleaned);
+    // Parse steps
+    const steps = (parsed.steps || []).map((s) => ({
+        index: typeof s.index === 'number' ? s.index : 0,
+        purpose: s.purpose || '',
+        disposition: s.disposition === 'exploratory' ? 'exploratory' : 'core',
+    }));
+    // Parse iterations
+    const iterations = (parsed.iterations || []).map((it) => ({
+        bodyStepIndex: typeof it.body_step_index === 'number' ? it.body_step_index : 0,
+        toolName: it.tool_name || '',
+        serverId: it.server_id,
+        sourceStepIndex: typeof it.source_step_index === 'number' ? it.source_step_index : 0,
+        sourceField: it.source_field || 'items',
+        varyingKeys: Array.isArray(it.varying_keys) ? it.varying_keys : [],
+        constantArgs: it.constant_args && typeof it.constant_args === 'object' ? it.constant_args : {},
+        keyMappings: it.key_mappings && typeof it.key_mappings === 'object' ? it.key_mappings : {},
+    }));
+    // Parse data flow
+    const dataFlow = (parsed.data_flow || []).map((df) => {
+        const edge = {
+            fromStep: df.from_step === 'trigger' ? 'trigger' : (typeof df.from_step === 'number' ? df.from_step : 0),
+            fromField: df.from_field || '',
+            toStep: typeof df.to_step === 'number' ? df.to_step : 0,
+            toField: df.to_field || '',
+            isSessionWire: !!df.is_session_wire,
+        };
+        // Parse transform spec if present — normalize snake_case from LLM to camelCase
+        if (df.transform && typeof df.transform === 'object') {
+            const rawDerivations = df.transform.derivations;
+            const derivations = rawDerivations
+                ? Object.fromEntries(Object.entries(rawDerivations).map(([k, v]) => [k, {
+                        sourceKey: v.source_key || v.sourceKey || '',
+                        strategy: v.strategy || 'passthrough',
+                        ...(v.prefix ? { prefix: v.prefix } : {}),
+                        ...(v.suffix ? { suffix: v.suffix } : {}),
+                        ...(v.template ? { template: v.template } : {}),
+                    }]))
+                : undefined;
+            edge.transform = {
+                fieldMap: df.transform.field_map && typeof df.transform.field_map === 'object'
+                    ? df.transform.field_map : {},
+                ...(df.transform.defaults ? { defaults: df.transform.defaults } : {}),
+                ...(derivations ? { derivations } : {}),
+            };
+        }
+        return edge;
+    });
+    // Parse inputs
+    const inputs = (parsed.inputs || []).map((inp) => ({
+        key: inp.key,
+        type: inp.type || 'string',
+        classification: inp.classification === 'dynamic' ? 'dynamic' : 'fixed',
+        description: inp.description || '',
+        ...(inp.default !== undefined ? { default: inp.default } : {}),
+    }));
+    return {
+        intent: parsed.intent || '',
+        description: parsed.description || '',
+        steps,
+        coreStepIndices: parsed.core_step_indices || steps
+            .filter(s => s.disposition === 'core')
+            .map(s => s.index),
+        inputs,
+        iterations,
+        dataFlow,
+        sessionFields: Array.isArray(parsed.session_fields) ? parsed.session_fields : [],
+        hasIteration: iterations.length > 0 || !!parsed.has_iteration,
+    };
+}

package/build/services/yaml-workflow/pipeline/compile/summarize.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Step summarization helpers for LLM compilation context.
+ *
+ * Truncates and structures execution step data so the LLM receives
+ * concise but structurally complete information about each step.
+ */
+import type { ExtractedStep } from '../../types';
+export interface StepSummary {
+    index: number;
+    kind: 'tool' | 'llm' | 'signal';
+    toolName: string;
+    server?: string;
+    argumentKeys: string[];
+    arguments: Record<string, unknown>;
+    resultKeys: string[];
+    /** Truncated result structure showing arrays and nested objects. */
+    resultSample: unknown;
+    /** If this step has _iteration metadata from pattern detector. */
+    iterationMeta?: {
+        tool: string;
+        count: number;
+        varyingKeys: string[];
+        constantArgs: Record<string, unknown>;
+        arraySource: {
+            stepIndex: number;
+            field: string;
+        } | null;
+    };
+}
+/** Truncate a value for display in the LLM prompt. */
+export declare function truncateValue(value: unknown): unknown;
+/**
+ * Truncate an object's values for LLM context, preserving structure.
+ */
+export declare function truncateObject(obj: Record<string, unknown>, maxDepth?: number): Record<string, unknown>;
+/**
+ * Summarize extracted steps for the LLM, including result structure.
+ */
+export declare function summarizeSteps(steps: ExtractedStep[]): StepSummary[];

package/build/services/yaml-workflow/pipeline/compile/summarize.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Step summarization helpers for LLM compilation context.
+ *
+ * Truncates and structures execution step data so the LLM receives
+ * concise but structurally complete information about each step.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateValue = truncateValue;
+exports.truncateObject = truncateObject;
+exports.summarizeSteps = summarizeSteps;
+/** Truncate a value for display in the LLM prompt. */
+function truncateValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length <= 2)
+            return value;
+        return `[${value.length} items]`;
+    }
+    if (typeof value === 'string' && value.length > 200) {
+        return value.slice(0, 200) + '...';
+    }
+    if (typeof value === 'object' && value !== null) {
+        const str = JSON.stringify(value);
+        if (str.length > 300)
+            return str.slice(0, 300) + '...';
+        return value;
+    }
+    return value;
+}
+/**
+ * Truncate an object's values for LLM context, preserving structure.
+ */
+function truncateObject(obj, maxDepth = 2) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (Array.isArray(value)) {
+            if (value.length === 0) {
+                result[key] = [];
+            }
+            else if (value.length <= 2) {
+                result[key] = value.map(v => v && typeof v === 'object' && !Array.isArray(v) && maxDepth > 1
+                    ? truncateObject(v, maxDepth - 1)
+                    : truncateValue(v));
+            }
+            else {
+                // Show array structure: type, length, and first item's keys
+                const firstItem = value[0];
+                if (firstItem && typeof firstItem === 'object' && !Array.isArray(firstItem)) {
+                    result[key] = {
+                        _type: 'array',
+                        _length: value.length,
+                        _itemKeys: Object.keys(firstItem),
+                        _firstItem: maxDepth > 1
+                            ? truncateObject(firstItem, maxDepth - 1)
+                            : `{${Object.keys(firstItem).join(', ')}}`,
+                    };
+                }
+                else {
+                    result[key] = { _type: 'array', _length: value.length, _itemType: typeof firstItem };
+                }
+            }
+        }
+        else if (value && typeof value === 'object' && maxDepth > 1) {
+            result[key] = truncateObject(value, maxDepth - 1);
+        }
+        else {
+            result[key] = truncateValue(value);
+        }
+    }
+    return result;
+}
+/**
+ * Summarize extracted steps for the LLM, including result structure.
+ */
+function summarizeSteps(steps) {
+    // Pre-compute array outputs from all steps for provenance detection
+    const arrayOutputs = [];
+    for (let i = 0; i < steps.length; i++) {
+        const result = steps[i].result;
+        if (result && typeof result === 'object' && !Array.isArray(result)) {
+            for (const [field, value] of Object.entries(result)) {
+                if (Array.isArray(value) && value.length > 0) {
+                    arrayOutputs.push({ stepIndex: i, field, items: value });
+                }
+            }
+        }
+    }
+    return steps.map((step, index) => {
+        const args = {};
+        let iterationMeta = undefined;
+        for (const [key, value] of Object.entries(step.arguments)) {
+            if (key === '_iteration') {
+                const iter = value;
+                iterationMeta = {
+                    tool: iter.tool,
+                    count: iter.count,
+                    varyingKeys: iter.varyingKeys,
+                    constantArgs: iter.constantArgs,
+                    arraySource: iter.arraySource,
+                };
+            }
+            else if (Array.isArray(value) && value.length > 3) {
+                // Check if this array was likely derived from a prior step's output
+                let provenance = '';
+                for (const ao of arrayOutputs) {
+                    if (ao.stepIndex >= index)
+                        continue; // only prior steps
+                    if (ao.items.length > 0 && value.length > 0) {
+                        const sourceValues = new Set();
+                        for (const item of ao.items) {
+                            if (item && typeof item === 'object') {
+                                for (const v of Object.values(item)) {
+                                    if (typeof v === 'string')
+                                        sourceValues.add(v);
+                                }
+                            }
+                        }
+                        const targetValues = [];
+                        for (const item of value) {
+                            if (item && typeof item === 'object') {
+                                for (const v of Object.values(item)) {
+                                    if (typeof v === 'string')
+                                        targetValues.push(v);
+                                }
+                            }
+                        }
+                        const overlap = targetValues.filter(v => sourceValues.has(v)).length;
+                        if (overlap > value.length * 0.3) {
+                            provenance = ` ⚠️ DERIVED FROM step ${ao.stepIndex} field "${ao.field}" (${overlap} overlapping values — this is NOT a user input, it was computed from step ${ao.stepIndex}'s output)`;
+                            break;
+                        }
+                    }
+                }
+                args[key] = `[Array of ${value.length} items, first: ${JSON.stringify(value[0]).slice(0, 200)}]${provenance}`;
+            }
+            else if (typeof value === 'string' && value.length > 300) {
+                args[key] = value.slice(0, 300) + '...';
+            }
+            else {
+                args[key] = value;
+            }
+        }
+        // Build result sample showing structure (not just keys)
+        let resultSample = null;
+        if (step.result && typeof step.result === 'object') {
+            if (Array.isArray(step.result)) {
+                resultSample = {
+                    _type: 'array',
+                    _length: step.result.length,
+                    _firstItem: step.result[0] && typeof step.result[0] === 'object'
+                        ? truncateObject(step.result[0])
+                        : step.result[0],
+                };
+            }
+            else {
+                resultSample = truncateObject(step.result);
+            }
+        }
+        const resultKeys = step.result && typeof step.result === 'object' && !Array.isArray(step.result)
+            ? Object.keys(step.result)
+            : [];
+        return {
+            index,
+            kind: step.kind,
+            toolName: step.toolName,
+            server: step.mcpServerId,
+            argumentKeys: Object.keys(step.arguments).filter(k => k !== '_iteration'),
+            arguments: args,
+            resultKeys,
+            resultSample,
+            ...(iterationMeta ? { iterationMeta } : {}),
+        };
+    });
+}

package/build/services/yaml-workflow/pipeline/extract-helpers.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Helper functions for the extract pipeline stage.
+ *
+ * Parsing utilities for MCP activity types, tool arguments,
+ * LLM messages, and default prompt construction.
+ */
+import type { ExtractedStep } from '../types';
+/**
+ * Parse an MCP activity type name back into server name + tool name.
+ * Activity names follow: mcp_{serverName}_{toolName}
+ */
+export declare function parseMcpActivityType(activityType: string): {
+    serverName: string;
+    toolName: string;
+};
+/**
+ * Extract the tool arguments from an enriched activity event's input.
+ *
+ * The enriched `input` field contains the raw arguments passed to the
+ * activity function. The shape depends on the activity:
+ * - callMcpTool(qualifiedName, args) → [qualifiedName, args]
+ * - callDbTool(name, args) → [name, args]
+ * - callLLM(messages, tools?) → [messages, tools?]
+ * - mcp_* activities(args) → [args]
+ */
+export declare function extractToolArgs(attrs: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Extract the LLM prompt messages from an enriched callLLM event's input.
+ * callLLM(messages, tools?) → input = [messages, tools?]
+ */
+export declare function extractLlmMessages(attrs: Record<string, unknown>): Array<{
+    role: string;
+    content: string;
+}> | undefined;
+/**
+ * Build a default prompt template referencing the data available from prior tool steps.
+ * The prompt uses {field} placeholders that map to input_maps at runtime.
+ */
+export declare function buildDefaultPrompt(priorSteps: ExtractedStep[]): Array<{
+    role: string;
+    content: string;
+}>;

package/build/services/yaml-workflow/pipeline/extract-helpers.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Helper functions for the extract pipeline stage.
+ *
+ * Parsing utilities for MCP activity types, tool arguments,
+ * LLM messages, and default prompt construction.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMcpActivityType = parseMcpActivityType;
+exports.extractToolArgs = extractToolArgs;
+exports.extractLlmMessages = extractLlmMessages;
+exports.buildDefaultPrompt = buildDefaultPrompt;
+const prompts_1 = require("./prompts");
+/**
+ * Parse an MCP activity type name back into server name + tool name.
+ * Activity names follow: mcp_{serverName}_{toolName}
+ */
+function parseMcpActivityType(activityType) {
+    const rest = activityType.slice(4);
+    const firstUnderscore = rest.indexOf('_');
+    if (firstUnderscore === -1) {
+        return { serverName: rest, toolName: rest };
+    }
+    return {
+        serverName: rest.slice(0, firstUnderscore),
+        toolName: rest.slice(firstUnderscore + 1),
+    };
+}
+/**
+ * Extract the tool arguments from an enriched activity event's input.
+ *
+ * The enriched `input` field contains the raw arguments passed to the
+ * activity function. The shape depends on the activity:
+ * - callMcpTool(qualifiedName, args) → [qualifiedName, args]
+ * - callDbTool(name, args) → [name, args]
+ * - callLLM(messages, tools?) → [messages, tools?]
+ * - mcp_* activities(args) → [args]
+ */
+function extractToolArgs(attrs) {
+    const input = attrs.input;
+    if (!input || !Array.isArray(input))
+        return {};
+    // callMcpTool / callTriageTool / callDbTool / callVisionTool: [name, args]
+    if (['callMcpTool', 'callTriageTool', 'callDbTool', 'callVisionTool'].includes(attrs.activity_type)) {
+        const args = input[1];
+        return (args && typeof args === 'object' && !Array.isArray(args))
+            ? args
+            : {};
+    }
+    // mcp_* activities: [args] (single argument — the tool parameters)
+    if (attrs.activity_type?.startsWith('mcp_')) {
+        const args = input[0];
+        return (args && typeof args === 'object' && !Array.isArray(args))
+            ? args
+            : {};
+    }
+    return {};
+}
+/**
+ * Extract the LLM prompt messages from an enriched callLLM event's input.
+ * callLLM(messages, tools?) → input = [messages, tools?]
+ */
+function extractLlmMessages(attrs) {
+    const input = attrs.input;
+    if (!input || !Array.isArray(input) || input.length === 0)
+        return undefined;
+    const messages = input[0];
+    if (!Array.isArray(messages))
+        return undefined;
+    return messages.filter((m) => m?.role && m?.content);
+}
+/**
+ * Build a default prompt template referencing the data available from prior tool steps.
+ * The prompt uses {field} placeholders that map to input_maps at runtime.
+ */
+function buildDefaultPrompt(priorSteps) {
+    const lastToolStep = [...priorSteps].reverse().find((s) => s.kind === 'tool');
+    const fields = lastToolStep?.result && typeof lastToolStep.result === 'object' && !Array.isArray(lastToolStep.result)
+        ? Object.keys(lastToolStep.result)
+        : [];
+    const dataRef = fields.length > 0
+        ? `The data includes the following fields: ${fields.join(', ')}.`
+        : 'Analyze the provided data.';
+    return [
+        { role: 'system', content: prompts_1.EXTRACT_DEFAULT_SYSTEM_PROMPT },
+        { role: 'user', content: prompts_1.EXTRACT_DEFAULT_USER_TEMPLATE.replace('{dataRef}', dataRef) },
+    ];
+}

package/build/services/yaml-workflow/pipeline/extract.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Extract stage: Parse execution events into an ordered step sequence.
+ *
+ * Supports four patterns:
+ * 1a. callLLM → callDbTool/callVisionTool (Insight/agentic paired calls)
+ * 1b. callLLM → callMcpTool (mcpQuery with qualified names)
+ * 2.  mcp_* activities (direct external tool calls via proxyActivities)
+ * 3.  callLLM (interpretation) — final LLM text response
+ */
+import type { WorkflowExecutionEvent } from '../../../types';
+import type { ExtractedStep, PipelineContext } from '../types';
+/**
+ * Extract the ordered step sequence from an execution's events.
+ */
+export declare function extractStepSequence(events: WorkflowExecutionEvent[]): ExtractedStep[];
+/**
+ * Resolve slugified server IDs (e.g., "my_server") back to
+ * real MCP server names (e.g., "my-server").
+ */
+export declare function resolveServerIds(steps: ExtractedStep[]): Promise<void>;
+/**
+ * Extract pipeline stage: parse execution events into ordered steps.
+ */
+export declare function extract(ctx: PipelineContext): Promise<PipelineContext>;