@hotmeshio/long-tail 0.1.0

package/build/services/yaml-workflow/input-analyzer.js

@@ -0,0 +1,109 @@
+"use strict";
+/**
+ * Semantic input extraction for YAML workflow generator.
+ *
+ * Analyzes all steps from an execution and classifies each argument as:
+ * - **dynamic**: user-provided at invocation time (e.g., url, query, password)
+ * - **fixed**: implementation detail with a sensible default (e.g., selector, timeout)
+ * - **wired**: inter-step data from previous step output (e.g., page_id, content)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyArgument = void 0;
+exports.extractSemanticInputs = extractSemanticInputs;
+exports.buildEnrichedInputSchema = buildEnrichedInputSchema;
+const input_analyzer_helpers_1 = require("./input-analyzer-helpers");
+// Re-export everything from helpers so existing consumers are unaffected
+var input_analyzer_helpers_2 = require("./input-analyzer-helpers");
+Object.defineProperty(exports, "classifyArgument", { enumerable: true, get: function () { return input_analyzer_helpers_2.classifyArgument; } });
+/**
+ * Scan ALL steps from an execution and return classified `InputFieldMeta[]`.
+ *
+ * - Iterates every step's arguments and classifies each key
+ * - Deduplicates by key (first occurrence wins)
+ * - Skips wired arguments (they come from step chaining)
+ * - Flattens nested objects that contain dynamic keys
+ * - Caps large defaults (arrays, objects) to prevent hardcoded execution data
+ * - Enhances descriptions using the original prompt where possible
+ */
+function extractSemanticInputs(steps, originalPrompt) {
+    const seen = new Map();
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        if (step.kind !== 'tool')
+            continue;
+        for (const [key, value] of Object.entries(step.arguments)) {
+            if (key === '_iteration')
+                continue;
+            // First occurrence wins
+            if (seen.has(key))
+                continue;
+            const classification = (0, input_analyzer_helpers_1.classifyArgument)(key, value, {
+                stepIndex: i,
+                toolName: step.toolName,
+            });
+            // Skip wired arguments — they come from step chaining
+            if (classification === 'wired')
+                continue;
+            // Flatten nested objects that contain dynamic keys.
+            // e.g., login: { url, username, password } → login_url, username, password
+            if (classification === 'dynamic' && value && typeof value === 'object' && !Array.isArray(value)) {
+                (0, input_analyzer_helpers_1.flattenDynamicObject)(key, value, i, step.toolName, originalPrompt, seen);
+                continue;
+            }
+            let description = (0, input_analyzer_helpers_1.humanize)(key);
+            // Enhance description from original prompt if the value appears in it
+            if (originalPrompt && value !== null && value !== undefined) {
+                const valueStr = String(value);
+                if (valueStr.length > 2 && valueStr.length < 200 && originalPrompt.includes(valueStr)) {
+                    description += ` (from prompt: "${valueStr}")`;
+                }
+            }
+            // Cap defaults for large arrays/objects — they're execution-specific data
+            const cappedDefault = classification === 'fixed' ? (0, input_analyzer_helpers_1.capDefault)(value) : undefined;
+            seen.set(key, {
+                key,
+                type: (0, input_analyzer_helpers_1.inferType)(value),
+                ...(cappedDefault !== undefined ? { default: cappedDefault } : {}),
+                description,
+                classification,
+                source_step_index: i,
+                source_tool: step.toolName,
+            });
+        }
+    }
+    return Array.from(seen.values());
+}
+/**
+ * Build a JSON Schema from classified input field metadata.
+ *
+ * - `dynamic` fields become required properties (no default — user must provide)
+ * - `fixed` fields become optional properties with defaults from the execution
+ */
+function buildEnrichedInputSchema(fieldMeta) {
+    if (fieldMeta.length === 0) {
+        return { type: 'object' };
+    }
+    const properties = {};
+    const required = [];
+    for (const field of fieldMeta) {
+        const prop = {
+            type: field.type,
+            description: field.description,
+        };
+        if (field.classification === 'dynamic') {
+            required.push(field.key);
+        }
+        else if (field.classification === 'fixed' && field.default !== undefined) {
+            prop.default = field.default;
+        }
+        properties[field.key] = prop;
+    }
+    const schema = {
+        type: 'object',
+        properties,
+    };
+    if (required.length > 0) {
+        schema.required = required;
+    }
+    return schema;
+}

