@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7194.1.ab4fc81f82

package/dist/modules/workflows/lib/step-handler.js

@@ -1,12 +1,41 @@
 import {
+  WorkflowInstance,
+  WorkflowDefinition,
   StepInstance,
   UserTask,
   WorkflowEvent
 } from "../data/entities.js";
-import { parseDuration } from "./duration.js";
+import { emitWorkflowsEvent } from "../events.js";
+import { calculateDueDate, parseDuration } from "./duration.js";
+import {
+  CONDITION_STEP_TYPE,
+  conditionReadContext,
+  evaluateConditionExpression,
+  readWaitForConditionConfig
+} from "./condition-handler.js";
+import { mapAgentResultToContext } from "./agent-result-mapping.js";
+import {
+  WORKFLOW_AGENT_OUTCOME_CONTEXT_KEY,
+  buildAgentOutcomeContextEntry,
+  mapDispositionToAgentOutcome
+} from "./outcome-routing.js";
 import { logWorkflowEvent } from "./event-logger.js";
+import { DRY_RUN_EVENT_TYPES, isDryRunInstance } from "./dry-run.js";
 import { findDefinitionForInstance } from "./find-definition.js";
+import { resolveDefinitionInterpolationMode } from "./interpolation-pipeline.js";
+import {
+  collectResolvedEntityTypes,
+  flattenTaskText,
+  resolveTaskAssignment,
+  resolveTaskDeadlineDuration,
+  resolveTaskDecisions,
+  resolveTaskEntityBindings,
+  resolveTaskText
+} from "./task-resolution.js";
+import { scheduleUserTaskSla } from "./task-sla.js";
 import { createLogger } from "@open-mercato/shared/lib/logger";
+import { findWorkflowDefinition } from "./find-definition.js";
+import { validateAgainstPorts } from "./port-contract.js";
 const logger = createLogger("workflows");
 class StepExecutionError extends Error {
   constructor(message, code, details) {
@@ -66,6 +95,33 @@ async function enterStep(em, instance, stepId, context, branch) {
   });
   return stepInstance;
 }
+async function emitStepMilestone(em, stepInstance) {
+  try {
+    const instance = await em.findOne(WorkflowInstance, { id: stepInstance.workflowInstanceId });
+    if (!instance) return;
+    const definition = await em.findOne(WorkflowDefinition, { id: instance.definitionId });
+    const stepDef = definition?.definition?.steps?.find((step) => step.stepId === stepInstance.stepId);
+    const milestoneKey = typeof stepDef?.milestone === "string" ? stepDef.milestone : null;
+    if (!milestoneKey) return;
+    await emitWorkflowsEvent(
+      "workflows.instance.milestone_reached",
+      {
+        instanceId: instance.id,
+        workflowId: instance.workflowId,
+        milestoneKey,
+        // For the trace only. A consumer matches on `milestoneKey`; matching on
+        // the step is exactly the coupling the milestone model removes.
+        stepId: stepInstance.stepId,
+        occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
+        data: stepInstance.outputData ?? null,
+        tenantId: instance.tenantId,
+        organizationId: instance.organizationId
+      },
+      { persistent: true }
+    );
+  } catch {
+  }
+}
 async function exitStep(em, stepInstance, outputData) {
   const now = /* @__PURE__ */ new Date();
   let executionTimeMs = null;
@@ -91,6 +147,29 @@ async function exitStep(em, stepInstance, outputData) {
     tenantId: stepInstance.tenantId,
     organizationId: stepInstance.organizationId
   });
