@hotmeshio/long-tail 0.1.14 → 0.1.16

package/build/services/yaml-workflow/builder-regenerate.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Regenerate a Plan Build workflow from its original prompt + compilation feedback.
+ *
+ * Reuses the builder's LLM call and prompt structure without spawning a full
+ * durable workflow. This is the fast path for "Recompile Pipeline" on Plan Build
+ * workflows that don't have an execution trace.
+ */
+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.rebuildFromPrompt = rebuildFromPrompt;
+const llm_1 = require("../llm");
+const defaults_1 = require("../../modules/defaults");
+const logger_1 = require("../../lib/logger");
+const BUILDER_MAX_TOKENS = 8192;
+/**
+ * Rebuild a YAML workflow from a prompt with optional feedback on the prior attempt.
+ */
+async function rebuildFromPrompt(options) {
+    // Load the builder's system prompt and tool inventory
+    const { loadBuilderTools } = await Promise.resolve().then(() => __importStar(require('../../system/workflows/mcp-workflow-builder/activities')));
+    const { BUILDER_SYSTEM_PROMPT, REFINE_PROMPT } = await Promise.resolve().then(() => __importStar(require('../../system/workflows/mcp-workflow-builder/prompts')));
+    const raw = await loadBuilderTools();
+    const serverSection = [
+        raw.strategy ? `${raw.strategy}\n` : '',
+        `## Available MCP Servers & Tools\n\n${raw.inventory}`,
+    ].filter(Boolean).join('\n');
+    const messages = [
+        { role: 'system', content: BUILDER_SYSTEM_PROMPT(serverSection) },
+    ];
+    if (options.feedback && options.priorYaml) {
+        messages.push({ role: 'user', content: `Build a workflow for: ${options.prompt}` });
+        messages.push({
+            role: 'assistant',
+            content: `Here is the prior YAML that needs fixing:\n\`\`\`yaml\n${options.priorYaml.slice(0, 3000)}\n\`\`\``,
+        });
+        messages.push({
+            role: 'user',
+            content: `${REFINE_PROMPT}\n\nExecution feedback:\n${options.feedback}`,
+        });
+    }
+    else {
+        messages.push({ role: 'user', content: `Build a workflow for: ${options.prompt}` });
+    }
+    // Call LLM with retry
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const t0 = Date.now();
+        const response = await (0, llm_1.callLLM)({
+            model: defaults_1.LLM_MODEL_PRIMARY,
+            messages,
+            temperature: 0,
+            max_tokens: BUILDER_MAX_TOKENS,
+        });
+        logger_1.loggerRegistry.info(`[builder-regenerate] attempt=${attempt + 1} ${Date.now() - t0}ms | in=${response.usage?.prompt_tokens} out=${response.usage?.completion_tokens}`);
+        const content = response.content || '';
+        const cleaned = content.replace(/^```(?:json)?\s*/m, '').replace(/\s*```\s*$/m, '');
+        try {
+            const parsed = JSON.parse(cleaned);
+            if (!parsed.yaml)
+                throw new Error('Missing yaml in response');
+            return {
+                yaml: parsed.yaml,
+                inputSchema: parsed.input_schema || {},
+                outputSchema: parsed.output_schema || {},
+                activityManifest: parsed.activity_manifest || [],
+                tags: parsed.tags || [],
+            };
+        }
+        catch (err) {
+            logger_1.loggerRegistry.warn(`[builder-regenerate] parse failed (attempt ${attempt + 1}): ${err.message}`);
+            messages.push({ role: 'assistant', content });
+            messages.push({
+                role: 'user',
+                content: `Your response was not valid JSON. Return ONLY a JSON object with "yaml", "input_schema", "output_schema", "activity_manifest", and "tags" fields.`,
+            });
+        }
+    }
+    throw new Error('Failed to regenerate YAML after 3 attempts');
+}