package/build/services/yaml-workflow/pattern-detector/array-source.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Array source detection for iteration patterns.
+ *
+ * Locates prior step results that contain arrays matching the
+ * iteration data, using key-overlap and length-match strategies.
+ */
+import type { ExtractedStepLike } from './types';
+/**
+ * Find a prior step whose result contains an array field that is the likely
+ * data source for the iteration. Uses two strategies:
+ *
+ * 1. **Key overlap**: Array items have keys matching the iteration's varying keys
+ *    (e.g., links[].href matches the varying key `url`)
+ * 2. **Length match**: Array length matches the run length (fallback)
+ *
+ * Searches recursively through nested objects, returning a dot-path
+ * (e.g., "links") so the YAML mapping references the correct depth.
+ */
+export declare function findArraySource(steps: ExtractedStepLike[], runStartIndex: number, runLength: number, varyingKeys?: string[]): {
+    stepIndex: number;
+    fieldName: string;
+} | null;

package/build/services/yaml-workflow/pattern-detector/array-source.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Array source detection for iteration patterns.
+ *
+ * Locates prior step results that contain arrays matching the
+ * iteration data, using key-overlap and length-match strategies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findArraySource = findArraySource;
+/**
+ * Find a prior step whose result contains an array field that is the likely
+ * data source for the iteration. Uses two strategies:
+ *
+ * 1. **Key overlap**: Array items have keys matching the iteration's varying keys
+ *    (e.g., links[].href matches the varying key `url`)
+ * 2. **Length match**: Array length matches the run length (fallback)
+ *
+ * Searches recursively through nested objects, returning a dot-path
+ * (e.g., "links") so the YAML mapping references the correct depth.
+ */
+function findArraySource(steps, runStartIndex, runLength, varyingKeys) {
+    // Strategy 1: Find array whose items have keys overlapping with varying keys
+    if (varyingKeys && varyingKeys.length > 0) {
+        for (let i = runStartIndex - 1; i >= 0; i--) {
+            const result = steps[i].result;
+            if (!result || typeof result !== 'object' || Array.isArray(result))
+                continue;
+            const path = findArrayByKeyOverlap(result, varyingKeys, '');
+            if (path) {
+                return { stepIndex: i, fieldName: path };
+            }
+        }
+    }
+    // Strategy 2: Exact length match (fallback)
+    for (let i = runStartIndex - 1; i >= 0; i--) {
+        const result = steps[i].result;
+        if (!result || typeof result !== 'object' || Array.isArray(result))
+            continue;
+        const path = findArrayByLength(result, runLength, '');
+        if (path) {
+            return { stepIndex: i, fieldName: path };
+        }
+    }
+    return null;
+}
+/**
+ * Find an array whose items contain keys that overlap with the iteration's
+ * varying keys. For example, if varying keys are ['url', 'screenshot_path']
+ * and a prior step returned { links: [{ text, href }, ...] }, the 'href'
+ * key semantically matches 'url'. Returns the dot-path to the array.
+ */
+function findArrayByKeyOverlap(obj, varyingKeys, prefix, maxDepth = 3) {
+    if (maxDepth <= 0)
+        return null;
+    for (const [key, value] of Object.entries(obj)) {
+        if (Array.isArray(value) && value.length > 0) {
+            const firstItem = value[0];
+            if (firstItem && typeof firstItem === 'object' && !Array.isArray(firstItem)) {
+                const itemKeys = Object.keys(firstItem);
+                // Check if item keys overlap with varying keys or their semantic equivalents
+                const hasOverlap = varyingKeys.some(vk => itemKeys.includes(vk) ||
+                    itemKeys.some(ik => keysAreSemanticallyRelated(vk, ik)));
+                if (hasOverlap) {
+                    return prefix ? `${prefix}.${key}` : key;
+                }
+            }
+        }
+    }
+    // Recurse into nested objects
+    for (const [key, value] of Object.entries(obj)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const nested = findArrayByKeyOverlap(value, varyingKeys, prefix ? `${prefix}.${key}` : key, maxDepth - 1);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}
+/**
+ * Check if two keys are semantically related.
+ * E.g., 'url' and 'href', 'path' and 'screenshot_path'.
+ */
+function keysAreSemanticallyRelated(a, b) {
+    const la = a.toLowerCase();
+    const lb = b.toLowerCase();
+    // One contains the other
+    if (la.includes(lb) || lb.includes(la))
+        return true;
+    // URL-like equivalences
+    const urlKeys = ['url', 'href', 'link', 'src'];
+    if (urlKeys.includes(la) && urlKeys.includes(lb))
+        return true;
+    // Path-like equivalences
+    const pathKeys = ['path', 'file', 'filepath', 'filename'];
+    if (pathKeys.some(p => la.includes(p)) && pathKeys.some(p => lb.includes(p)))
+        return true;
+    // Name/label equivalences (nav link text often maps to filenames)
+    const nameKeys = ['name', 'text', 'label', 'title'];
+    if (nameKeys.includes(la) && nameKeys.includes(lb))
+        return true;
+    return false;
+}
+/** Find an array by exact length match (fallback strategy). */
+function findArrayByLength(obj, targetLength, prefix, maxDepth = 3) {
+    if (maxDepth <= 0)
+        return null;
+    for (const [key, value] of Object.entries(obj)) {
+        if (Array.isArray(value) && value.length === targetLength) {
+            return prefix ? `${prefix}.${key}` : key;
+        }
+    }
+    for (const [key, value] of Object.entries(obj)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const nested = findArrayByLength(value, targetLength, prefix ? `${prefix}.${key}` : key, maxDepth - 1);
+            if (nested)
+                return nested;
+        }
+    }
+    return null;
+}

