Let me assume that you are concerned with ordinal time Turing
machines, using a tape of order type Ord.

My first observation is that the accidentally writable reals are
exactly the constructible reals.

**Theorem.** The OTM accidentally writable reals are exactly the
constructible reals, that is, the reals in $\mathbb{R}^L$.

**Proof.** The forward inclusion holds because all the OTM
computations can be undertaken inside $L$, and so whatever it is
that appears on the tape at any moment for them will necessarily be
in $L$. So every accidentally writable real is in $L$.

Conversely, we use the fact that the machines are able to simulate
the constructibility hierarchy. With a suitable choice of finitely
many ordinal parameters, the machines can construct a code for any
desired level of the $L_\alpha$ hierarchy and pick out the code for
any particular constructible set. In particular, with suitable
parameters, one can produce any given constructible real on the
tape. And now the point is that we can design a program that
systematically does this for all possible choice of ordinal
parameters. The universal algorithm will simply iteratively
increase a master ordinal, interpreting it as a code for a finite
tuple of ordinals, and carry out the construction that far. So
every particular constructible real will appear on the tape during
this universal procedure. $\Box$

In particular, the supremum of the OTM accidentally writable reals
will be exactly $\omega_1^L$.

Meanwhile, there are only countably-in-$L$ many programs and
therefore only countably many eventually writable reals, since each
one can be associated with the program giving rise to it. So
$\eta<\omega_1^L$.

The rest of your question appears to concern an algorithm that will
in part somehow store the value of $\omega_1^L$. Let us discuss how
this can be done. Since this is a machine model with only a tape
and no registers to store the value in, let me assume that you
intend to place a special mark at position $\omega_1^L$ on the
tape, in such a way that you can recognized that it has been so
marked. Let us say that position $\alpha$ on the tape is
*eventually markable* if there is an algorithm that eventually
places a $1$ at position $\alpha$, followed by a certain unique
finite pattern of marks, which eventually does not appear anywhere
else on the tape. If our tape allows a bigger alphabet, we could
say more simply that $\alpha$ is eventually markable if there is an
algorithm that (on empty input) eventually stabilizes with a red
check mark on position $\alpha$ and no other red check marks. Or we
can think of the special finite pattern as the red check mark.

**Theorem.** The ordinal $\omega_1^L$ is eventually markable.

**Proof.** The ordinal $\omega_1^L$ is the least ordinal that is
never coded by any real in $L$. So we can simply search for an
ordinal that will pass that test. We gradually consider ordinal
positions in turn. For every ordinal, we temporarily place a red
check mark at it, until we find a real coding it (this uses the
count-through algorithm to count to the position coded by any
relation coded with a real). When an ordinal is revealed as
countable in this way, then we move on to the next ordinal, erasing
the previous red mark and placing the next one. At limits of these
stages, the head will be in a position at the supremum of the
previous red marks. And so we will eventually place a red mark at
$\omega_1^L$, never afterward to change it. So $\omega_1^L$ is
eventually markable. $\Box$

The next part of your algorithm is to look at the eventually
writable reals that stabilize in time $\omega_1^L$, by using
simulations that proceed up to that red mark. This seems right to
me. More generally:

**Theorem.** If $\alpha$ is eventually markable, then the supremum
of the ordinals coded by reals that stabilize in time $\alpha$ is
eventually writable.

**Proof.** Consider the program that eventually marks $\alpha$. At
each stage, this algorithm is giving us a putative copy $\alpha_0$
of $\alpha$, which is eventually correct. For each $\alpha_0$ that
appears during the computation, let us run a simulation of all
programs on empty input, running them for $\alpha_0$ many steps. We
can arrange to inspect this computation to see if the output had
stabilized before $\alpha_0$, and in this way, we can compute a
list of all the reals that are
eventually-in-time-$\alpha_0$-writable. We can then check which
code a well-order, and then write down a real coding the supremum
of these ordinals. If at any moment, the red check mark changes,
then we start completely over with the new $\alpha_0$. Eventually,
$\alpha_0$ will be $\alpha$ itself, and we will stabilize on a real
coding the supremum of the eventually-in-time-$\alpha$-writable
ordinals, as desired. $\Box$

In particular, if we use $\alpha=\omega_1^L$, then we will
eventually write a real coding the supremum of the ordinals coded
by an eventually-in-time-$\omega_1^L$-writable real. It seems to me
that ultimately, the algorithm you are proposing is writing down
exactly the supremum of the
eventually-in-time-$\omega_1^L$-writable ordinals, and this is
strictly less than $\eta$.

In particular, it follows from what we've said so far that
eventually writable reals do not stabilize in time $\omega_1^L$.

**Corollary.** Not all algorithms producing eventually writable reals stabilize in time $\omega_1^L$.

But actually, it is a bit easier to see that there are computations
whose first $\omega$ cells eventually stabilize, but not by any
stage before $\omega_1^L$. To see this, consider the algorithm that
is eventually marking position $\omega_1^L$. Do not write on the
first $\omega$ many cells, except when you change the red check
mark, and then flash a $1$ and then $0$ on the first cell. This
algorithm will eventually stabilize with its red check mark at
position $\omega_1^L$, after which time it will no longer flash
anything in the first $\omega$ cells. So this is an algorithm that
writes an eventually writable real, but it does not stabilize
before time $\omega_1^L$.