package/build/services/yaml-workflow/db-versions.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Version history and cron scheduling DB operations for yaml-workflows.
+ *
+ * Extracted from db.ts to keep each file under 300 lines.
+ */
+import type { LTYamlWorkflowRecord, LTYamlWorkflowVersionRecord, ActivityManifestEntry } from '../../types/yaml-workflow';
+export declare function createVersionSnapshot(workflowId: string, version: number, yamlContent: string, activityManifest: ActivityManifestEntry[] | unknown, inputSchema: Record<string, unknown> | unknown, outputSchema: Record<string, unknown> | unknown, inputFieldMeta?: unknown, changeSummary?: string): Promise<LTYamlWorkflowVersionRecord>;
+export declare function getVersionHistory(workflowId: string, limit?: number, offset?: number): Promise<{
+    versions: LTYamlWorkflowVersionRecord[];
+    total: number;
+}>;
+export declare function getVersionSnapshot(workflowId: string, version: number): Promise<LTYamlWorkflowVersionRecord | null>;
+export declare function markContentDeployed(workflowId: string): Promise<void>;
+export declare function markAppIdContentDeployed(appId: string): Promise<void>;
+export declare function updateCronSchedule(id: string, cronSchedule: string, cronEnvelope: Record<string, unknown> | null, executeAs: string | null): Promise<LTYamlWorkflowRecord | null>;
+export declare function clearCronSchedule(id: string): Promise<LTYamlWorkflowRecord | null>;
+export declare function getCronScheduledWorkflows(): Promise<LTYamlWorkflowRecord[]>;

package/build/services/yaml-workflow/db-versions.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Version history and cron scheduling DB operations for yaml-workflows.
+ *
+ * Extracted from db.ts to keep each file under 300 lines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVersionSnapshot = createVersionSnapshot;
+exports.getVersionHistory = getVersionHistory;
+exports.getVersionSnapshot = getVersionSnapshot;
+exports.markContentDeployed = markContentDeployed;
+exports.markAppIdContentDeployed = markAppIdContentDeployed;
+exports.updateCronSchedule = updateCronSchedule;
+exports.clearCronSchedule = clearCronSchedule;
+exports.getCronScheduledWorkflows = getCronScheduledWorkflows;
+const db_1 = require("../../lib/db");
+const defaults_1 = require("../../modules/defaults");
+const sql_1 = require("./sql");
+// -- Version history ---------------------------------------------------------
+async function createVersionSnapshot(workflowId, version, yamlContent, activityManifest, inputSchema, outputSchema, inputFieldMeta, changeSummary) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.CREATE_VERSION_SNAPSHOT, [
+        workflowId, version, yamlContent,
+        JSON.stringify(activityManifest),
+        JSON.stringify(inputSchema),
+        JSON.stringify(outputSchema),
+        JSON.stringify(inputFieldMeta || []),
+        changeSummary || null,
+    ]);
+    return rows[0];
+}
+async function getVersionHistory(workflowId, limit = defaults_1.YAML_VERSION_LIMIT, offset = 0) {
+    const pool = (0, db_1.getPool)();
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(sql_1.COUNT_VERSIONS, [workflowId]),
+        pool.query(sql_1.LIST_VERSIONS, [workflowId, limit, offset]),
+    ]);
+    return {
+        versions: dataResult.rows,
+        total: parseInt(countResult.rows[0].count, 10),
+    };
+}
+async function getVersionSnapshot(workflowId, version) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_VERSION_SNAPSHOT, [workflowId, version]);
+    return rows[0] || null;
+}
+async function markContentDeployed(workflowId) {
+    const pool = (0, db_1.getPool)();
+    await pool.query(sql_1.MARK_CONTENT_DEPLOYED, [workflowId]);
+}
+async function markAppIdContentDeployed(appId) {
+    const pool = (0, db_1.getPool)();
+    await pool.query(sql_1.MARK_APP_ID_CONTENT_DEPLOYED, [appId]);
+}
+// -- Cron scheduling ---------------------------------------------------------
+async function updateCronSchedule(id, cronSchedule, cronEnvelope, executeAs) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.UPDATE_CRON_SCHEDULE, [
+        id,
+        cronSchedule,
+        cronEnvelope ? JSON.stringify(cronEnvelope) : null,
+        executeAs,
+    ]);
+    return rows[0] || null;
+}
+async function clearCronSchedule(id) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.CLEAR_CRON_SCHEDULE, [id]);
+    return rows[0] || null;
+}
+async function getCronScheduledWorkflows() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_CRON_SCHEDULED_WORKFLOWS);
+    return rows;
+}

