what we need to do is:

instead of reading from stdin all at once until EOL,
we should read one character at a time, and evaluate
callbacks in between each letter of input. this may
be achieved by using the 'read' command set at one byte
instead of the 'gets' commands. when the callbacks are
evaluated (such as we get an IM_IN...), if one is
recieved, the input should be cleared to the beginning
of the line (we may have to use ANSI... or tput) and
the callback should be printed. then the input thus far
should be placed on the next line, with no newline, and
continue to read until another callback or EOL, one letter
at a time. a trick may be determining EOL when we use
'read.'

it is good that tac_output is used instead of puts directly
because we can change the condition that checks for
the TAC(input) and displays it or adds it to TAC(output)
for later output. instead of later ouptut, we may want to
output it right away, with the clearing and re-placing of
output as described above. we may also try this method without
changing the gets to a read, and see how that works. since i
think the gets will wait until EOL regardless of callbacks,
it is possible that nothing will happen, except maybe the
messages will appear out of order. but if that isn't true, then
the framework of my ideal UI is already there, and all we need
are some good screen control functions. hopefully, some will
present themselves before long. ANSI seems to be one alternative,
although it isn't supported by ALL terminals (especially those in
non-UNIX platforms). if ANSI-escapes were used, some users would
see garbage and others would work well. this isn't good at all.

there could be an ansi and a non-ansi client in the distribution,
but if we're going to do that, then why not just make a tcl-curses
one instead? maybe that's a good idea...