package/build/services/yaml-workflow/pattern-detector/collapse.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Iteration pattern collapse and detection.
+ *
+ * Collapses runs of repeated tool calls into single batch steps
+ * with iteration metadata, and detects structural patterns for
+ * informational annotation.
+ */
+import type { ExtractedStepLike, PatternAnnotation } from './types';
+/**
+ * Collapse iteration patterns in the step sequence.
+ *
+ * Detects runs of 3+ consecutive calls to the same tool, analyzes
+ * which arguments vary vs. stay constant, and replaces the run with
+ * a single step that carries _iteration metadata.
+ *
+ * The YAML generator reads this annotation to produce either:
+ * - A batch tool call (if the tool accepts arrays)
+ * - A cycle/hook pattern (if iteration must happen in the graph)
+ *
+ * This function is entirely tool-agnostic -- it knows nothing about
+ * playwright, screenshots, or any specific MCP server.
+ */
+export declare function collapseIterationPatterns(steps: ExtractedStepLike[]): ExtractedStepLike[];
+/**
+ * Detect structural patterns and return annotations (informational).
+ */
+export declare function detectPatterns(steps: ExtractedStepLike[]): PatternAnnotation[];

package/build/services/yaml-workflow/pattern-detector/collapse.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Iteration pattern collapse and detection.
+ *
+ * Collapses runs of repeated tool calls into single batch steps
+ * with iteration metadata, and detects structural patterns for
+ * informational annotation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collapseIterationPatterns = collapseIterationPatterns;
+exports.detectPatterns = detectPatterns;
+const run_detection_1 = require("./run-detection");
+const array_source_1 = require("./array-source");
+/**
+ * Collapse iteration patterns in the step sequence.
+ *
+ * Detects runs of 3+ consecutive calls to the same tool, analyzes
+ * which arguments vary vs. stay constant, and replaces the run with
+ * a single step that carries _iteration metadata.
+ *
+ * The YAML generator reads this annotation to produce either:
+ * - A batch tool call (if the tool accepts arrays)
+ * - A cycle/hook pattern (if iteration must happen in the graph)
+ *
+ * This function is entirely tool-agnostic -- it knows nothing about
+ * playwright, screenshots, or any specific MCP server.
+ */
+function collapseIterationPatterns(steps) {
+    const runs = (0, run_detection_1.findConsecutiveRuns)(steps);
+    if (runs.length === 0)
+        return steps;
+    const result = [];
+    let cursor = 0;
+    for (const run of runs) {
+        // Add all steps before this run
+        while (cursor < run.startIndex) {
+            result.push(steps[cursor]);
+            cursor++;
+        }
+        const { varying, constant, items } = (0, run_detection_1.classifyRunArguments)(run.steps);
+        const arraySource = (0, array_source_1.findArraySource)(steps, run.startIndex, run.steps.length, varying);
+        // Create a collapsed step with iteration metadata
+        const collapsedArgs = {
+            ...constant,
+            _iteration: {
+                tool: run.toolName,
+                server: run.serverId,
+                items,
+                varyingKeys: varying,
+                constantArgs: constant,
+                arraySource: arraySource
+                    ? { stepIndex: arraySource.stepIndex, field: arraySource.fieldName }
+                    : null,
+                count: run.steps.length,
+            },
+        };
+        const lastResult = run.steps[run.steps.length - 1].result;
+        result.push({
+            kind: 'tool',
+            toolName: `${run.toolName}_batch`,
+            arguments: collapsedArgs,
+            result: lastResult,
+            source: run.steps[0].source,
+            mcpServerId: run.serverId,
+        });
+        cursor = run.endIndex;
+    }
+    while (cursor < steps.length) {
+        result.push(steps[cursor]);
+        cursor++;
+    }
+    return result;
+}
+/**
+ * Detect structural patterns and return annotations (informational).
+ */
+function detectPatterns(steps) {
+    const runs = (0, run_detection_1.findConsecutiveRuns)(steps);
+    return runs.map(run => {
+        const { varying, constant } = (0, run_detection_1.classifyRunArguments)(run.steps);
+        const arraySource = (0, array_source_1.findArraySource)(steps, run.startIndex, run.steps.length);
+        return {
+            type: 'iteration',
+            toolName: run.toolName,
+            runStartIndex: run.startIndex,
+            iterationCount: run.steps.length,
+            varyingKeys: varying,
+            constantKeys: Object.keys(constant),
+            arraySource,
+        };
+    });
+}