package/build/services/yaml-workflow/db.d.ts

@@ -1,6 +1,7 @@
-import type { LTYamlWorkflowRecord, LTYamlWorkflowVersionRecord, ActivityManifestEntry } from '../../types/yaml-workflow';
+import type { LTYamlWorkflowRecord } from '../../types/yaml-workflow';
 import type { CreateYamlWorkflowInput } from './types';
 export { parseVersionFromYaml, updateYamlWorkflowStatus, listYamlWorkflows, findYamlWorkflowsByTags, } from './db-utils';
+export { createVersionSnapshot, getVersionHistory, getVersionSnapshot, markContentDeployed, markAppIdContentDeployed, updateCronSchedule, clearCronSchedule, getCronScheduledWorkflows, } from './db-versions';
 /**
  * Check whether a graph_topic is already in use by a non-archived workflow
  * in the same namespace. Returns the conflicting workflow name, or null.
@@ -30,18 +31,7 @@ export declare function listYamlWorkflowsByAppId(appId: string): Promise<LTYamlW
  *
  * A new namespace with no workflows returns '1'.
  * An existing namespace with one active tool at v1 returns '2' when a
- * second tool is added — even though that second tool is "version 1" of itself.
+ * second tool is added -- even though that second tool is "version 1" of itself.
  */
 export declare function getNextAppVersion(appId: string): Promise<string>;
 export declare function getDistinctAppIds(): Promise<string[]>;
-export declare function createVersionSnapshot(workflowId: string, version: number, yamlContent: string, activityManifest: ActivityManifestEntry[] | unknown, inputSchema: Record<string, unknown> | unknown, outputSchema: Record<string, unknown> | unknown, inputFieldMeta?: unknown, changeSummary?: string): Promise<LTYamlWorkflowVersionRecord>;
-export declare function getVersionHistory(workflowId: string, limit?: number, offset?: number): Promise<{
-    versions: LTYamlWorkflowVersionRecord[];
-    total: number;
-}>;
-export declare function getVersionSnapshot(workflowId: string, version: number): Promise<LTYamlWorkflowVersionRecord | null>;
-export declare function markContentDeployed(workflowId: string): Promise<void>;
-export declare function markAppIdContentDeployed(appId: string): Promise<void>;
-export declare function updateCronSchedule(id: string, cronSchedule: string, cronEnvelope: Record<string, unknown> | null, executeAs: string | null): Promise<LTYamlWorkflowRecord | null>;
-export declare function clearCronSchedule(id: string): Promise<LTYamlWorkflowRecord | null>;
-export declare function getCronScheduledWorkflows(): Promise<LTYamlWorkflowRecord[]>;

package/build/services/yaml-workflow/db.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findYamlWorkflowsByTags = exports.listYamlWorkflows = exports.updateYamlWorkflowStatus = exports.parseVersionFromYaml = void 0;
+exports.getCronScheduledWorkflows = exports.clearCronSchedule = exports.updateCronSchedule = exports.markAppIdContentDeployed = exports.markContentDeployed = exports.getVersionSnapshot = exports.getVersionHistory = exports.createVersionSnapshot = exports.findYamlWorkflowsByTags = exports.listYamlWorkflows = exports.updateYamlWorkflowStatus = exports.parseVersionFromYaml = void 0;
 exports.checkTopicConflict = checkTopicConflict;
 exports.createYamlWorkflow = createYamlWorkflow;
 exports.getYamlWorkflow = getYamlWorkflow;
@@ -13,24 +13,26 @@ exports.getActiveYamlWorkflows = getActiveYamlWorkflows;
 exports.listYamlWorkflowsByAppId = listYamlWorkflowsByAppId;
 exports.getNextAppVersion = getNextAppVersion;
 exports.getDistinctAppIds = getDistinctAppIds;
