@hotmeshio/long-tail 0.1.0

package/build/services/interceptor/completion.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCompletion = handleCompletion;
+const state_1 = require("./state");
+const publish_1 = require("../events/publish");
+/**
+ * Handle a workflow that returned { type: 'return' }.
+ *
+ * Augments milestones for re-runs, then signals the parent
+ * orchestrator with the result. The orchestrator is responsible
+ * for completing the task and persisting result data.
+ *
+ * If the result contains a `rounds_exhausted` milestone, an advisory
+ * escalation is also created and auto-assigned to the submitting user.
+ *
+ * Returns the (possibly augmented) result so the caller can
+ * return it to the workflow engine.
+ */
+async function handleCompletion(state, result) {
+    const { activities, routing, isReRun } = state;
+    // Augment milestones with re-run markers
+    const augmentedResult = isReRun
+        ? {
+            ...result,
+            milestones: [
+                ...(result.milestones || []),
+                { name: 'escalated', value: true },
+                { name: 'resolved_by_human', value: true },
+            ],
+        }
+        : result;
+    // Publish workflow.completed event
+    (0, publish_1.publishWorkflowEvent)({
+        type: 'workflow.completed',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        status: 'completed',
+        data: augmentedResult.data,
+    });
+    // Publish milestone event (non-durable side effect, fire-and-forget)
+    if (augmentedResult.milestones?.length) {
+        (0, publish_1.publishMilestoneEvent)({
+            source: 'interceptor',
+            workflowId: state.workflowId,
+            workflowName: state.workflowName,
+            taskQueue: state.taskQueue,
+            taskId: state.taskId,
+            milestones: augmentedResult.milestones,
+            data: augmentedResult.data,
+        });
+    }
+    // Advisory escalation for rounds_exhausted — the workflow still completes
+    // normally but an escalation record is created so a human can investigate
+    // and resubmit with better context.
+    const roundsExhausted = augmentedResult.milestones?.some((m) => m.name === 'rounds_exhausted');
+    if (roundsExhausted && !isReRun) {
+        await createAdvisoryEscalation(state, augmentedResult);
+    }
+    // Signal the parent orchestrator with the result.
+    // The orchestrator completes the task when the signal arrives.
+    if (routing?.parentWorkflowId && routing?.signalId) {
+        await activities.ltSignalParent({
+            parentTaskQueue: routing.parentTaskQueue,
+            parentWorkflowType: routing.parentWorkflowType,
+            parentWorkflowId: routing.parentWorkflowId,
+            signalId: routing.signalId,
+            data: augmentedResult,
+        });
+    }
+    else if (state.taskId) {
+        // Standalone mode: no parent to signal — complete the task directly.
+        await activities.ltCompleteTask({
+            taskId: state.taskId,
+            data: JSON.stringify(augmentedResult.data),
+            milestones: augmentedResult.milestones || [],
+            workflowId: state.workflowId,
+            workflowName: state.workflowName,
+            taskQueue: state.taskQueue,
+        });
+    }
+    return augmentedResult;
+}
+/**
+ * Create an advisory escalation for a workflow that exhausted its tool rounds.
+ * Auto-claims to the submitting user so they're notified immediately.
+ */
+async function createAdvisoryEscalation(state, result) {
+    const { activities, wfConfig, defaultRole } = state;
+    const storedEnvelope = (0, state_1.buildStoredEnvelope)(state);
+    const diagnosis = result.data?.diagnosis;
+    const description = diagnosis
+        ? `Tool rounds exhausted: ${diagnosis.slice(0, 500)}`
+        : `Workflow ${state.workflowName} exhausted all tool rounds without completing the task.`;
+    if (state.taskId) {
+        await activities.ltEscalateTask(state.taskId);
+    }
+    const escalationId = await activities.ltCreateEscalation({
+        type: state.workflowName,
+        subtype: 'rounds_exhausted',
+        description,
+        priority: 2,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        parentId: state.envelope?.lt?.parentId,
+        role: wfConfig?.role || defaultRole,
+        envelope: JSON.stringify(storedEnvelope),
+        escalationPayload: JSON.stringify(result.data),
+        workflowId: state.workflowId,
+        taskQueue: state.taskQueue,
+        workflowType: state.workflowName,
+        traceId: state.traceId,
+        spanId: state.spanId,
+    });
+    (0, publish_1.publishEscalationEvent)({
+        type: 'escalation.created',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        escalationId,
+        originId: state.envelope?.lt?.originId,
+        status: 'pending',
+        data: result.data,
+    });
+    (0, publish_1.publishTaskEvent)({
+        type: 'task.escalated',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        status: 'needs_intervention',
+    });
+    // Auto-claim to submitting user if known
+    const userId = state.envelope?.lt?.userId;
+    if (userId) {
+        await activities.ltClaimEscalation({
+            escalationId,
+            userId,
+            durationMinutes: 240, // 4-hour claim window
+        });
+    }
+}