package/build/services/yaml-workflow/pattern-detector/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pattern detection for YAML workflow generation.
+ *
+ * Analyzes extracted step sequences to detect higher-order structural
+ * patterns -- entirely tool-agnostic. The detector recognizes shapes
+ * in the call flow (iteration, repetition) and collapses them into
+ * richer YAML structures.
+ *
+ * Patterns detected:
+ * 1. **Iteration**: Same tool called N times with systematically varying
+ *    arguments -> collapse into a single step with an array input.
+ * 2. **Constant args**: Arguments that don't change across repeated calls
+ *    -> extract as shared config (not iterated).
+ * 3. **Array source**: When a prior step's result contains an array
+ *    whose length matches the repetition count -> link as the data source.
+ */
+export type { ExtractedStepLike, PatternAnnotation } from './types';
+export { collapseIterationPatterns, detectPatterns } from './collapse';

package/build/services/yaml-workflow/pattern-detector/index.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Pattern detection for YAML workflow generation.
+ *
+ * Analyzes extracted step sequences to detect higher-order structural
+ * patterns -- entirely tool-agnostic. The detector recognizes shapes
+ * in the call flow (iteration, repetition) and collapses them into
+ * richer YAML structures.
+ *
+ * Patterns detected:
+ * 1. **Iteration**: Same tool called N times with systematically varying
+ *    arguments -> collapse into a single step with an array input.
+ * 2. **Constant args**: Arguments that don't change across repeated calls
+ *    -> extract as shared config (not iterated).
+ * 3. **Array source**: When a prior step's result contains an array
+ *    whose length matches the repetition count -> link as the data source.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPatterns = exports.collapseIterationPatterns = void 0;
+var collapse_1 = require("./collapse");
+Object.defineProperty(exports, "collapseIterationPatterns", { enumerable: true, get: function () { return collapse_1.collapseIterationPatterns; } });
+Object.defineProperty(exports, "detectPatterns", { enumerable: true, get: function () { return collapse_1.detectPatterns; } });

package/build/services/yaml-workflow/pattern-detector/run-detection.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Detection and classification of consecutive tool-call runs.
+ *
+ * Finds sequences of 3+ consecutive calls to the same tool and
+ * classifies their arguments as varying, constant, or wired.
+ */
+import type { ExtractedStepLike } from './types';
+/**
+ * Detect runs of consecutive calls to the same tool (same name + same server).
+ */
+export declare function findConsecutiveRuns(steps: ExtractedStepLike[], minLength?: number): Array<{
+    startIndex: number;
+    endIndex: number;
+    toolName: string;
+    serverId: string | undefined;
+    steps: ExtractedStepLike[];
+}>;
+/**
+ * Analyze a run of repeated tool calls and separate arguments into:
+ * - **varying**: keys whose values differ across calls (the iterated data)
+ * - **constant**: keys whose values are identical across all calls (shared config)
+ * - **wired**: inter-step handles -- excluded from both
+ */
+export declare function classifyRunArguments(run: ExtractedStepLike[]): {
+    varying: string[];
+    constant: Record<string, unknown>;
+    items: Array<Record<string, unknown>>;
+};

