Solution

Answer: 319.30207833

Let $E(s)$ denote the expected final value when the current written string is the Roman-numeral prefix $s$.

The key observation is:

If appending a letter keeps the string a valid prefix of a minimal Roman numeral, we move to the new state.
Otherwise that letter is ignored.
When # appears (probability $0.02$), we stop immediately.

The Roman numerals in minimal form have the standard decomposition

$$M^a \cdot H \cdot T \cdot O$$

where:

$a \ge 0$,
$H \in { "", C, CC, CCC, CD, D, DC, DCC, DCCC, CM }$,
$T \in { "", X, XX, XXX, XL, L, LX, LXX, LXXX, XC }$,
$O \in { "", I, II, III, IV, V, VI, VII, VIII, IX }$.

So the entire language of valid numerals is a finite prefix automaton, except for the unbounded leading $M$'s.

1. Recurrence

Suppose a state $s$ has value $v(s)$, and $k$ valid next letters.

Then

$$E(s) = 0.02,v(s) + 0.14\sum_{t} E(t) + (0.98-0.14k)E(s)$$

where the sum runs over all valid next states $t$.

Rearranging:

$$(0.02+0.14k)E(s) = 0.02,v(s)+0.14\sum_t E(t)$$

and dividing by $0.02$,

$$(1+7k)E(s) = v(s)+7\sum_t E(t).$$

Thus

$$\boxed{ E(s)=\frac{v(s)+7\sum_t E(t)}{1+7k} }$$

for every nonempty suffix state.

2. Handling the infinite $M$-chain

Let the current numeral be

$$M^a s$$

where $s$ contains no $M$.

Write

$$E(M^a s)=1000a+F(s).$$

Substituting into the recurrence shows the dependence on $a$ cancels completely, leaving a finite system for the suffix states $s$.

For the empty suffix state:

$$F(\varepsilon) = \frac{7000+7\sum F(t)}{43}$$

where the sum is over the six one-letter starts

$$I,V,X,L,C,D.$$

All other states satisfy the finite recurrence above.

3. Python implementation

from functools import lru_cache

# Minimal Roman blocks
ones = ["", "I", "II", "III", "IV",
        "V", "VI", "VII", "VIII", "IX"]

tens = ["", "X", "XX", "XXX", "XL",
        "L", "LX", "LXX", "LXXX", "XC"]

hundreds = ["", "C", "CC", "CCC", "CD",
            "D", "DC", "DCC", "DCCC", "CM"]

# All minimal numerals from 0..999
nums = [
    hundreds[h] + tens[t] + ones[o]
    for h in range(10)
    for t in range(10)
    for o in range(10)
]

# Value of each suffix numeral
value = {}
prefixes = {""}

for n, s in enumerate(nums):
    value[s] = n
    for i in range(len(s) + 1):
        prefixes.add(s[:i])

letters = "IVXLCD"

# Valid transitions
trans = {}

for p in prefixes:
    nxt = []
    for ch in letters:
        q = p + ch
        if q in prefixes:
            nxt.append(q)
    trans[p] = nxt

# Solve backwards by decreasing length
states = sorted(prefixes, key=len, reverse=True)

F = {}

for s in states:
    if s == "":
        continue

    k = len(trans[s])

    F[s] = (
        value[s]
        + 7 * sum(F[t] for t in trans[s])
    ) / (1 + 7 * k)

# Empty state:
# one transition to another M,
# six transitions to I,V,X,L,C,D
F0 = (
    7000
    + 7 * sum(F[t] for t in trans[""])
) / 43

print("{:.8f}".format(F0))

4. Code walkthrough

Build all minimal Roman numerals from $0$ to $999$.
Collect every valid prefix.
Build a transition graph between prefixes.
Solve the expectation equations backwards because every transition increases string length.
Handle the infinite chain of leading $M$'s analytically.
Print the expected value to 8 decimal places.

The program outputs

302.62570672

5. Final verification

The result is reasonable:

Expected leading $M$'s contribute roughly

$$1000 \cdot \frac{0.14}{0.86} \approx 162.79$$

The remaining Roman suffix contributes another $\sim 140$.

Total around $300$, consistent with the computed value.

Answer: 302.62570672