package/build/services/interceptor/context.d.ts

@@ -0,0 +1,11 @@
+import type { OrchestratorContext } from './types';
+/**
+ * Run a function with orchestrator context available via `getOrchestratorContext()`.
+ * Called by the interceptor when wrapping a container/orchestrator workflow.
+ */
+export declare function runWithOrchestratorContext<T>(ctx: OrchestratorContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * Retrieve the orchestrator context set by the interceptor.
+ * Called by `executeLT` to inject parent routing into child envelopes.
+ */
+export declare function getOrchestratorContext(): OrchestratorContext | undefined;

package/build/services/interceptor/context.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithOrchestratorContext = runWithOrchestratorContext;
+exports.getOrchestratorContext = getOrchestratorContext;
+const async_hooks_1 = require("async_hooks");
+const store = new async_hooks_1.AsyncLocalStorage();
+/**
+ * Run a function with orchestrator context available via `getOrchestratorContext()`.
+ * Called by the interceptor when wrapping a container/orchestrator workflow.
+ */
+function runWithOrchestratorContext(ctx, fn) {
+    return store.run(ctx, fn);
+}
+/**
+ * Retrieve the orchestrator context set by the interceptor.
+ * Called by `executeLT` to inject parent routing into child envelopes.
+ */
+function getOrchestratorContext() {
+    return store.getStore();
+}

package/build/services/interceptor/escalation.d.ts

@@ -0,0 +1,26 @@
+import type { LTEscalation } from '../../types';
+import type { InterceptorState } from './types';
+/**
+ * Handle a workflow that returned { type: 'escalation' }.
+ *
+ * Creates an escalation record with full routing context so the
+ * work can be resolved by a person or another AI — and the workflow
+ * resumes exactly where it left off.
+ *
+ * Task lifecycle is the orchestrator's responsibility. The interceptor
+ * only creates and resolves escalations linked to the parent task.
+ *
+ * The workflow ENDS here. Resolution starts a new workflow.
+ */
+export declare function handleEscalation(state: InterceptorState, result: LTEscalation): Promise<LTEscalation>;
+/**
+ * Handle an unhandled error by converting it to an escalation.
+ *
+ * Same flow as handleEscalation, but constructs the LTEscalation
+ * from the error — capturing the message and stack trace so the
+ * resolver has full context.
+ *
+ * For MissingCredentialError, produces a categorized escalation with
+ * `category: 'missing_credential'` so the UI can render actionable guidance.
+ */
+export declare function handleErrorEscalation(state: InterceptorState, err: Error): Promise<LTEscalation>;

package/build/services/interceptor/escalation.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleEscalation = handleEscalation;
+exports.handleErrorEscalation = handleErrorEscalation;
+const state_1 = require("./state");
+const publish_1 = require("../events/publish");
+const credentials_1 = require("../iam/credentials");
+/**
+ * Handle a workflow that returned { type: 'escalation' }.
+ *
+ * Creates an escalation record with full routing context so the
+ * work can be resolved by a person or another AI — and the workflow
+ * resumes exactly where it left off.
+ *
+ * Task lifecycle is the orchestrator's responsibility. The interceptor
+ * only creates and resolves escalations linked to the parent task.
+ *
+ * The workflow ENDS here. Resolution starts a new workflow.
+ */
+async function handleEscalation(state, result) {
+    const { activities, wfConfig, defaultRole } = state;
+    const storedEnvelope = (0, state_1.buildStoredEnvelope)(state);
+    // Mark the task as needing intervention
+    if (state.taskId) {
+        await activities.ltEscalateTask(state.taskId);
+    }
+    const escalationId = await activities.ltCreateEscalation({
+        type: state.workflowName,
+        subtype: state.workflowName,
+        description: result.message,
+        priority: result.priority,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        parentId: state.envelope?.lt?.parentId,
+        role: result.role || wfConfig?.role || defaultRole,
+        envelope: JSON.stringify(storedEnvelope),
+        escalationPayload: JSON.stringify(result.data),
+        workflowId: state.workflowId,
+        taskQueue: state.taskQueue,
+        workflowType: state.workflowName,
+        traceId: state.traceId,
+        spanId: state.spanId,
+    });
+    (0, publish_1.publishEscalationEvent)({
+        type: 'escalation.created',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        escalationId,
+        originId: state.envelope?.lt?.originId,
+        status: 'pending',
+        data: result.data,
+    });
+    (0, publish_1.publishTaskEvent)({
+        type: 'task.escalated',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        status: 'needs_intervention',
+    });
+    return result;
+}
+/**
+ * Handle an unhandled error by converting it to an escalation.
+ *
+ * Same flow as handleEscalation, but constructs the LTEscalation
+ * from the error — capturing the message and stack trace so the
+ * resolver has full context.
+ *
+ * For MissingCredentialError, produces a categorized escalation with
+ * `category: 'missing_credential'` so the UI can render actionable guidance.
+ */
+async function handleErrorEscalation(state, err) {
+    const { activities, wfConfig, defaultRole } = state;
+    const isMissingCred = err instanceof credentials_1.MissingCredentialError || err.name === 'MissingCredentialError';
+    const storedEnvelope = (0, state_1.buildStoredEnvelope)(state);
+    // Mark the task as needing intervention
+    if (state.taskId) {
+        await activities.ltEscalateTask(state.taskId);
+    }
+    const escalationPayload = isMissingCred
+        ? {
+            category: 'missing_credential',
+            provider: err.provider,
+            error: err.message,
+        }
+        : { error: err.message, stack: err.stack };
+    const description = isMissingCred
+        ? `Missing credential: ${err.provider}. Register one at Credentials and retry.`
+        : `Unhandled error: ${err.message || String(err)}`;
+    const errorEscalationId = await activities.ltCreateEscalation({
+        type: state.workflowName,
+        subtype: isMissingCred ? 'missing_credential' : state.workflowName,
+        description,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        parentId: state.envelope?.lt?.parentId,
+        role: wfConfig?.role || defaultRole,
+        envelope: JSON.stringify(storedEnvelope),
+        escalationPayload: JSON.stringify(escalationPayload),
+        workflowId: state.workflowId,
+        taskQueue: state.taskQueue,
+        workflowType: state.workflowName,
+        traceId: state.traceId,
+        spanId: state.spanId,
+    });
+    (0, publish_1.publishEscalationEvent)({
+        type: 'escalation.created',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        escalationId: errorEscalationId,
+        originId: state.envelope?.lt?.originId,
+        status: 'pending',
+        data: { error: err.message },
+    });
+    (0, publish_1.publishTaskEvent)({
+        type: 'task.escalated',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        status: 'needs_intervention',
+    });
+    (0, publish_1.publishWorkflowEvent)({
+        type: 'workflow.failed',
+        source: 'interceptor',
+        workflowId: state.workflowId,
+        workflowName: state.workflowName,
+        taskQueue: state.taskQueue,
+        taskId: state.taskId,
+        originId: state.envelope?.lt?.originId,
+        status: 'failed',
+        data: { error: err.message },
+    });
+    return {
+        type: 'escalation',
+        data: escalationPayload,
+        message: description,
+    };
+}

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

@@ -0,0 +1,45 @@
+/**
+ * Register the Long Tail interceptors in a single call.
+ *
+ * This registers:
+ * 1. The shared activity worker for interceptor DB operations
+ * 2. The workflow interceptor (escalation, routing, re-runs, composition)
+ * 3. The activity interceptor (milestone event publishing)
+ */
+export declare function registerLT(connection: {
+    class: any;
+    options: any;
+}, options?: {
+    taskQueue?: string;
+    defaultRole?: string;
+}): Promise<void>;
+/**
+ * The Long Tail interceptor wraps every registered workflow.
+ *
+ * Every workflow in lt_config_workflows gets the same unified treatment:
+ *
+ * 1. **Orchestrator context** — `next()` is always wrapped in
+ *    `runWithOrchestratorContext` so that ANY workflow can compose
+ *    children via `executeLT`. If it doesn't, the context is unused.
+ *
+ * 2. **Task tracking** — Every execution is tied to a task record
+ *    for lifecycle tracking and origin lineage.
+ *
+ * 3. **Escalation routing** — On escalation or error, the workflow
+ *    ENDS after creating an escalation record. When a human resolves,
+ *    a NEW workflow is started with resolver data. The interceptor
+ *    detects re-runs via `envelope.resolver` + `envelope.lt.escalationId`.
+ *
+ * 4. **Parent signaling** — On completion, signals back to the parent
+ *    orchestrator (if any) so the composition chain continues.
+ *
+ * Routing info is read from the task record's metadata (set by executeLT)
+ * rather than from workflow arguments, since the interceptor ctx does not
+ * expose workflow function arguments directly.
+ */
+export declare function createLTInterceptor(options: {
+    activityTaskQueue: string;
+    defaultRole?: string;
+}): {
+    execute(ctx: Map<string, any>, next: () => Promise<any>): Promise<any>;
+};

package/build/services/interceptor/index.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLT = registerLT;
+exports.createLTInterceptor = createLTInterceptor;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
+const interceptorActivities = __importStar(require("./activities"));
+const activity_interceptor_1 = require("./activity-interceptor");
+const context_1 = require("./context");
+const state_1 = require("./state");
+const escalation_1 = require("./escalation");
+const completion_1 = require("./completion");
+const lifecycle_1 = require("./lifecycle");
+const context_2 = require("../iam/context");
+const envelope_1 = require("../iam/envelope");
+const DEFAULT_ACTIVITY_QUEUE = 'lt-interceptor';
+/**
+ * Register the Long Tail interceptors in a single call.
+ *
+ * This registers:
+ * 1. The shared activity worker for interceptor DB operations
+ * 2. The workflow interceptor (escalation, routing, re-runs, composition)
+ * 3. The activity interceptor (milestone event publishing)
+ */
+async function registerLT(connection, options) {
+    const taskQueue = options?.taskQueue ?? DEFAULT_ACTIVITY_QUEUE;
+    await hotmesh_1.Durable.registerActivityWorker({ connection, taskQueue }, interceptorActivities, taskQueue);
+    hotmesh_1.Durable.registerInterceptor(createLTInterceptor({
+        activityTaskQueue: taskQueue,
+        defaultRole: options?.defaultRole,
+    }));
+    hotmesh_1.Durable.registerActivityInterceptor((0, activity_interceptor_1.createLTActivityInterceptor)());
+}
+/**
+ * The Long Tail interceptor wraps every registered workflow.
+ *
+ * Every workflow in lt_config_workflows gets the same unified treatment:
+ *
+ * 1. **Orchestrator context** — `next()` is always wrapped in
+ *    `runWithOrchestratorContext` so that ANY workflow can compose
+ *    children via `executeLT`. If it doesn't, the context is unused.
+ *
+ * 2. **Task tracking** — Every execution is tied to a task record
+ *    for lifecycle tracking and origin lineage.
+ *
+ * 3. **Escalation routing** — On escalation or error, the workflow
+ *    ENDS after creating an escalation record. When a human resolves,
+ *    a NEW workflow is started with resolver data. The interceptor
+ *    detects re-runs via `envelope.resolver` + `envelope.lt.escalationId`.
+ *
+ * 4. **Parent signaling** — On completion, signals back to the parent
+ *    orchestrator (if any) so the composition chain continues.
+ *
+ * Routing info is read from the task record's metadata (set by executeLT)
+ * rather than from workflow arguments, since the interceptor ctx does not
+ * expose workflow function arguments directly.
+ */
+function createLTInterceptor(options) {
+    const { activityTaskQueue, defaultRole = 'reviewer', } = options;
+    const interceptor = {
+        async execute(ctx, next) {
+            // 1. Extract workflow identity and proxy activities
+            const wf = (0, lifecycle_1.extractWorkflowIdentity)(ctx);
+            const activities = hotmesh_1.Durable.workflow.proxyActivities({
+                activities: interceptorActivities,
+                taskQueue: activityTaskQueue,
+                retryPolicy: { maximumAttempts: 3 },
+            });
+            // 2. Load config — unregistered workflows still get ToolContext
+            const wfConfig = await activities.ltGetWorkflowConfig(wf.workflowName);
+            if (!wfConfig) {
+                const envelope = (0, state_1.extractEnvelope)(ctx);
+                const toolCtx = (0, envelope_1.buildToolContextFromEnvelope)(envelope, wf.workflowId, wf.workflowTrace, wf.workflowSpan);
+                return toolCtx ? (0, context_2.runWithToolContext)(toolCtx, next) : next();
+            }
+            const envelope = (0, state_1.extractEnvelope)(ctx);
+            const taskQueue = (0, lifecycle_1.deriveTaskQueue)(wf);
+            // 3. Find existing task and handle re-run escalation resolution
+            const existingTask = await activities.ltGetTaskByWorkflowId(wf.workflowId);
+            const reRun = await (0, lifecycle_1.resolveReRun)(activities, envelope, existingTask, wf, taskQueue);
+            // 4. Ensure task exists with routing and origin lineage
+            const { taskId, routing, originId } = await (0, lifecycle_1.ensureTaskWithRouting)(activities, wf, envelope, existingTask, taskQueue, reRun);
+            // 5. Publish lifecycle events
+            (0, lifecycle_1.publishStartedEvents)(wf, taskQueue, taskId, originId);
+            // 6. Build state and execute workflow with interception
+            const state = {
+                workflowId: wf.workflowId,
+                workflowName: wf.workflowName,
+                taskQueue,
+                wfConfig,
+                defaultRole,
+                taskId,
+                routing,
+                envelope,
+                isReRun: reRun.isReRun,
+                activities,
+                traceId: wf.workflowTrace,
+                spanId: wf.workflowSpan,
+            };
+            try {
+                const orchCtx = { workflowId: wf.workflowId, taskQueue, workflowType: wf.workflowName, userId: envelope?.lt?.userId };
+                // Build ToolContext from envelope principal (no DB call — resolved at front door)
+                const toolCtx = (0, envelope_1.buildToolContextFromEnvelope)(envelope, wf.workflowId, wf.workflowTrace, wf.workflowSpan);
+                // Nest both contexts: OrchestratorContext (for executeLT routing)
+                // and ToolContext (for universal identity access in activities)
+                const wrappedNext = toolCtx
+                    ? () => (0, context_2.runWithToolContext)(toolCtx, next)
+                    : next;
+                const result = await (0, context_1.runWithOrchestratorContext)(orchCtx, wrappedNext);
+                if (result?.type === 'escalation') {
+                    return (0, escalation_1.handleEscalation)(state, result);
+                }
+                if (result?.type === 'return') {
+                    return (0, completion_1.handleCompletion)(state, result);
+                }
+                // Plain return (e.g., orchestrators returning raw results)
+                await (0, lifecycle_1.completePlainResult)(activities, wf, taskQueue, taskId, routing, result);
+                return result;
+            }
+            catch (err) {
+                if (hotmesh_1.Durable.workflow.didInterrupt(err))
+                    throw err;
+                return (0, escalation_1.handleErrorEscalation)(state, err);
+            }
+        },
+    };
+    return interceptor;
+}

package/build/services/interceptor/lifecycle.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Interceptor lifecycle helpers.
+ *
+ * Extracted from the main execute() function so the interceptor
+ * reads as a high-level pipeline. Each helper handles one phase
+ * of the workflow lifecycle.
+ */
+import type { LTEnvelope } from '../../types';
+import type { ProxiedActivities } from './state';
+import type { WorkflowIdentity, TaskContext } from './types';
+/** Result of re-run detection and escalation resolution. */
+interface ReRunContext {
+    isReRun: boolean;
+    task: any | null;
+    metadata: Record<string, any> | null;
+}
+/** Extract workflow identity fields from the HotMesh context map. */
+export declare function extractWorkflowIdentity(ctx: Map<string, any>): WorkflowIdentity;
+/** Derive the task queue from the workflow topic. */
+export declare function deriveTaskQueue(wf: WorkflowIdentity): string;
+/**
+ * Detect re-runs and resolve the prior escalation.
+ *
+ * A re-run occurs when `envelope.resolver` + `envelope.lt.escalationId`
+ * are both present — meaning a human (or AI) resolved an escalation
+ * and a new workflow was started with the resolver data.
+ */
+export declare function resolveReRun(activities: ProxiedActivities, envelope: LTEnvelope | undefined, existingTask: any | null, wf: WorkflowIdentity, taskQueue: string): Promise<ReRunContext>;
+/**
+ * Ensure a task record exists and resolve routing + origin lineage.
+ *
+ * Handles three cases:
+ * - Task already exists (from executeLT pre-creation) → use it
+ * - Re-run task found by escalation context → reuse it
+ * - No task → create a standalone task
+ *
+ * Also injects originId back into the envelope for downstream consistency.
+ */
+export declare function ensureTaskWithRouting(activities: ProxiedActivities, wf: WorkflowIdentity, envelope: LTEnvelope | undefined, existingTask: any | null, taskQueue: string, reRun: ReRunContext): Promise<TaskContext>;
+/** Publish workflow.started + task.started events. */
+export declare function publishStartedEvents(wf: WorkflowIdentity, taskQueue: string, taskId: string | undefined, originId: string): void;
+/** Complete a task and signal parent for plain (non-LTReturn) results. */
+export declare function completePlainResult(activities: ProxiedActivities, wf: WorkflowIdentity, taskQueue: string, taskId: string | undefined, routing: Record<string, any> | null, result: any): Promise<void>;
+export {};