-exports.createVersionSnapshot = createVersionSnapshot;
-exports.getVersionHistory = getVersionHistory;
-exports.getVersionSnapshot = getVersionSnapshot;
-exports.markContentDeployed = markContentDeployed;
-exports.markAppIdContentDeployed = markAppIdContentDeployed;
-exports.updateCronSchedule = updateCronSchedule;
-exports.clearCronSchedule = clearCronSchedule;
-exports.getCronScheduledWorkflows = getCronScheduledWorkflows;
 const db_1 = require("../../lib/db");
-const defaults_1 = require("../../modules/defaults");
 const sql_1 = require("./sql");
 const db_utils_1 = require("./db-utils");
+const db_versions_1 = require("./db-versions");
 // Re-export functions from db-utils
 var db_utils_2 = require("./db-utils");
 Object.defineProperty(exports, "parseVersionFromYaml", { enumerable: true, get: function () { return db_utils_2.parseVersionFromYaml; } });
 Object.defineProperty(exports, "updateYamlWorkflowStatus", { enumerable: true, get: function () { return db_utils_2.updateYamlWorkflowStatus; } });
 Object.defineProperty(exports, "listYamlWorkflows", { enumerable: true, get: function () { return db_utils_2.listYamlWorkflows; } });
 Object.defineProperty(exports, "findYamlWorkflowsByTags", { enumerable: true, get: function () { return db_utils_2.findYamlWorkflowsByTags; } });