package/build/services/yaml-workflow/pattern-detector/run-detection.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Detection and classification of consecutive tool-call runs.
+ *
+ * Finds sequences of 3+ consecutive calls to the same tool and
+ * classifies their arguments as varying, constant, or wired.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConsecutiveRuns = findConsecutiveRuns;
+exports.classifyRunArguments = classifyRunArguments;
+const types_1 = require("./types");
+/**
+ * Detect runs of consecutive calls to the same tool (same name + same server).
+ */
+function findConsecutiveRuns(steps, minLength = 3) {
+    const runs = [];
+    let i = 0;
+    while (i < steps.length) {
+        const step = steps[i];
+        if (step.kind !== 'tool') {
+            i++;
+            continue;
+        }
+        let runEnd = i + 1;
+        while (runEnd < steps.length &&
+            steps[runEnd].kind === 'tool' &&
+            steps[runEnd].toolName === step.toolName &&
+            steps[runEnd].mcpServerId === step.mcpServerId) {
+            runEnd++;
+        }
+        if (runEnd - i >= minLength) {
+            runs.push({
+                startIndex: i,
+                endIndex: runEnd,
+                toolName: step.toolName,
+                serverId: step.mcpServerId,
+                steps: steps.slice(i, runEnd),
+            });
+        }
+        i = Math.max(i + 1, runEnd);
+    }
+    return runs;
+}
+/**
+ * Analyze a run of repeated tool calls and separate arguments into:
+ * - **varying**: keys whose values differ across calls (the iterated data)
+ * - **constant**: keys whose values are identical across all calls (shared config)
+ * - **wired**: inter-step handles -- excluded from both
+ */
+function classifyRunArguments(run) {
+    const allKeys = new Set();
+    for (const step of run) {
+        for (const key of Object.keys(step.arguments)) {
+            allKeys.add(key);
+        }
+    }
+    const varying = [];
+    const constant = {};
+    for (const key of allKeys) {
+        if (types_1.WIRED_KEYS.has(key))
+            continue;
+        const values = run.map(s => JSON.stringify(s.arguments[key] ?? null));
+        const allSame = values.every(v => v === values[0]);
+        if (allSame) {
+            constant[key] = run[0].arguments[key];
+        }
+        else {
+            varying.push(key);
+        }
+    }
+    const items = run.map(s => {
+        const item = {};
+        for (const key of varying) {
+            if (s.arguments[key] !== undefined) {
+                item[key] = s.arguments[key];
+            }
+        }
+        return item;
+    });
+    return { varying, constant, items };
+}

package/build/services/yaml-workflow/pattern-detector/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared types and constants for pattern detection.
+ */
+export interface ExtractedStepLike {
+    kind: 'tool' | 'llm';
+    toolName: string;
+    arguments: Record<string, unknown>;
+    result: unknown;
+    source: string;
+    mcpServerId?: string;
+    promptMessages?: Array<{
+        role: string;
+        content: string;
+    }>;
+}
+/** Keys that represent inter-step handles, not meaningful iteration data. */
+export declare const WIRED_KEYS: Set<string>;
+export interface PatternAnnotation {
+    type: 'iteration';
+    toolName: string;
+    runStartIndex: number;
+    iterationCount: number;
+    varyingKeys: string[];
+    constantKeys: string[];
+    arraySource: {
+        stepIndex: number;
+        fieldName: string;
+    } | null;
+}

package/build/services/yaml-workflow/pattern-detector/types.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Shared types and constants for pattern detection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WIRED_KEYS = void 0;
+/** Keys that represent inter-step handles, not meaningful iteration data. */
+exports.WIRED_KEYS = new Set(['page_id', '_handle', 'session_id']);

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

