턴이 지금 어디 있는지

# After the route's mark named here, the next step is this stage. The marks
# are the ``[turn-prep]`` line's own (routes/chat.py and the Ollama route
# make them in this order); a mark not listed keeps the stage it is in.
STAGE_AFTER_MARK: dict[str, str] = {
    "resolve": "voice_check",
    "speaker": "preparing",
    "between": "memory",
    "history": "memory",
    "rag_and_prompt": "preparing",
}

# ``ProviderClock.first`` stages that move the board.
STAGE_AT_PROVIDER: dict[str, str] = {
    "sent": "model",
    "first_thinking": "thinking",
    "first_text": "writing",
}

# A finished entry is kept this long for a late reader, then dropped.
_KEEP_DONE_SECONDS = 600.0
# Finished turns findable by request id (``finished``), newest last.
_KEEP_FINISHED = 64

"""A minimal sketch: one stage board a turn publishes to, a screen that long-polls
it, and "stalled" said only after something was checked. Not the engine."""
import asyncio
import time


class Board:
    def __init__(self):
        self.entry = {"stage": None, "detail": None, "seq": 0, "since": time.monotonic()}
        self.changed = asyncio.Event()

    def publish(self, stage, detail=None):
        self.entry = {"stage": stage, "detail": detail, "seq": self.entry["seq"] + 1,
                      "since": time.monotonic()}
        self.changed.set()                  # wake every waiter...
        self.changed = asyncio.Event()      # ...and arm the next move

    async def wait_past(self, seq, wait):
        """Answer as soon as the stage moves past seq, or after `wait` seconds."""
        if self.entry["seq"] > seq:
            return self.entry
        try:
            await asyncio.wait_for(self.changed.wait(), wait)
        except asyncio.TimeoutError:
            pass
        return self.entry


async def turn(board):
    steps = [("received", None, 0.05), ("voice_check", None, 0.2), ("memory", None, 0.3),
             ("model", None, 1.3), ("tool", "coop", 0.3), ("writing", None, 0.3), ("done", None, 0)]
    for stage, detail, seconds in steps:
        board.publish(stage, detail)
        await asyncio.sleep(seconds)


def check(link_ok, office_answered_ago):
    """A diagnosis, never a timer: look at the link, then at office."""
    if not link_ok:
        return "the phone has no network"
    if office_answered_ago is None or office_answered_ago > 15:
        return "office does not answer"
    return "office answers; the model has not started yet"


async def screen(board, limit=1.0):
    seq, start = 0, time.monotonic()
    while True:
        entry = await board.wait_past(seq, wait=0.5)
        quiet = time.monotonic() - entry["since"]
        moved = entry["seq"] != seq
        if moved or quiet > limit:
            line = entry["stage"] + (f" · {entry['detail']}" if entry["detail"] else "")
            if not moved:
                line += f" · quiet {quiet:.1f}s · {check(True, 2.0)}"
            print(f"{time.monotonic() - start:4.1f}s  {line}")
        seq = entry["seq"]
        if entry["stage"] == "done":
            return


async def main():
    board = Board()
    await asyncio.gather(turn(board), screen(board))


asyncio.run(main())