+// Re-export version history and cron scheduling from db-versions
+var db_versions_2 = require("./db-versions");
+Object.defineProperty(exports, "createVersionSnapshot", { enumerable: true, get: function () { return db_versions_2.createVersionSnapshot; } });
+Object.defineProperty(exports, "getVersionHistory", { enumerable: true, get: function () { return db_versions_2.getVersionHistory; } });
+Object.defineProperty(exports, "getVersionSnapshot", { enumerable: true, get: function () { return db_versions_2.getVersionSnapshot; } });
+Object.defineProperty(exports, "markContentDeployed", { enumerable: true, get: function () { return db_versions_2.markContentDeployed; } });
+Object.defineProperty(exports, "markAppIdContentDeployed", { enumerable: true, get: function () { return db_versions_2.markAppIdContentDeployed; } });
+Object.defineProperty(exports, "updateCronSchedule", { enumerable: true, get: function () { return db_versions_2.updateCronSchedule; } });
+Object.defineProperty(exports, "clearCronSchedule", { enumerable: true, get: function () { return db_versions_2.clearCronSchedule; } });
+Object.defineProperty(exports, "getCronScheduledWorkflows", { enumerable: true, get: function () { return db_versions_2.getCronScheduledWorkflows; } });
 /**
  * Check whether a graph_topic is already in use by a non-archived workflow
  * in the same namespace. Returns the conflicting workflow name, or null.
@@ -68,7 +70,7 @@ async function createYamlWorkflow(input) {
         input.set_build_order ?? null,
     ]);
     const record = rows[0];
-    await createVersionSnapshot(record.id, 1, record.yaml_content, input.activity_manifest || [], input.input_schema || {}, input.output_schema || {}, input.input_field_meta || [], 'Initial version');
+    await (0, db_versions_1.createVersionSnapshot)(record.id, 1, record.yaml_content, input.activity_manifest || [], input.input_schema || {}, input.output_schema || {}, input.input_field_meta || [], 'Initial version');
     return record;
 }
 async function getYamlWorkflow(id) {
@@ -145,7 +147,7 @@ async function updateYamlWorkflow(id, updates) {
     const { rows } = await pool.query(`UPDATE lt_yaml_workflows SET ${sets.join(', ')} WHERE id = $${idx} RETURNING *`, values);
     const record = rows[0] || null;
     if (record && yamlChanging) {
-        await createVersionSnapshot(record.id, record.content_version, record.yaml_content, record.activity_manifest, record.input_schema, record.output_schema, record.input_field_meta);
+        await (0, db_versions_1.createVersionSnapshot)(record.id, record.content_version, record.yaml_content, record.activity_manifest, record.input_schema, record.output_schema, record.input_field_meta);
     }
     return record;
 }
@@ -182,7 +184,7 @@ async function listYamlWorkflowsByAppId(appId) {
  *
  * A new namespace with no workflows returns '1'.
  * An existing namespace with one active tool at v1 returns '2' when a
- * second tool is added — even though that second tool is "version 1" of itself.
+ * second tool is added -- even though that second tool is "version 1" of itself.
  */
 async function getNextAppVersion(appId) {
     const pool = (0, db_1.getPool)();
@@ -195,61 +197,3 @@ async function getDistinctAppIds() {
     const { rows } = await pool.query(sql_1.GET_DISTINCT_APP_IDS);
     return rows.map((r) => r.app_id);
 }
-// -- Version history ---------------------------------------------------------
-async function createVersionSnapshot(workflowId, version, yamlContent, activityManifest, inputSchema, outputSchema, inputFieldMeta, changeSummary) {
-    const pool = (0, db_1.getPool)();
-    const { rows } = await pool.query(sql_1.CREATE_VERSION_SNAPSHOT, [
-        workflowId, version, yamlContent,
-        JSON.stringify(activityManifest),
-        JSON.stringify(inputSchema),
-        JSON.stringify(outputSchema),
-        JSON.stringify(inputFieldMeta || []),
-        changeSummary || null,
-    ]);
-    return rows[0];
-}
-async function getVersionHistory(workflowId, limit = defaults_1.YAML_VERSION_LIMIT, offset = 0) {
-    const pool = (0, db_1.getPool)();
-    const [countResult, dataResult] = await Promise.all([
-        pool.query(sql_1.COUNT_VERSIONS, [workflowId]),
-        pool.query(sql_1.LIST_VERSIONS, [workflowId, limit, offset]),
-    ]);
-    return {
-        versions: dataResult.rows,
-        total: parseInt(countResult.rows[0].count, 10),
-    };
-}
-async function getVersionSnapshot(workflowId, version) {
-    const pool = (0, db_1.getPool)();
-    const { rows } = await pool.query(sql_1.GET_VERSION_SNAPSHOT, [workflowId, version]);
-    return rows[0] || null;
-}
-async function markContentDeployed(workflowId) {
-    const pool = (0, db_1.getPool)();
-    await pool.query(sql_1.MARK_CONTENT_DEPLOYED, [workflowId]);
-}
-async function markAppIdContentDeployed(appId) {
-    const pool = (0, db_1.getPool)();
-    await pool.query(sql_1.MARK_APP_ID_CONTENT_DEPLOYED, [appId]);
-}
-// -- Cron scheduling ---------------------------------------------------------
-async function updateCronSchedule(id, cronSchedule, cronEnvelope, executeAs) {
-    const pool = (0, db_1.getPool)();
-    const { rows } = await pool.query(sql_1.UPDATE_CRON_SCHEDULE, [
-        id,
-        cronSchedule,
-        cronEnvelope ? JSON.stringify(cronEnvelope) : null,
-        executeAs,
-    ]);
-    return rows[0] || null;
-}
-async function clearCronSchedule(id) {
-    const pool = (0, db_1.getPool)();
-    const { rows } = await pool.query(sql_1.CLEAR_CRON_SCHEDULE, [id]);
-    return rows[0] || null;
-}
-async function getCronScheduledWorkflows() {
-    const pool = (0, db_1.getPool)();
-    const { rows } = await pool.query(sql_1.GET_CRON_SCHEDULED_WORKFLOWS);
-    return rows;
-}

package/build/services/yaml-workflow/deployer-helpers.js

@@ -56,27 +56,28 @@ async function buildMergedYaml(appId, version) {
             allGraphs.push(...parsed.app.graphs);
         }
     }