@@ -0,0 +1,11 @@
+/**
+ * Analyze stage: run pattern detection and naive input classification.
+ *
+ * Wraps the existing pattern-detector and input-analyzer modules,
+ * populating the pipeline context with their results.
+ */
+import type { PipelineContext } from '../types';
+/**
+ * Analyze pipeline stage: detect patterns and classify inputs.
+ */
+export declare function analyze(ctx: PipelineContext): Promise<PipelineContext>;

package/build/services/yaml-workflow/pipeline/analyze.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Analyze stage: run pattern detection and naive input classification.
+ *
+ * Wraps the existing pattern-detector and input-analyzer modules,
+ * populating the pipeline context with their results.
+ */
+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.analyze = analyze;
+const pattern_detector_1 = require("../pattern-detector");
+const input_analyzer_1 = require("../input-analyzer");
+/**
+ * Analyze pipeline stage: detect patterns and classify inputs.
+ */
+async function analyze(ctx) {
+    // Detect structural patterns (informational — passed to compile stage)
+    ctx.patternAnnotations = (0, pattern_detector_1.detectPatterns)(ctx.rawSteps);
+    // Collapse iteration patterns: N consecutive calls → single step with _iteration metadata
+    ctx.collapsedSteps = (0, pattern_detector_1.collapseIterationPatterns)(ctx.rawSteps);
+    // Advisory: consecutive steps from the same server
+    const consecutiveSameServer = ctx.collapsedSteps.filter((s, i) => s.kind === 'tool' && s.mcpServerId &&
+        i > 0 && ctx.collapsedSteps[i - 1].mcpServerId === s.mcpServerId);
+    if (consecutiveSameServer.length > 0) {
+        const { loggerRegistry } = await Promise.resolve().then(() => __importStar(require('../../logger')));
+        const serverIds = [...new Set(consecutiveSameServer.map(s => s.mcpServerId))];
+        loggerRegistry.info(`[yaml-workflow] hint: ${consecutiveSameServer.length + 1} consecutive same-server steps detected (${serverIds.join(', ')}) — pattern detector may collapse these`);
+    }
+    // Naive input classification: classify all step arguments as dynamic/fixed/wired
+    ctx.naiveInputs = (0, input_analyzer_1.extractSemanticInputs)(ctx.collapsedSteps, ctx.originalPrompt);
+    return ctx;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * DAG construction helpers for the build pipeline stage.
+ *
+ * Encapsulates the mutable state of DAG assembly (activities, transitions,
+ * manifest) behind semantic operations so the main build() function reads
+ * as a high-level pipeline.
+ */
+import type { ExtractedStep, EnhancedCompilationPlan, IterationSpec } from '../../types';
+import type { DagBuilder } from '../../types';
+/** Create the DAG with its trigger activity. */
+export declare function initializeDag(prefix: string, graphTopic: string, inputSchema: Record<string, unknown>): DagBuilder;
+/** Append an iteration pattern (hook → worker → cycle → done) to the DAG. */
+export declare function appendIterationStep(dag: DagBuilder, iterSpec: IterationSpec, prefix: string, graphTopic: string, idx: number, step: ExtractedStep, triggerInputKeys: Set<string>, steps: ExtractedStep[], sessionFields: string[], plan: EnhancedCompilationPlan | null): void;
+/** Append a normal (non-iteration) step activity to the DAG. */
+export declare function appendNormalStep(dag: DagBuilder, idx: number, step: ExtractedStep, prefix: string, graphTopic: string, plan: EnhancedCompilationPlan | null, steps: ExtractedStep[], triggerInputKeys: Set<string>, collapsedToCoreIndex: Map<number, number>): void;
+/**
+ * Append a signal step pair (escalation worker + hook) to the DAG.
+ *
+ * The escalation worker creates the escalation via the human-queue MCP tool.
+ * The hook pauses until the escalation is resolved and a signal arrives.
+ * A hooks section entry routes the external signal to the waiting hook.
+ */
+export declare function appendSignalStep(dag: DagBuilder, idx: number, step: ExtractedStep, prefix: string, graphTopic: string, plan: EnhancedCompilationPlan | null, steps: ExtractedStep[], triggerInputKeys: Set<string>, collapsedToCoreIndex: Map<number, number>): void;
+/** Assemble the DAG into a HotMesh YAML document. */
+export declare function serializeToYaml(appId: string, graphTopic: string, inputSchema: Record<string, unknown>, outputSchema: Record<string, unknown>, dag: DagBuilder): string;