I see your concern about not wanting to include <strio.c>, though in this particular case, you'd save yourself some work by allowing that one.
If you prefer, you can also just copy str_replaceall from that file into your script (and everything that particular one needs - I haven't looked at it).
If you'd rather do that yourself, then you should look at the str_cpy, str_cat, str_clip, str_trunc and str_stri - instructions. Or, if you'd rather go on a "per-character" level, check out str_setchr and str_getchr (and note that str_setchr requires a var - if you want to use a char, you have to cast it to int first).
~ ~ ~
Okay, let's look at your code, starting with this line:
STRING* emptystring_str = "";
First, a note - as I've said, this is lite-c only. You normally wouldn't be able to initialize that this way. But that's really just a note - it's okay here.
But let's think about that: You've created a string-pointer (thats really just what you'd expect after writing STRING*), and you've asked lite-c to create a new string object for you, that holds, in your case, a maximum of... zero characters.
Alright, so what happens? If you create this stuff, your computer needs to get some area of memory for it. It then "marks" that area as used, and the STRING* points to that (meaning: It holds now the adress of that particular memory block).
As a side note here, it used to be so that you couldn't exceed the length of the original string (in fact, only by checking the manual just now did I learn that this limit no longer exists.

Learn something new everyday!)
Okay, so let's summarize this. emptystring_str is a
pointer. It is not the object itself. Think of it as the adress in memory (which is really just a number). Cool beans.
Actually, while I'm rather confident as to what the error is in your code, I'd be lying if I said that I'm 100% sure in every detail in the explanation below. After all, I just learnt that strings behave differently from what I'm used to (I only "recently" switched to A8). I provide it anyhow, but please understand that I'm far from an expert. 
emptystring_str = blabla enemy name;
Now, what does this do? You set the POINTER, that, well, just points to something to something else. After this line, emptystring_str points to whatever "blabla enemy name" pointed. Let's have an example.
Consider this scenario:
STRING* str1;
STRING* str2;
Let's assume they are both correctly initialized. Also, let's assume that str1 points to memory adress 100, where the string "Bananas" is stored. str2 points to memory adress 200, where we can find "Apples".
If you now write:
str1 = str2;
then you only changed the memory adresses those things point to.
str1 now points to memory adress 200 as well. If you read it out, you'll get "Apples", but it's really THE SAME "Apples" as str2 holds. If you CHANGE str2 afterwards:
str_cpy(str2,"Cherries");
then you changed the memory area, and reading out str2 will result in "Cherries". Since str1 points to the same area, if you now read out str1, you'll get "Cherries" as well. So the fate of "Apples" was that that bit got overwritten with "Cherries". Is... Is that bad? I don't know how things go in Fruit land.
What happens with "Bananas"? Good question. It's sitting in memory, it's flagged as being used, and there's no way to access it ever again. It's wasted memory. You don't get it back. A memory leak! Oh no!
Instead, if you work with strings, always, always use the str_-functions, unless you're 100% sure you want to do something with the pointers (as opposed to their content).
So here, what you'd do is:
str_cpy(emptystring_str, blbalba enemy name);
I'll spare you the "BUT BE SURE ENEMY NAME IS DEFINED"-stuff, and I also refrain from noting that emptystring_str is totally not empty anymore after one such instruction

You wouldn't have to go via the two strings in your TEXT*-object, if you don't want to. You could also go:
str_cpy(emptystring_str,"Name:\n");
str_cat(emptystring_str,enemy_name);
But, you know. Perhaps you prefer your way.
Of course, if you're really crafty, you can just keep emptystring_str to be JUST a pointer, with no actual object behind it, and then point that STRING-pointer to whereever the enemy_names are stored. In that case, you couldn't use a TEXT*-object like that. But have you seen draw_text ?
This is a bit more complicated, and depending on your code structure involves some work, but it allows you to save a bit of memory. ... But of course, it's not like you're "wasting" any amount that one notices on a modern computer.