-    // Pre-validate: check for duplicate activity IDs across all graphs
-    const activityIds = new Map(); // id -> graph subscribes topic
-    const duplicates = [];
+    // Resolve duplicate activity IDs across graphs by rewriting suffixes
+    const activityIds = new Set();
     for (const graph of allGraphs) {
         const g = graph;
-        const topic = g.subscribes || 'unknown';
-        if (g.activities) {
-            for (const id of Object.keys(g.activities)) {
-                if (activityIds.has(id)) {
-                    duplicates.push(`"${id}" in both "${activityIds.get(id)}" and "${topic}"`);
-                }
-                else {
-                    activityIds.set(id, topic);
-                }
+        if (!g.activities)
+            continue;
+        // Check if any activity IDs collide with previously seen IDs
+        const ids = Object.keys(g.activities);
+        const hasCollision = ids.some((id) => activityIds.has(id));
+        if (hasCollision) {
+            // Rewrite all activity IDs in this graph with a unique suffix
+            const newSuffix = Math.random().toString(36).slice(2, 6);
+            const oldSuffix = extractSuffix(ids[0]);
+            if (oldSuffix) {
+                rewriteGraphSuffix(g, oldSuffix, newSuffix);
+                logger_1.loggerRegistry.info(`[yaml-workflow] rewrote activity suffix ${oldSuffix}→${newSuffix} in "${g.subscribes}" to resolve collision`);
             }
         }
-    }
-    if (duplicates.length > 0) {
-        const msg = `Duplicate activity IDs across graphs in app "${appId}": ${duplicates.join('; ')}`;
-        logger_1.loggerRegistry.error(`[yaml-workflow] ${msg}`);
-        throw new Error(msg);
+        // Register all (possibly rewritten) activity IDs
+        for (const id of Object.keys(g.activities)) {
+            activityIds.add(id);
+        }
     }
     const merged = {
         app: {
@@ -87,6 +88,36 @@ async function buildMergedYaml(appId, version) {
     };
     return yaml.dump(merged, { lineWidth: defaults_1.YAML_LINE_WIDTH, noRefs: true, sortKeys: false });
 }
+/** Extract the 4-char suffix from an activity ID like "trigger_x8kf" */
+function extractSuffix(activityId) {
+    const match = activityId.match(/_([a-z0-9]{4})$/);
+    return match ? match[1] : null;
+}
+/** Rewrite all activity ID suffixes in a graph definition */
+function rewriteGraphSuffix(graph, oldSuffix, newSuffix) {
+    const suffixPattern = new RegExp(`_${oldSuffix}\\b`, 'g');
+    const replace = (obj) => {
+        if (typeof obj === 'string')
+            return obj.replace(suffixPattern, `_${newSuffix}`);
+        if (Array.isArray(obj))
+            return obj.map(replace);
+        if (obj && typeof obj === 'object') {
+            const result = {};
+            for (const [k, v] of Object.entries(obj)) {
+                const newKey = k.replace(suffixPattern, `_${newSuffix}`);
+                result[newKey] = replace(v);
+            }
+            return result;
+        }
+        return obj;
+    };
+    if (graph.activities)
+        graph.activities = replace(graph.activities);
+    if (graph.transitions)
+        graph.transitions = replace(graph.transitions);
+    if (graph.hooks)
+        graph.hooks = replace(graph.hooks);
+}
 /**
  * Re-run the compilation pipeline for the most recently compiled workflow
  * in the app, feeding the deployment error as context so the LLM can

package/build/services/yaml-workflow/durable-compiler/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Durable-to-YAML compiler — converts procedural TypeScript workflows to YAML DAGs.
+ *
+ * This is "Path 3" for YAML DAG creation: static compilation from durable source
+ * code without executing the workflow. The LLM translates the procedural orchestration
+ * into an equivalent HotMesh YAML DAG that runs without replay overhead.
+ *
+ * Pipeline:
+ *   1. Read source (file or inline string)
+ *   2. Optionally resolve and read the activities module
+ *   3. Extract metadata (activity names, primitives, control flow)
+ *   4. Build LLM messages (system prompt + source + metadata)
+ *   5. Call LLM (temperature 0, retry on parse failure)
+ *   6. Fix known @pipe anti-patterns
+ *   7. Return result compatible with existing YAML workflow CRUD
+ */
+import type { CompileDurableOptions, CompileDurableResult } from './types';
+export type { CompileDurableOptions, CompileDurableResult } from './types';
+/**
+ * Compile a durable TypeScript workflow into a HotMesh YAML DAG.
+ */
+export declare function compileDurableToYaml(options: CompileDurableOptions): Promise<CompileDurableResult>;

package/build/services/yaml-workflow/durable-compiler/index.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Durable-to-YAML compiler — converts procedural TypeScript workflows to YAML DAGs.
+ *
+ * This is "Path 3" for YAML DAG creation: static compilation from durable source
+ * code without executing the workflow. The LLM translates the procedural orchestration
+ * into an equivalent HotMesh YAML DAG that runs without replay overhead.
+ *
+ * Pipeline:
+ *   1. Read source (file or inline string)
+ *   2. Optionally resolve and read the activities module
+ *   3. Extract metadata (activity names, primitives, control flow)
+ *   4. Build LLM messages (system prompt + source + metadata)
+ *   5. Call LLM (temperature 0, retry on parse failure)
+ *   6. Fix known @pipe anti-patterns
+ *   7. Return result compatible with existing YAML workflow CRUD
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileDurableToYaml = compileDurableToYaml;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const llm_1 = require("../../llm");
+const defaults_1 = require("../../../modules/defaults");
+const logger_1 = require("../../../lib/logger");
+const utils_1 = require("../../../modules/utils");
+const parser_1 = require("./parser");
+const prompts_1 = require("./prompts");
+const MAX_COMPILE_ATTEMPTS = 3;
+const COMPILER_MAX_TOKENS = 8192;
+/**
+ * Compile a durable TypeScript workflow into a HotMesh YAML DAG.
+ */
+async function compileDurableToYaml(options) {
+    const appId = options.appId || 'longtail';
+    const graphTopic = options.subscribes || (0, utils_1.sanitizeToolName)(options.name);
+    // 1. Read source
+    const source = options.isFilePath
+        ? await (0, promises_1.readFile)(options.source, 'utf-8')
+        : options.source;
+    // 2. Extract metadata
+    const metadata = (0, parser_1.extractDurableMetadata)(source, options.workflowName);
+    // 3. Optionally resolve and read activities module
+    let activitiesSource;
+    if (options.isFilePath && metadata.activityImports.length > 0) {
+        activitiesSource = await resolveActivitiesSource(options.source, metadata.activityImports);
+    }
+    // 4. Load activity types reference
+    const activityTypesRef = await loadActivityTypesReference();
+    // 5. Build LLM messages
+    const messages = [
+        {
+            role: 'system',
+            content: (0, prompts_1.DURABLE_COMPILER_SYSTEM_PROMPT)(activityTypesRef, metadata),
+        },
+        {
+            role: 'user',
+            content: (0, prompts_1.buildUserMessage)(source, metadata, activitiesSource),
+        },
+    ];
+    // 6. Call LLM with retry on parse failure
+    let parsed = null;
+    let lastError = '';
+    for (let attempt = 1; attempt <= MAX_COMPILE_ATTEMPTS; attempt++) {
+        const t0 = Date.now();
+        const response = await (0, llm_1.callLLM)({
+            model: defaults_1.LLM_MODEL_PRIMARY,
+            messages,
+            temperature: 0,
+            max_tokens: COMPILER_MAX_TOKENS,
+        });
+        logger_1.loggerRegistry.info(`[durable-compiler] attempt=${attempt} ${Date.now() - t0}ms | in=${response.usage?.prompt_tokens} out=${response.usage?.completion_tokens}`);
+        const content = response.content || '';
+        try {
+            parsed = parseJsonResponse(content);
+            break;
+        }
+        catch (err) {
+            lastError = err.message;
+            logger_1.loggerRegistry.warn(`[durable-compiler] JSON parse failed (attempt ${attempt}): ${lastError}`);
+            // Feed error back for retry
+            messages.push({ role: 'assistant', content });
+            messages.push({
+                role: 'user',
+                content: `Your response was not valid JSON. Error: ${lastError}\n\nPlease return ONLY the JSON object with no markdown fences or surrounding text.`,
+            });
+        }
+    }
+    if (!parsed) {
+        throw new Error(`[durable-compiler] Failed to get valid JSON after ${MAX_COMPILE_ATTEMPTS} attempts. Last error: ${lastError}`);
+    }
+    // 7. Fix known @pipe anti-patterns
+    let yaml = fixPipePatterns(parsed.yaml || '');
+    // 7b. Rewrite app.id to match the target appId
+    yaml = yaml.replace(/^(\s*id:\s*)(.+)$/m, `$1${appId}`);
+    // 8. Extract the actual subscribes topic from the YAML (LLM may choose its own)
+    const subscribesMatch = yaml.match(/subscribes:\s*(.+)/);
+    const actualTopic = subscribesMatch
+        ? subscribesMatch[1].trim().replace(/^['"]|['"]$/g, '')
+        : graphTopic;
+    // 9. Build result
+    return {
+        yaml,
+        inputSchema: parsed.input_schema || {},
+        outputSchema: parsed.output_schema || {},
+        activityManifest: parsed.activity_manifest || [],
+        graphTopic: actualTopic,
+        appId,
+        tags: parsed.tags || ['durable'],
+        inputFieldMeta: [],
+        category: 'durable',
+    };
+}
+/**
+ * Parse a JSON response from the LLM, stripping markdown fences if present.
+ */
+function parseJsonResponse(content) {
+    let cleaned = content.trim();
+    // Strip markdown code fences
+    if (cleaned.startsWith('```')) {
+        cleaned = cleaned.replace(/^```(?:json)?\s*\n?/, '').replace(/\n?\s*```$/, '');
+    }
+    return JSON.parse(cleaned);
+}
+/**
+ * Fix known @pipe anti-patterns that LLMs consistently produce.
+ * Same fixes as the workflow-builder.
+ */
+function fixPipePatterns(yaml) {
+    // Fix: ['{@date.toISOString}'] then [0, 10] then ['{@string.substring}']
+    yaml = yaml.replace(/(\['\{@date\.toISOString\}'\])\s*\n(\s*)- \[0, 10\]\s*\n(\s*)- \['\{@string\.substring\}'\]/g, "['{@date.toISOString}', 0, 10]\n$2- ['{@string.substring}']");
+    return yaml;
+}
+/**
+ * Load the full activity-types.md reference file.
+ */
+async function loadActivityTypesReference() {
+    try {
+        const refPath = (0, path_1.join)(__dirname, '..', '..', '..', 'system', 'workflows', 'mcp-workflow-builder', 'reference', 'activity-types.md');
+        return await (0, promises_1.readFile)(refPath, 'utf-8');
+    }
+    catch {
+        // Fallback: return minimal reference if file not found
+        return '(Activity types reference not available — use trigger, worker, hook, await, cycle, signal, interrupt types as documented in HotMesh.)';
+    }
+}
+/**
+ * Resolve and read activities source from import paths.
+ * Returns combined source of all activity modules found.
+ */
+async function resolveActivitiesSource(workflowFilePath, importPaths) {
+    const dir = (0, path_1.dirname)(workflowFilePath);
+    const sources = [];
+    for (const importPath of importPaths) {
+        // Try common extensions
+        const basePath = (0, path_1.resolve)(dir, importPath);
+        for (const ext of ['.ts', '/index.ts', '.js', '/index.js']) {
+            try {
+                const content = await (0, promises_1.readFile)(basePath + ext, 'utf-8');
+                sources.push(`// ${importPath}\n${content}`);
+                break;
+            }
+            catch {
+                // Try next extension
+            }
+        }
+    }
+    return sources.length > 0 ? sources.join('\n\n') : undefined;
+}

package/build/services/yaml-workflow/durable-compiler/parser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Lightweight regex-based metadata extractor for durable workflow source.
+ *
+ * Extracts structural hints (activity names, primitives, control flow)
+ * that ground the LLM during compilation. This is NOT a full AST parser —
+ * it gives the LLM better context without requiring ts-morph or the TS compiler API.
+ */
+import type { DurableSourceMetadata } from './types';
+/**
+ * Extract structural metadata from durable workflow TypeScript source.
+ */
+export declare function extractDurableMetadata(source: string, workflowFunctionName: string): DurableSourceMetadata;