+  await emitStepMilestone(em, stepInstance);
+}
+async function markStepInstanceFailed(em, stepInstance, failure) {
+  if (stepInstance.status === "FAILED") return;
+  const now = /* @__PURE__ */ new Date();
+  stepInstance.status = "FAILED";
+  stepInstance.errorData = {
+    error: failure.error,
+    details: failure.details ?? void 0
+  };
+  stepInstance.exitedAt = now;
+  stepInstance.updatedAt = now;
+  await em.flush();
+  await logStepEvent(em, {
+    workflowInstanceId: stepInstance.workflowInstanceId,
+    stepInstanceId: stepInstance.id,
+    ...failure.branchInstanceId ? { branchInstanceId: failure.branchInstanceId } : {},
+    eventType: "STEP_FAILED",
+    eventData: { stepId: stepInstance.stepId, error: failure.error },
+    ...failure.userId ? { userId: failure.userId } : {},
+    tenantId: stepInstance.tenantId,
+    organizationId: stepInstance.organizationId
+  });
 }
 async function executeStep(em, instance, stepId, context, container, branch) {
   try {
@@ -116,12 +195,23 @@ async function executeStep(em, instance, stepId, context, container, branch) {
       instance,
       stepInstance,
       stepDef,
-      context,
+      {
+        ...context,
+        interpolationMode: resolveDefinitionInterpolationMode(definition.definition),
+        workflowName: definition.workflowName
+      },
       container,
       branch
     );
     if (result.status === "COMPLETED") {
       await exitStep(em, stepInstance, result.outputData);
+    } else if (result.status === "FAILED") {
+      await markStepInstanceFailed(em, stepInstance, {
+        error: result.error ?? "Step execution failed",
+        details: result.outputData,
+        branchInstanceId: branch?.id ?? null,
+        userId: context.userId
+      });
     }
     return result;
   } catch (error) {
@@ -133,21 +223,11 @@ async function executeStep(em, instance, stepId, context, container, branch) {
         status: "ACTIVE"
       });
       if (failedStepInstance) {
-        failedStepInstance.status = "FAILED";
-        failedStepInstance.errorData = {
+        await markStepInstanceFailed(em, failedStepInstance, {
           error: errorMessage,
-          details: error instanceof StepExecutionError ? error.details : void 0
-        };
-        failedStepInstance.exitedAt = /* @__PURE__ */ new Date();
-        failedStepInstance.updatedAt = /* @__PURE__ */ new Date();
-        await em.flush();
-        await logStepEvent(em, {
-          workflowInstanceId: instance.id,
-          stepInstanceId: failedStepInstance.id,
-          eventType: "STEP_FAILED",
-          eventData: { error: errorMessage },
-          tenantId: instance.tenantId,
-          organizationId: instance.organizationId
+          details: error instanceof StepExecutionError ? error.details : void 0,
+          branchInstanceId: branch?.id ?? null,
+          userId: context.userId
         });
       }
     } catch (updateError) {
@@ -179,10 +259,15 @@ async function executeStepByType(em, instance, stepInstance, stepDef, context, c
         );
       }
       return await handleSubWorkflowStep(em, container, instance, stepInstance, stepDef, context);
+    case "IF_ELSE":
+    case "SWITCH":
+      return handleBranchingStep(stepType);
     case "WAIT_FOR_SIGNAL":
       return await handleWaitForSignalStep(em, instance, stepInstance, stepDef, context, branch);
     case "WAIT_FOR_TIMER":
       return await handleWaitForTimerStep(em, instance, stepInstance, stepDef, context, branch);
+    case "WAIT_FOR_CONDITION":
+      return await handleWaitForConditionStep(em, instance, stepInstance, stepDef, context, branch);
     case "PARALLEL_FORK": {
       if (branch) {
         throw new StepExecutionError(
@@ -232,6 +317,15 @@ function handleEndStep(stepDef, context) {
     }
   };
 }
+function handleBranchingStep(stepType) {
+  return {
+    status: "COMPLETED",
+    outputData: {
+      stepType,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
 async function handleAutomatedStep(em, instance, stepInstance, stepDef, context, container, branch) {
   const activities = stepDef.activities || [];
   if (activities.length === 0) {
@@ -243,14 +337,34 @@ async function handleAutomatedStep(em, instance, stepInstance, stepDef, context,
       }
     };
   }
-  const { executeActivities } = await import("./activity-executor.js");
+  const { executeActivities, interpolateVariables } = await import("./activity-executor.js");
+  const agentActivity = activities.find(
+    (activity) => activity.activityType === "INVOKE_AGENT" && activity?.config?.input !== void 0
+  );
+  if (agentActivity) {
+    try {
+      const resolvedInput = interpolateVariables(
+        agentActivity.config.input,
+        context.workflowContext,
+        instance,
+        { mode: context.interpolationMode }
+      );
+      if (resolvedInput !== void 0) {
+        stepInstance.inputData = resolvedInput;
+        stepInstance.updatedAt = /* @__PURE__ */ new Date();
+        await em.flush();
+      }
+    } catch {
+    }
+  }
   try {
     const results = await executeActivities(em, container, activities, {
       workflowInstance: instance,
       workflowContext: context.workflowContext,
       stepContext: { stepId: stepDef.stepId, stepName: stepDef.stepName },
       stepInstanceId: stepInstance.id,
-      userId: context.userId
+      userId: context.userId,
+      interpolationMode: context.interpolationMode
     });
     const pendingActivities = results.filter((r) => r.async && !r.success);
     if (pendingActivities.length > 0) {
@@ -293,6 +407,78 @@ async function handleAutomatedStep(em, instance, stepInstance, stepDef, context,
         }
       };
     }
+    const parkResult = results.find((r) => r.output && r.output.__park);
+    if (parkResult) {
+      const signalName = parkResult.output.__park.signalName;
+      const proposalId = parkResult.output.proposalId;
+      const now = /* @__PURE__ */ new Date();
+      await logStepEvent(em, {
+        workflowInstanceId: instance.id,
+        stepInstanceId: stepInstance.id,
+        ...branch ? { branchInstanceId: branch.id } : {},
+        eventType: "SIGNAL_AWAITING",
+        eventData: { signalName, proposalId, reason: "INVOKE_AGENT" },
+        userId: context.userId,
+        tenantId: instance.tenantId,
+        organizationId: instance.organizationId
+      });
+      if (branch) {
+        branch.status = "PAUSED";
+        branch.updatedAt = now;
+      } else {
+        instance.status = "PAUSED";
+        instance.pausedAt = now;
+        instance.updatedAt = now;
+      }
+      await em.flush();
+      return {
+        status: "WAITING",
+        waitReason: "SIGNAL",
+        outputData: { signalName, proposalId, awaitingSince: now }
+      };
+    }
+    const inlineAgent = results.find(
+      (r) => r.output && typeof r.output.kind === "string" && "agentId" in r.output
+    );
+    if (inlineAgent && !branch) {
+      const out = inlineAgent.output;
+      const agentActivity2 = activities.find(
+        (a) => a.activityType === "INVOKE_AGENT" && a.activityId === inlineAgent.activityId
+      );
+      const mappedPatch = mapAgentResultToContext(
+        {
+          kind: out.kind,
+          agentId: out.agentId,
+          proposalId: out.proposalId,
+          proposalPayload: out.proposalPayload,
+          data: out.data,
+          artifacts: out.artifacts
+        },
+        agentActivity2?.config?.outputMapping
+      );
+      const contextPatch = mappedPatch ?? (out.kind === "auto_approved" ? {
+        disposition: "auto_approved",
+        agentProposalId: out.proposalId,
+        proposalPayload: out.proposalPayload
+      } : out.kind === "artifact" ? {
+        disposition: "researcher",
+        [`${stepInstance.stepId}_agent`]: { artifacts: out.artifacts, summary: out.summary }
+      } : null);
+      const resolvedOutcome = mapDispositionToAgentOutcome(out.kind);
+      const outcomeMarker = resolvedOutcome ? {
+        [WORKFLOW_AGENT_OUTCOME_CONTEXT_KEY]: buildAgentOutcomeContextEntry(
+          stepInstance.stepId,
+          resolvedOutcome,
+          out.proposalId
+        )
+      } : null;
+      const nextContext = { ...instance.context, ...contextPatch ?? {}, ...outcomeMarker ?? {} };
+      if (contextPatch || outcomeMarker) {
+        instance.context = nextContext;
+        instance.updatedAt = /* @__PURE__ */ new Date();
+        await em.flush();
+      }
+    }
     const activityOutputs = results.reduce((acc, r) => {
       if (r.output) {
         acc[r.activityId] = r.output;
@@ -315,27 +501,159 @@ async function handleAutomatedStep(em, instance, stepInstance, stepDef, context,
     };
   }
 }
+function resolveUserTaskDeadline(stepId, slaDuration) {
+  try {
+    return calculateDueDate(slaDuration);
+  } catch (error) {
+    throw new StepExecutionError(
+      `Invalid user task deadline "${slaDuration}": ${error instanceof Error ? error.message : String(error)}`,
+      "INVALID_USER_TASK_DEADLINE",
+      { stepId, slaDuration }
+    );
+  }
+}
+async function emitTaskAssignedEvent(userTask, instance, context, quickAction) {
+  try {
+    await emitWorkflowsEvent(
+      "workflows.task.assigned",
+      {
+        // Everything the notification quick-action rule needs, and nothing more.
+        // ABSENT means "unknown", and the subscriber falls back to the deep
+        // link — a quick action must never be offered on a guess.
+        ...quickAction ? { quickAction } : {},
+        taskId: userTask.id,
+        taskName: userTask.taskName,
+        workflowInstanceId: instance.id,
+        workflowId: instance.workflowId,
+        workflowName: context.workflowName ?? instance.workflowId,
+        assignedUserId: userTask.assignedTo ?? null,
+        assignedToRoles: userTask.assignedToRoles ?? null,
+        dueDate: userTask.dueDate ? userTask.dueDate.toISOString() : null,
+        // Additive: the records the task is about. Modules that own those
+        // records subscribe and surface the task on their own turf — the
+        // customers module writes a `CustomerTodoLink` from this. Workflows
+        // never reaches into another module's tables to do it itself.
+        entityBindings: userTask.entityBindings ?? null,
+        tenantId: instance.tenantId,
+        organizationId: instance.organizationId ?? null
+      },
+      { persistent: true }
+    );
+  } catch (error) {
+    logger.error("Failed to emit workflows.task.assigned", {
+      component: "step-handler",
+      taskId: userTask.id,
+      err: error
+    });
+  }
+  if (userTask.assigneeKind !== "customer" || !userTask.assignedTo) return;
+  try {
+    await emitWorkflowsEvent(
+      "workflows.task.portal_assigned",
+      {
+        taskId: userTask.id,
+        recipientUserId: userTask.assignedTo,
+        tenantId: instance.tenantId,
+        organizationId: instance.organizationId ?? null
+      },
+      { persistent: false }
+    );
+  } catch (error) {
+    logger.error("Failed to emit workflows.task.portal_assigned", {
+      component: "step-handler",
+      taskId: userTask.id,
+      err: error
+    });
+  }
+}
 async function handleUserTaskStep(em, instance, stepInstance, stepDef, context, branch) {
   const userTaskConfig = stepDef.userTaskConfig || {};
-  let assignedTo = userTaskConfig.assignedTo || null;
-  let assignedToRoles = userTaskConfig.assignedToRoles || null;
-  if (Array.isArray(assignedTo)) {
-    assignedToRoles = assignedTo;
-    assignedTo = null;
+  const { interpolateVariables } = await import("./activity-executor.js");
+  const interpolate = (value) => interpolateVariables(value, context.workflowContext, instance);
+  const assignment = resolveTaskAssignment(userTaskConfig, interpolate);
+  if (assignment.fellBackToRoles) {
+    logger.warn("Dynamic task assignee resolved to nothing; falling back to the role queue", {
+      component: "step-handler",
+      stepId: stepDef.stepId,
+      workflowInstanceId: instance.id,
+      assignedToRoles: assignment.assignedToRoles
+    });
   }
+  if (assignment.fellBackFromCustomer) {
+    logger.warn("Portal task assignee resolved to nothing; task created for the backoffice instead", {
+      component: "step-handler",
+      stepId: stepDef.stepId,
+      workflowInstanceId: instance.id
+    });
+  }
+  const { bindings, unresolved } = resolveTaskEntityBindings(userTaskConfig.entityBindings, interpolate);
+  if (unresolved.length) {
+    logger.warn("Task entity bindings skipped because their ids did not resolve", {
+      component: "step-handler",
+      stepId: stepDef.stepId,
+      workflowInstanceId: instance.id,
+      unresolved
+    });
+  }
+  const taskName = String(interpolate(stepDef.stepName) ?? stepDef.stepName);
+  const instructions = resolveTaskText(userTaskConfig.instructions, interpolate);
+  const decisions = resolveTaskDecisions(userTaskConfig.decisions, interpolate);
+  const deadlineDuration = resolveTaskDeadlineDuration(userTaskConfig);
   const now = /* @__PURE__ */ new Date();
+  if (isDryRunInstance(instance)) {
+    await logStepEvent(em, {
+      workflowInstanceId: instance.id,
+      stepInstanceId: stepInstance.id,
+      ...branch ? { branchInstanceId: branch.id } : {},
+      eventType: DRY_RUN_EVENT_TYPES.userTaskSimulated,
+      eventData: {
+        taskName,
+        assignedTo: assignment.assignedTo,
+        assignedToRoles: assignment.assignedToRoles,
+        assigneeKind: assignment.assigneeKind,
+        ...bindings.length ? { entityBindings: bindings } : {},
+        ...decisions.length ? { decisions } : {},
+        ...deadlineDuration ? { deadlineDuration } : {}
+      },
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId
+    });
+    if (branch) {
+      branch.status = "PAUSED";
+      branch.updatedAt = now;
+    } else {
+      instance.status = "PAUSED";
+      instance.updatedAt = now;
+    }
+    await em.flush();
+    return {
+      status: "WAITING",
+      waitReason: "USER_TASK",
+      outputData: { simulated: true, wouldRaiseTask: taskName }
+    };
+  }
   const userTask = em.create(UserTask, {
     workflowInstanceId: instance.id,
     stepInstanceId: stepInstance.id,
     branchInstanceId: branch ? branch.id : null,
-    taskName: stepDef.stepName,
-    description: stepDef.description || null,
+    taskName,
+    description: flattenTaskText(instructions) ?? stepDef.description ?? null,
     status: "PENDING",
     formSchema: userTaskConfig.formSchema || null,
     formData: null,
-    assignedTo,
-    assignedToRoles,
-    dueDate: userTaskConfig.slaDuration ? calculateDueDate(userTaskConfig.slaDuration) : null,
+    assignedTo: assignment.assignedTo,
+    // Decided by `resolveTaskAssignment` from the authored `assigneeKind`, and
+    // `'customer'` only when an individual assignee actually resolved. Written
+    // explicitly rather than left to the column default so the discriminator is
+    // a decision at every creation site, not an accident.
+    assigneeKind: assignment.assigneeKind,
+    assignedToRoles: assignment.assignedToRoles,
+    entityBindings: bindings.length ? bindings : null,
+    // Denormalized from the SAME resolved bindings, so the two can never drift.
+    // Null for a task about nothing, which is what the vacuous-pass rule reads.
+    entityTypes: bindings.length ? collectResolvedEntityTypes(bindings) : null,
+    priority: userTaskConfig.priority ?? null,
+    dueDate: deadlineDuration ? resolveUserTaskDeadline(stepDef.stepId, deadlineDuration) : null,
     tenantId: instance.tenantId,
     organizationId: instance.organizationId,
     createdAt: now,
@@ -351,11 +669,32 @@ async function handleUserTaskStep(em, instance, stepInstance, stepDef, context,
       userTaskId: userTask.id,
       taskName: userTask.taskName,
       assignedTo: userTask.assignedTo,
-      assignedToRoles: userTask.assignedToRoles
+      assignedToRoles: userTask.assignedToRoles,
+      ...bindings.length ? { entityBindings: bindings } : {},
+      ...userTask.priority ? { priority: userTask.priority } : {},
+      ...decisions.length ? { decisions } : {},
+      ...assignment.fellBackToRoles ? { assignmentFallback: "roles" } : {}
     },
     tenantId: instance.tenantId,
     organizationId: instance.organizationId
   });
+  await emitTaskAssignedEvent(userTask, instance, context, {
+    decisions: decisions.map((decision) => ({ id: decision.id })),
+    formSchema: userTask.formSchema ?? null,
+    editablePrefilled: userTaskConfig.editablePrefilled ?? null
+  });
+  await scheduleUserTaskSla({
+    workflowInstanceId: instance.id,
+    stepInstanceId: stepInstance.id,
+    branchInstanceId: branch ? branch.id : null,
+    userTaskId: userTask.id,
+    dueDate: userTask.dueDate ?? null,
+    reminders: userTaskConfig.reminders ?? null,
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId,
+    userId: context.userId,
+    now
+  });
   if (branch) {
     branch.status = "PAUSED";
     branch.updatedAt = now;
@@ -380,9 +719,33 @@ async function handleSubWorkflowStep(em, container, instance, stepInstance, step
       error: "Sub-workflow ID not specified in step configuration"
     };
   }
-  const childContext = mapInputData(instance.context, inputMapping || {});
+  let childContext = mapInputData(instance.context, inputMapping || {});
   const { startWorkflow, executeWorkflow } = await import("./workflow-executor.js");
   try {
+    const childDefinition = await findWorkflowDefinition(em, {
+      workflowId: subWorkflowId,
+      version,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId
+    });
+    const ioContract = childDefinition?.definition?.io;
+    if (ioContract?.inputs?.length) {
+      const { coerced, errors } = validateAgainstPorts(childContext, ioContract.inputs);
+      if (errors.length > 0) {
+        const message = `Sub-workflow input validation failed: ${errors.map((e) => e.message).join("; ")}`;
+        await logStepEvent(em, {
+          workflowInstanceId: instance.id,
+          stepInstanceId: stepInstance.id,
+          eventType: "SUB_WORKFLOW_FAILED",
+          eventData: { subWorkflowId, reason: "INPUT_VALIDATION", error: message },
+          userId: context.userId,
+          tenantId: instance.tenantId,
+          organizationId: instance.organizationId
+        });
+        return { status: "FAILED", error: message };
+      }
+      childContext = coerced;
+    }
     const childInstance = await startWorkflow(em, {
       workflowId: subWorkflowId,
       version,
@@ -418,7 +781,20 @@ async function handleSubWorkflowStep(em, container, instance, stepInstance, step
       userId: context.userId
     });
     if (result.status === "COMPLETED") {
-      const outputData = mapOutputData(result.context, outputMapping || {});
+      const mapped = mapSubWorkflowOutput(result.context, outputMapping || {}, ioContract);
+      if (mapped.error) {
+        await logStepEvent(em, {
+          workflowInstanceId: instance.id,
+          stepInstanceId: stepInstance.id,
+          eventType: "SUB_WORKFLOW_FAILED",
+          eventData: { childInstanceId: childInstance.id, reason: "OUTPUT_VALIDATION", error: mapped.error },
+          userId: context.userId,
+          tenantId: instance.tenantId,
+          organizationId: instance.organizationId
+        });
+        return { status: "FAILED", error: mapped.error };
+      }
+      const outputData = mapped.outputData;
       await logStepEvent(em, {
         workflowInstanceId: instance.id,
         stepInstanceId: stepInstance.id,
@@ -453,9 +829,29 @@ async function handleSubWorkflowStep(em, container, instance, stepInstance, step
         error: `Sub-workflow failed: ${result.errors?.join(", ")}`
       };
     } else {
+      const { SUB_WORKFLOW_SIGNAL_NAME } = await import("./activity-executor.js");
+      const now = /* @__PURE__ */ new Date();
+      await logStepEvent(em, {
+        workflowInstanceId: instance.id,
+        stepInstanceId: stepInstance.id,
+        eventType: "SIGNAL_AWAITING",
+        eventData: {
+          signalName: SUB_WORKFLOW_SIGNAL_NAME,
+          childInstanceId: childInstance.id,
+          reason: "SUB_WORKFLOW"
+        },
+        userId: context.userId,
+        tenantId: instance.tenantId,
+        organizationId: instance.organizationId
+      });
+      instance.status = "PAUSED";
+      instance.pausedAt = now;
+      instance.updatedAt = now;
+      await em.flush();
       return {
-        status: "FAILED",
-        error: `Sub-workflow ended in unexpected state: ${result.status}`
+        status: "WAITING",
+        waitReason: "SIGNAL",
+        outputData: { childInstanceId: childInstance.id }
       };
     }
   } catch (error) {
@@ -601,6 +997,92 @@ async function handleWaitForTimerStep(em, instance, stepInstance, stepDef, conte
     }
   };
 }
+async function handleWaitForConditionStep(em, instance, stepInstance, stepDef, context, branch) {
+  const config = readWaitForConditionConfig(stepDef);
+  const data = {
+    ...conditionReadContext(instance, branch ?? null),
+    ...context.workflowContext || {}
+  };
+  const met = await evaluateConditionExpression({
+    condition: config.condition,
+    data,
+    instanceId: instance.id,
+    userId: context.userId
+  });
+  const now = /* @__PURE__ */ new Date();
+  if (met) {
+    await logWorkflowEvent(em, {
+      workflowInstanceId: instance.id,
+      stepInstanceId: stepInstance.id,
+      ...branch ? { branchInstanceId: branch.id } : {},
+      eventType: "CONDITION_MET",
+      eventData: { stepId: stepDef.stepId, attempts: 1, waitedMs: 0, wokenBy: "immediate" },
+      userId: context.userId,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId
+    });
+    return {
+      status: "COMPLETED",
+      outputData: {
+        stepType: CONDITION_STEP_TYPE,
+        conditionMet: true,
+        attempts: 1,
+        waitedMs: 0,
+        wokenBy: "immediate"
+      }
+    };
+  }
+  const deadlineAt = new Date(now.getTime() + config.timeoutMs);
+  const { enqueueConditionCheckJob } = await import("./activity-executor.js");
+  const jobId = await enqueueConditionCheckJob({
+    workflowInstanceId: instance.id,
+    stepInstanceId: stepInstance.id,
+    branchInstanceId: branch ? branch.id : void 0,
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId,
+    userId: context.userId,
+    deadlineAt: deadlineAt.toISOString(),
+    attempt: 1,
+    delayMs: Math.min(config.pollIntervalMs, config.timeoutMs)
+  });
+  await logWorkflowEvent(em, {
+    workflowInstanceId: instance.id,
+    stepInstanceId: stepInstance.id,
+    ...branch ? { branchInstanceId: branch.id } : {},
+    eventType: "CONDITION_AWAITING",
+    eventData: {
+      stepId: stepDef.stepId,
+      condition: config.condition,
+      deadlineAt: deadlineAt.toISOString(),
+      pollIntervalMs: config.pollIntervalMs,
+      onTimeout: config.onTimeout,
+      jobId
+    },
+    userId: context.userId,
+    tenantId: instance.tenantId,
+    organizationId: instance.organizationId
+  });
+  if (branch) {
+    branch.status = "PAUSED";
+    branch.updatedAt = now;
+  } else {
+    instance.status = "PAUSED";
+    instance.pausedAt = now;
+    instance.updatedAt = now;
+  }
+  await em.flush();
+  return {
+    status: "WAITING",
+    waitReason: "CONDITION",
+    outputData: {
+      stepType: CONDITION_STEP_TYPE,
+      deadlineAt: deadlineAt.toISOString(),
+      pollIntervalMs: config.pollIntervalMs,
+      onTimeout: config.onTimeout,
+      jobId
+    }
+  };
+}
 async function logStepEvent(em, event) {
   const workflowEvent = em.create(WorkflowEvent, {
     ...event,
@@ -609,25 +1091,6 @@ async function logStepEvent(em, event) {
   await em.persist(workflowEvent).flush();
   return workflowEvent;
 }
-function calculateDueDate(duration) {
-  const now = /* @__PURE__ */ new Date();
-  const daysMatch = duration.match(/P(\d+)D/);
-  if (daysMatch) {
-    const days = parseInt(daysMatch[1], 10);
-    return new Date(now.getTime() + days * 24 * 60 * 60 * 1e3);
-  }
-  const hoursMatch = duration.match(/PT(\d+)H/);
-  if (hoursMatch) {
-    const hours = parseInt(hoursMatch[1], 10);
-    return new Date(now.getTime() + hours * 60 * 60 * 1e3);
-  }
-  const weeksMatch = duration.match(/P(\d+)W/);
-  if (weeksMatch) {
-    const weeks = parseInt(weeksMatch[1], 10);
-    return new Date(now.getTime() + weeks * 7 * 24 * 60 * 60 * 1e3);
-  }
-  return new Date(now.getTime() + 24 * 60 * 60 * 1e3);
-}
 function getNestedValue(obj, path) {
   return path.split(".").reduce((current, key) => current?.[key], obj);
 }
@@ -660,10 +1123,23 @@ function mapOutputData(childContext, mapping) {
   }
   return Object.keys(result).length > 0 ? result : childContext;
 }
+function mapSubWorkflowOutput(childContext, outputMapping, ioContract) {
+  let outputData = mapOutputData(childContext, outputMapping || {});
+  if (ioContract?.outputs?.length) {
+    const { coerced, errors } = validateAgainstPorts(outputData, ioContract.outputs);
+    if (errors.length > 0) {
+      return { error: `Sub-workflow output validation failed: ${errors.map((e) => e.message).join("; ")}` };
+    }
+    outputData = coerced;
+  }
+  return { outputData };
+}
 export {
   StepExecutionError,
   enterStep,
   executeStep,
-  exitStep
+  exitStep,
+  mapSubWorkflowOutput,
+  markStepInstanceFailed
 };
 //# sourceMappingURL=step-handler.js.map