@hotmeshio/hotmesh 0.10.2 → 0.11.0

package/README.md

@@ -11,7 +11,7 @@ npm install @hotmeshio/hotmesh
 ## Use HotMesh for
 
 - **Durable pipelines** — Orchestrate long-running, multi-step pipelines transactionally.
-- **Temporal alternative** — The `Durable` module provides a Temporal-compatible API (`Client`, `Worker`, `proxyActivities`, `sleepFor`, `startChild`, signals) that runs directly on Postgres. No app server required.
+- **Familiar Temporal syntax** — The `Durable` module provides a Temporal-compatible API (`Client`, `Worker`, `proxyActivities`, `sleepFor`, `startChild`, signals) that runs directly on Postgres. No app server required.
 - **Distributed state machines** — Build stateful applications where every component can [fail and recover](https://github.com/hotmeshio/sdk-typescript/blob/main/services/collator/README.md).
 - **AI and training pipelines** — Multi-step AI workloads where each stage is expensive and must not be repeated on failure. A crashed pipeline resumes from the last committed step, not from the beginning.
 

package/build/modules/errors.d.ts

@@ -52,6 +52,8 @@ declare class DurableChildError extends Error {
     parentWorkflowId: string;
     workflowId: string;
     workflowTopic: string;
+    taskQueue: string;
+    workflowName: string;
     type: string;
     constructor(params: DurableChildErrorType);
 }

package/build/modules/errors.js

@@ -54,6 +54,8 @@ class DurableChildError extends Error {
         this.arguments = params.arguments;
         this.workflowId = params.workflowId;
         this.workflowTopic = params.workflowTopic;
+        this.taskQueue = params.taskQueue;
+        this.workflowName = params.workflowName;
         this.parentWorkflowId = params.parentWorkflowId;
         this.expire = params.expire;
         this.persistent = params.persistent;

package/build/modules/key.js

@@ -143,7 +143,7 @@ class KeyService {
             case 'v':
                 return 'versions';
             case 'x':
-                return id === '' ? 'streams' : 'stream_topics';
+                return id === '' ? 'engine_streams' : 'worker_streams';
             case 'hooks':
                 return 'signal_patterns';
             case 'signals':
@@ -174,7 +174,8 @@ class KeyService {
                 return 's';
             case 'versions':
                 return 'v';
-            case 'streams':
+            case 'engine_streams':
+            case 'worker_streams':
                 return 'x';
             case 'signal_patterns':
                 return 'hooks';

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.10.2",
+    "version": "0.11.0",
     "description": "Permanent-Memory Workflows & AI Agents",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -46,7 +46,7 @@
         "test:durable:sleep": "vitest run tests/durable/sleep/postgres.test.ts",
         "test:durable:signal": "vitest run tests/durable/signal/postgres.test.ts",
         "test:durable:unknown": "vitest run tests/durable/unknown/postgres.test.ts",
-        "test:durable:exporter": "vitest run tests/durable/exporter/exporter.test.ts",
+        "test:durable:exporter": "HMSH_LOGLEVEL=info vitest run tests/durable/exporter",
         "test:durable:exporter:debug": "EXPORT_DEBUG=1 HMSH_LOGLEVEL=error vitest run tests/durable/basic/postgres.test.ts",
         "test:dba": "vitest run tests/dba",
         "test:cycle": "vitest run tests/functional/cycle",

package/build/services/activities/worker.js

@@ -189,6 +189,15 @@ class Worker extends activity_1.Activity {
     }
     async execActivity(transaction) {
         const topic = pipe_1.Pipe.resolve(this.config.subtype, this.context);
+        // Extract workflow name from job data (set by durable client) or derive from subscribes
+        const jobData = this.context.data;
+        let wfn = jobData?.workflowName || '';
+        if (!wfn && this.config.subscribes) {
+            // Fallback: derive from subscribes by removing topic prefix
+            wfn = this.config.subscribes.startsWith(`${topic}-`)
+                ? this.config.subscribes.substring(topic.length + 1)
+                : this.config.subscribes;
+        }
         const streamData = {
             metadata: {
                 guid: (0, utils_1.guid)(),
@@ -197,6 +206,7 @@ class Worker extends activity_1.Activity {
                 dad: this.metadata.dad,
                 aid: this.metadata.aid,
                 topic,
+                wfn,
                 spn: this.context['$self'].output.metadata.l1s,
                 trc: this.context.metadata.trc,
             },

package/build/services/dba/index.d.ts

@@ -12,7 +12,8 @@ import { PostgresClientType } from '../../types/postgres';
  * |---|---|
  * | `{appId}.jobs` | Completed/expired jobs with `expired_at` set |
  * | `{appId}.jobs_attributes` | Execution artifacts (`adata`, `hmark`, `status`, `other`) that are only needed during workflow execution |
- * | `{appId}.streams` | Processed stream messages with `expired_at` set |
+ * | `{appId}.engine_streams` | Processed engine stream messages with `expired_at` set |
+ * | `{appId}.worker_streams` | Processed worker stream messages with `expired_at` set |
  *
  * The `DBA` service addresses this with two methods:
  *

package/build/services/dba/index.js

@@ -15,7 +15,8 @@ const postgres_1 = require("../connector/providers/postgres");
  * |---|---|
  * | `{appId}.jobs` | Completed/expired jobs with `expired_at` set |
  * | `{appId}.jobs_attributes` | Execution artifacts (`adata`, `hmark`, `status`, `other`) that are only needed during workflow execution |
- * | `{appId}.streams` | Processed stream messages with `expired_at` set |
+ * | `{appId}.engine_streams` | Processed engine stream messages with `expired_at` set |
+ * | `{appId}.worker_streams` | Processed worker stream messages with `expired_at` set |
  *
  * The `DBA` service addresses this with two methods:
  *
@@ -188,6 +189,7 @@ class DBA {
         v_stripped_attributes BIGINT := 0;
         v_deleted_transient BIGINT := 0;
         v_marked_pruned BIGINT := 0;
+        v_temp_count BIGINT := 0;
       BEGIN
         -- 1. Hard-delete expired jobs older than the retention window.
         --    FK CASCADE on jobs_attributes handles attribute cleanup.
@@ -210,11 +212,18 @@ class DBA {
         END IF;
 
         -- 3. Hard-delete expired stream messages older than the retention window.
+        --    Deletes from both engine_streams and worker_streams tables.
         IF prune_streams THEN
-          DELETE FROM ${schema}.streams
+          DELETE FROM ${schema}.engine_streams
           WHERE expired_at IS NOT NULL
             AND expired_at < NOW() - retention;
           GET DIAGNOSTICS v_deleted_streams = ROW_COUNT;
+
+          DELETE FROM ${schema}.worker_streams
+          WHERE expired_at IS NOT NULL
+            AND expired_at < NOW() - retention;
+          GET DIAGNOSTICS v_temp_count = ROW_COUNT;
+          v_deleted_streams := v_deleted_streams + v_temp_count;
         END IF;
 
         -- 4. Strip execution artifacts from completed, live, un-pruned jobs.

package/build/services/durable/client.js

@@ -145,6 +145,8 @@ class ClientService {
                     parentWorkflowId: options.parentWorkflowId,
                     workflowId: options.workflowId || hotmesh_1.HotMesh.guid(),
                     workflowTopic: workflowTopic,
+                    taskQueue: taskQueueName,
+                    workflowName: workflowName,
                     backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
                     maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
                     maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL),
@@ -186,11 +188,14 @@ class ClientService {
              */
             hook: async (options) => {
                 const taskQueue = options.taskQueue ?? options.entity;
-                const workflowTopic = `${taskQueue}-${options.entity ?? options.workflowName}`;
+                const hookWorkflowName = options.entity ?? options.workflowName;
+                const workflowTopic = `${taskQueue}-${hookWorkflowName}`;
                 const payload = {
                     arguments: [...options.args],
                     id: options.workflowId,
                     workflowTopic,
+                    taskQueue,
+                    workflowName: hookWorkflowName,
                     backoffCoefficient: options.config?.backoffCoefficient || enums_1.HMSH_DURABLE_EXP_BACKOFF,
                     maximumAttempts: options.config?.maximumAttempts || enums_1.HMSH_DURABLE_MAX_ATTEMPTS,
                     maximumInterval: (0, utils_1.s)(options.config?.maximumInterval || enums_1.HMSH_DURABLE_MAX_INTERVAL),

package/build/services/durable/exporter.d.ts

@@ -63,6 +63,21 @@ declare class ExporterService {
      * their executions as nested `children`.
      */
     exportExecution(jobId: string, workflowTopic: string, options?: ExecutionExportOptions): Promise<WorkflowExecution>;
+    /**
+     * Reconstruct a WorkflowExecution from raw database rows when the job
+     * handle has expired or been pruned. Only available if the store provider
+     * implements getJobByKeyDirect.
+     */
+    private exportExecutionDirect;
+    /**
+     * Enrich execution events with activity and child workflow inputs.
+     * Queries the store for activity arguments and child workflow arguments.
+     */
+    private enrichExecutionInputs;
+    /**
+     * Resolve a symbol field from stable JSON path using the symbol registry.
+     */
+    private resolveSymbolField;
     /**
      * Pure transformation: convert a raw DurableJobExport into a
      * Temporal-compatible WorkflowExecution event history.

package/build/services/durable/exporter.js

@@ -182,14 +182,352 @@ class ExporterService {
      * their executions as nested `children`.
      */
     async exportExecution(jobId, workflowTopic, options = {}) {
-        const raw = await this.export(jobId);
-        const execution = this.transformToExecution(raw, jobId, workflowTopic, options);
-        if (options.mode === 'verbose') {
-            const maxDepth = options.max_depth ?? 5;
-            execution.children = await this.fetchChildren(raw, workflowTopic, options, 1, maxDepth);
+        let execution;
+        try {
+            const raw = await this.export(jobId);
+            execution = this.transformToExecution(raw, jobId, workflowTopic, options);
+            if (options.mode === 'verbose') {
+                const maxDepth = options.max_depth ?? 5;
+                execution.children = await this.fetchChildren(raw, workflowTopic, options, 1, maxDepth);
+            }
+        }
+        catch (error) {
+            // Fallback to direct query for expired/pruned jobs
+            if (options.allow_direct_query && this.store.getJobByKeyDirect) {
+                this.logger.debug('Job export failed, attempting direct query', { jobId, error: error.message });
+                execution = await this.exportExecutionDirect(jobId, workflowTopic, options);
+            }
+            else {
+                throw error;
+            }
+        }
+        // Enrich with activity/child workflow inputs if requested
+        if (options.enrich_inputs) {
+            await this.enrichExecutionInputs(execution, jobId);
         }
         return execution;
     }
+    /**
+     * Reconstruct a WorkflowExecution from raw database rows when the job
+     * handle has expired or been pruned. Only available if the store provider
+     * implements getJobByKeyDirect.
+     */
+    async exportExecutionDirect(workflowId, workflowTopic, options) {
+        if (!this.store.getJobByKeyDirect) {
+            throw new Error('Direct query not supported by this store provider');
+        }
+        const jobKey = `hmsh:${this.appId}:j:${workflowId}`;
+        const { job, attributes } = await this.store.getJobByKeyDirect(jobKey);
+        // Parse metadata for timing
+        const startTime = attributes['aoa'] ? parseTimestamp(attributes['aoa']) : job.created_at?.toISOString();
+        const closeTime = attributes['apa'] ? parseTimestamp(attributes['apa']) : job.updated_at?.toISOString();
+        // Parse workflow result
+        let workflowResult;
+        if (attributes['aBa']) {
+            const raw = attributes['aBa'].startsWith('/s') ? attributes['aBa'].slice(2) : attributes['aBa'];
+            try {
+                workflowResult = JSON.parse(raw);
+            }
+            catch { /* ignore */ }
+        }
+        // Build events from timeline operations
+        const events = [];
+        let nextId = 1;
+        // Helper to extract operation entries from attributes
+        const getOperationKeys = (prefix) => {
+            return Object.keys(attributes)
+                .filter((k) => k.startsWith(prefix))
+                .sort((a, b) => {
+                const numA = parseInt(a.replace(new RegExp(`${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}|-`, 'g'), ''));
+                const numB = parseInt(b.replace(new RegExp(`${prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}|-`, 'g'), ''));
+                return numA - numB;
+            })
+                .map((key) => {
+                const raw = attributes[key].startsWith('/s') ? attributes[key].slice(2) : attributes[key];
+                try {
+                    return { key, index: parseInt(key.replace(/[^0-9]/g, '')), val: JSON.parse(raw) };
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter(Boolean);
+        };
+        let systemCount = 0;
+        let userCount = 0;
+        let activityCompleted = 0;
+        let activityFailed = 0;
+        let childTotal = 0;
+        let childCompleted = 0;
+        let childFailed = 0;
+        let timerCount = 0;
+        let signalCount = 0;
+        // Process proxy (activities)
+        for (const { key, index, val } of getOperationKeys('-proxy-')) {
+            const activityName = extractActivityName(val);
+            const isSystem = isSystemActivity(activityName);
+            const ac = val.ac;
+            const au = val.au;
+            const dur = computeDuration(ac, au);
+            const hasError = '$error' in val;
+            if (isSystem)
+                systemCount++;
+            else
+                userCount++;
+            if (options.exclude_system && isSystem)
+                continue;
+            if (ac) {
+                events.push(makeEvent(nextId++, 'activity_task_scheduled', 'activity', parseTimestamp(ac), null, isSystem, {
+                    kind: 'activity_task_scheduled',
+                    activity_type: activityName,
+                    timeline_key: val.job_id || key,
+                    execution_index: index,
+                }));
+            }
+            if (au) {
+                if (hasError) {
+                    activityFailed++;
+                    events.push(makeEvent(nextId++, 'activity_task_failed', 'activity', parseTimestamp(au), dur, isSystem, {
+                        kind: 'activity_task_failed',
+                        activity_type: activityName,
+                        failure: val.$error,
+                        timeline_key: val.job_id || key,
+                        execution_index: index,
+                    }));
+                }
+                else {
+                    activityCompleted++;
+                    events.push(makeEvent(nextId++, 'activity_task_completed', 'activity', parseTimestamp(au), dur, isSystem, {
+                        kind: 'activity_task_completed',
+                        activity_type: activityName,
+                        result: options.omit_results ? undefined : val.data,
+                        timeline_key: val.job_id || key,
+                        execution_index: index,
+                    }));
+                }
+            }
+        }
+        // Process wait (signals)
+        for (const { key, index, val } of getOperationKeys('-wait-')) {
+            const signalName = val.id || val.data?.id || val.data?.data?.id || `signal-${index}`;
+            const ac = val.ac;
+            const au = val.au;
+            const dur = computeDuration(ac, au);
+            signalCount++;
+            const ts = au ? parseTimestamp(au) : ac ? parseTimestamp(ac) : startTime;
+            events.push(makeEvent(nextId++, 'workflow_execution_signaled', 'signal', ts, dur, false, {
+                kind: 'workflow_execution_signaled',
+                signal_name: signalName,
+                input: options.omit_results ? undefined : val.data?.data,
+                timeline_key: val.job_id || key,
+                execution_index: index,
+            }));
+        }
+        // Process sleep (timers)
+        for (const { key, index, val } of getOperationKeys('-sleep-')) {
+            const ac = val.ac;
+            const au = val.au;
+            const dur = computeDuration(ac, au);
+            timerCount++;
+            if (ac) {
+                events.push(makeEvent(nextId++, 'timer_started', 'timer', parseTimestamp(ac), null, false, {
+                    kind: 'timer_started',
+                    duration_ms: dur ?? undefined,
+                    timeline_key: val.job_id || key,
+                    execution_index: index,
+                }));
+            }
+            if (au) {
+                events.push(makeEvent(nextId++, 'timer_fired', 'timer', parseTimestamp(au), dur, false, {
+                    kind: 'timer_fired',
+                    timeline_key: val.job_id || key,
+                    execution_index: index,
+                }));
+            }
+        }
+        // Process child (awaited child workflows)
+        for (const { key, index, val } of getOperationKeys('-child-')) {
+            const childId = val.job_id || key;
+            const ac = val.ac;
+            const au = val.au;
+            const dur = computeDuration(ac, au);
+            const hasError = '$error' in val;
+            childTotal++;
+            if (ac) {
+                events.push(makeEvent(nextId++, 'child_workflow_execution_started', 'child_workflow', parseTimestamp(ac), null, false, {
+                    kind: 'child_workflow_execution_started',
+                    child_workflow_id: childId,
+                    awaited: true,
+                    timeline_key: childId,
+                    execution_index: index,
+                }));
+            }
+            if (au) {
+                if (hasError) {
+                    childFailed++;
+                    events.push(makeEvent(nextId++, 'child_workflow_execution_failed', 'child_workflow', parseTimestamp(au), dur, false, {
+                        kind: 'child_workflow_execution_failed',
+                        child_workflow_id: childId,
+                        failure: val.$error,
+                        timeline_key: childId,
+                        execution_index: index,
+                    }));
+                }
+                else {
+                    childCompleted++;
+                    events.push(makeEvent(nextId++, 'child_workflow_execution_completed', 'child_workflow', parseTimestamp(au), dur, false, {
+                        kind: 'child_workflow_execution_completed',
+                        child_workflow_id: childId,
+                        result: options.omit_results ? undefined : val.data,
+                        timeline_key: childId,
+                        execution_index: index,
+                    }));
+                }
+            }
+        }
+        // Process start (fire-and-forget child workflows)
+        for (const { key, index, val } of getOperationKeys('-start-')) {
+            const childId = val.job_id || key;
+            const ac = val.ac;
+            const au = val.au;
+            const ts = ac ? parseTimestamp(ac) : au ? parseTimestamp(au) : startTime;
+            childTotal++;
+            events.push(makeEvent(nextId++, 'child_workflow_execution_started', 'child_workflow', ts, null, false, {
+                kind: 'child_workflow_execution_started',
+                child_workflow_id: childId,
+                awaited: false,
+                timeline_key: childId,
+                execution_index: index,
+            }));
+        }
+        // Sort chronologically and re-number
+        events.sort((a, b) => {
+            const cmp = a.event_time.localeCompare(b.event_time);
+            return cmp !== 0 ? cmp : a.event_id - b.event_id;
+        });
+        for (let i = 0; i < events.length; i++) {
+            events[i].event_id = i + 1;
+        }
+        // Back-references
+        const scheduledMap = new Map();
+        const initiatedMap = new Map();
+        for (const e of events) {
+            const attrs = e.attributes;
+            if (e.event_type === 'activity_task_scheduled' && attrs.timeline_key) {
+                scheduledMap.set(attrs.timeline_key, e.event_id);
+            }
+            if (e.event_type === 'child_workflow_execution_started' && attrs.timeline_key) {
+                initiatedMap.set(attrs.timeline_key, e.event_id);
+            }
+            if ((e.event_type === 'activity_task_completed' || e.event_type === 'activity_task_failed') && attrs.timeline_key) {
+                attrs.scheduled_event_id = scheduledMap.get(attrs.timeline_key) ?? null;
+            }
+            if ((e.event_type === 'child_workflow_execution_completed' || e.event_type === 'child_workflow_execution_failed') && attrs.timeline_key) {
+                attrs.initiated_event_id = initiatedMap.get(attrs.timeline_key) ?? null;
+            }
+        }
+        // Compute total duration
+        let totalDurationMs = null;
+        if (startTime && closeTime) {
+            const diffMs = new Date(closeTime).getTime() - new Date(startTime).getTime();
+            if (diffMs >= 0)
+                totalDurationMs = diffMs;
+        }
+        const proxyTotal = systemCount + userCount;
+        return {
+            workflow_id: workflowId,
+            workflow_type: workflowTopic,
+            task_queue: workflowTopic,
+            status: 'completed',
+            start_time: startTime || null,
+            close_time: closeTime || null,
+            duration_ms: totalDurationMs,
+            result: workflowResult,
+            events,
+            summary: {
+                total_events: events.length,
+                activities: {
+                    total: proxyTotal,
+                    completed: activityCompleted,
+                    failed: activityFailed,
+                    system: systemCount,
+                    user: userCount,
+                },
+                child_workflows: { total: childTotal, completed: childCompleted, failed: childFailed },
+                timers: timerCount,
+                signals: signalCount,
+            },
+        };
+    }
+    /**
+     * Enrich execution events with activity and child workflow inputs.
+     * Queries the store for activity arguments and child workflow arguments.
+     */
+    async enrichExecutionInputs(execution, workflowId) {
+        // Check if store supports exporter queries
+        if (!this.store.getActivityInputs || !this.store.getChildWorkflowInputs) {
+            this.logger.warn('Store does not support input enrichment (provider may not implement getActivityInputs/getChildWorkflowInputs)');
+            return;
+        }
+        // Resolve symbol fields for activity and workflow arguments using symbol keys
+        const symbolSets = await this.store.getSymbolKeys(['activity_trigger', 'trigger']);
+        const activityArgsField = this.resolveSymbolField(symbolSets, 'activity_trigger', 'activity_trigger/output/data/arguments');
+        const workflowArgsField = this.resolveSymbolField(symbolSets, 'trigger', 'trigger/output/data/arguments');
+        // ── 1. Enrich activity inputs ──
+        if (activityArgsField) {
+            const activityEvents = execution.events.filter((e) => e.event_type === 'activity_task_scheduled' || e.event_type === 'activity_task_completed' || e.event_type === 'activity_task_failed');
+            if (activityEvents.length > 0) {
+                const { byJobId, byNameIndex } = await this.store.getActivityInputs(workflowId, activityArgsField);
+                for (const evt of activityEvents) {
+                    const attrs = evt.attributes;
+                    let input = attrs.timeline_key ? byJobId.get(attrs.timeline_key) : undefined;
+                    if (input === undefined && attrs.activity_type && attrs.execution_index !== undefined) {
+                        input = byNameIndex.get(`${attrs.activity_type}:${attrs.execution_index}`);
+                    }
+                    if (input !== undefined) {
+                        attrs.input = input;
+                    }
+                }
+            }
+        }
+        // ── 2. Enrich child workflow inputs ──
+        if (workflowArgsField) {
+            const childEvents = execution.events.filter((e) => e.event_type === 'child_workflow_execution_started');
+            if (childEvents.length > 0) {
+                const childIds = [...new Set(childEvents
+                        .map((e) => e.attributes.child_workflow_id)
+                        .filter(Boolean))];
+                if (childIds.length > 0) {
+                    const childJobKeys = childIds.map((id) => `hmsh:${this.appId}:j:${id}`);
+                    const childInputMap = await this.store.getChildWorkflowInputs(childJobKeys, workflowArgsField);
+                    for (const evt of childEvents) {
+                        const attrs = evt.attributes;
+                        const input = childInputMap.get(attrs.child_workflow_id);
+                        if (input !== undefined) {
+                            attrs.input = input;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Resolve a symbol field from stable JSON path using the symbol registry.
+     */
+    resolveSymbolField(symbolSets, range, path) {
+        // Get the symbol map for this range
+        const symbolMap = symbolSets[range];
+        if (!symbolMap) {
+            return null;
+        }
+        // Look up the symbol code for this path
+        const symbolCode = symbolMap[path];
+        if (!symbolCode) {
+            return null;
+        }
+        // Return with dimension suffix
+        return `${symbolCode},0`;
+    }
     /**
      * Pure transformation: convert a raw DurableJobExport into a
      * Temporal-compatible WorkflowExecution event history.

package/build/services/durable/schemas/factory.d.ts

@@ -17,7 +17,7 @@
  * * Service Meshes
  * * Master Data Management systems
  */
-declare const APP_VERSION = "5";
+declare const APP_VERSION = "8";
 declare const APP_ID = "durable";
 /**
  * returns a new durable workflow schema

package/build/services/durable/schemas/factory.js

@@ -20,7 +20,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.APP_ID = exports.APP_VERSION = exports.getWorkflowYAML = void 0;
-const APP_VERSION = '5';
+const APP_VERSION = '8';
 exports.APP_VERSION = APP_VERSION;
 const APP_ID = 'durable';
 exports.APP_ID = APP_ID;
@@ -66,7 +66,13 @@ const getWorkflowYAML = (app, version) => {
               description: the arguments to pass to the flow
               type: array
             workflowTopic:
-              description: the stream topic the worker is listening on
+              description: concatenated taskQueue-workflowName for engine-internal routing
+              type: string
+            taskQueue:
+              description: the task queue name (stream_name in worker_streams)
+              type: string
+            workflowName:
+              description: the workflow function name (workflow_name in worker_streams)
               type: string
             backoffCoefficient:
               description: the time multiple in seconds to backoff before retrying
@@ -155,7 +161,7 @@ const getWorkflowYAML = (app, version) => {
         worker:
           title: Main Worker - Calls linked Workflow functions
           type: worker
-          topic: '{trigger.output.data.workflowTopic}'
+          topic: '{trigger.output.data.taskQueue}'
           emit: '{$job.data.done}'
           input:
             schema:
@@ -169,6 +175,8 @@ const getWorkflowYAML = (app, version) => {
                   type: array
                 workflowTopic:
                   type: string
+                workflowName:
+                  type: string
                 canRetry:
                   type: boolean
                 expire:
@@ -178,6 +186,7 @@ const getWorkflowYAML = (app, version) => {
               workflowId: '{trigger.output.data.workflowId}'
               arguments: '{trigger.output.data.arguments}'
               workflowTopic: '{trigger.output.data.workflowTopic}'
+              workflowName: '{trigger.output.data.workflowName}'
               expire: '{trigger.output.data.expire}'
               canRetry:
                 '@pipe':
@@ -348,6 +357,10 @@ const getWorkflowYAML = (app, version) => {
               properties:
                 workflowTopic:
                   type: string
+                taskQueue:
+                  type: string
+                workflowName:
+                  type: string
                 backoffCoefficient:
                   type: number
                 maximumAttempts:
@@ -387,6 +400,7 @@ const getWorkflowYAML = (app, version) => {
               persistent: '{worker.output.data.persistent}'
               signalIn: '{worker.output.data.signalIn}'
               workflowId: '{worker.output.data.workflowId}'
+              taskQueue: '{worker.output.data.taskQueue}'
               workflowName: '{worker.output.data.workflowName}'
               workflowTopic: '{worker.output.data.workflowTopic}'
               entity: '{worker.output.data.entity}'
@@ -893,7 +907,7 @@ const getWorkflowYAML = (app, version) => {
         signaler_worker:
           title: Signal In - Worker
           type: worker
-          topic: '{signaler.hook.data.workflowTopic}'
+          topic: '{signaler.hook.data.taskQueue}'
           input:
             schema:
               type: object
@@ -906,6 +920,8 @@ const getWorkflowYAML = (app, version) => {
                   type: string
                 arguments:
                   type: array
+                workflowName:
+                  type: string
                 canRetry:
                   type: boolean
                 expire:
@@ -915,6 +931,7 @@ const getWorkflowYAML = (app, version) => {
               originJobId: '{trigger.output.data.originJobId}'
               workflowDimension: '{signaler.output.metadata.dad}'
               arguments: '{signaler.hook.data.arguments}'
+              workflowName: '{signaler.hook.data.workflowName}'
               expire: '{trigger.output.data.expire}'
               canRetry:
                 '@pipe':
@@ -1136,6 +1153,7 @@ const getWorkflowYAML = (app, version) => {
               persistent: '{signaler_worker.output.data.persistent}'
               signalIn: '{signaler_worker.output.data.signalIn}'
               workflowId: '{signaler_worker.output.data.workflowId}'
+              taskQueue: '{signaler_worker.output.data.taskQueue}'
               workflowName: '{signaler_worker.output.data.workflowName}'
               workflowTopic: '{signaler_worker.output.data.workflowTopic}'
               entity: '{signaler_worker.output.data.entity}'
@@ -1942,6 +1960,11 @@ const getWorkflowYAML = (app, version) => {
                   - ['{collator_trigger.output.data.items}', '{collator_cycle_hook.output.data.cur_index}']
                   - ['{@array.get}', workflowId]
                   - ['{@object.get}']
+              taskQueue:
+                '@pipe':
+                  - ['{collator_trigger.output.data.items}', '{collator_cycle_hook.output.data.cur_index}']
+                  - ['{@array.get}', taskQueue]
+                  - ['{@object.get}']
               workflowName:
                 '@pipe':
                   - ['{collator_trigger.output.data.items}', '{collator_cycle_hook.output.data.cur_index}']