잘못된 경보, 원인마다 따로 재기

        quick = readTransport ?? pool.transport(policy: .quick)
        media = bulkPool.transport(policy: Self.mediaPolicy)
        download = readTransport ?? bulkPool.transport(policy: Self.downloadPolicy)
        transcript = readTransport ?? pool.transport(policy: Self.transcriptPolicy)
        video = bulkPool.transport(policy: Self.videoPolicy)
        speech = bulkPool.transport(policy: Self.speechPolicy)
        control = pool.transport(policy: Self.controlPolicy)
        ensuring = pool.transport(policy: Self.ensurePolicy)
        bulkProbe = bulkPool.transport(policy: .quick)
        // A turn's stream opens a connection of its own (todo #556): on build 157 the
        // pool's kept-alive connection went stale within six minutes of launch, every
        // call on it hung until the pool healed, and a dictated turn sat 49 s on the
        // phone before its POST ("not sent for 37s; office answers"). One handshake
        // per turn, well under a second from Malaga, is the price of never waiting on
        // a dead connection.
        streamer = { request, policy in
            var request = request
            request.timeoutInterval = policy.requestTimeout
            return try await HTTPTransports.lineStream(request, policy: policy)
        }
        speechStreamer = bulkPool.byteStreamer(policy: Self.speechPolicy)

    /// "Reconnecting" is a verdict, never one missed check (todo #556): two checks
    /// in a row failing over at least this long, with nothing heard from the engine in
    /// `reconnectQuietSeconds`. One 5 s timeout behind a reply's audio said
    /// "The engine did not answer in time" against a healthy engine all day.
    nonisolated static let reconnectAfterSeconds = 6.0
    nonisolated static let reconnectQuietSeconds = 15.0

    /// Whether the progress check's failures add up to "Reconnecting".
    nonisolated static func reconnecting(failures: Int, failingFor: TimeInterval, sinceContact: TimeInterval?) -> Bool {
        guard failures >= 2, failingFor >= reconnectAfterSeconds else { return false }
        if let sinceContact, sinceContact < reconnectQuietSeconds { return false }
        return true
    }

# One pool of six for everything, or traffic by kind: when does the progress
# check get an answer, and when does the screen say "Reconnecting"?
# The rules follow cwkSiblingKit's HTTPConnectionPool and cwkPippa's
# AppModel.reconnecting; the call durations are illustrative, shaped after
# the Malaga access log of 2026-10-19, not measured per call.
import heapq

CONNECTIONS = 6        # httpMaximumConnectionsPerHost, per pool
CHECK_REST = 3.0       # the progress check sleeps this long between asks
CHECK_TIMEOUT = 5.0    # the quick policy's request timeout
CHECK_SECONDS = 0.2    # a healthy engine answers the check this fast
AFTER_SECONDS = 6.0    # AppModel.reconnectAfterSeconds
QUIET_SECONDS = 15.0   # AppModel.reconnectQuietSeconds

# (arrival, seconds held, kind). The turn's stream runs for the whole reply;
# when the tool ends at 20 s, four takes are prepared and streamed at once,
# and the 1.96 MB microphone-rate copy goes up in the same second.
REPLY = [(0.0, 40.4, "stream")]
REPLY += [(20.0, 0.4, "prepare")] * 4
REPLY += [(20.4, seconds, "take") for seconds in (14.0, 19.0, 24.0, 30.0)]
REPLY += [(20.0, 26.0, "upload")]
BULK = {"take", "upload"}


def run(calls, split: bool, engine_up: bool = True, until: float = 45.0):
    """Every call takes the connection that frees first in its pool, in arrival
    order. The check asks, waits for an answer or its timeout, rests, asks again."""
    pools = {"control": [0.0] * CONNECTIONS, "bulk": [0.0] * CONNECTIONS}
    queue = [(arrival, kind != "stream", seconds, kind) for arrival, seconds, kind in calls]
    queue.append((0.0, True, CHECK_SECONDS, "check"))
    heapq.heapify(queue)
    checks = []                                          # (asked at, answered at or None)
    while queue:
        arrival, _, seconds, kind = heapq.heappop(queue)
        pool = pools["bulk" if split and kind in BULK else "control"]
        slot = min(range(CONNECTIONS), key=lambda i: pool[i])
        start = max(arrival, pool[slot])
        if kind != "check":
            pool[slot] = start + seconds
            continue
        if engine_up and start + seconds - arrival < CHECK_TIMEOUT:
            pool[slot] = start + seconds
            checks.append((arrival, start + seconds))
            end = start + seconds
        else:
            checks.append((arrival, None))               # timed out
            end = arrival + CHECK_TIMEOUT
        if end + CHECK_REST < until:
            heapq.heappush(queue, (end + CHECK_REST, True, CHECK_SECONDS, "check"))
    return checks


def first_alarm(checks, words_until: float):
    """When one miss would say "Reconnecting", and when the verdict would:
    two failures in a row, failing for at least 6 s, nothing heard for 15 s.
    Her streamed words count as hearing from the engine."""
    one_miss = verdict = None
    failures, since, heard = 0, None, 0.0
    for asked, answered in checks:
        now = answered if answered is not None else asked + CHECK_TIMEOUT
        heard = max(heard, min(now, words_until))
        if answered is not None:
            failures, since, heard = 0, None, answered
            continue
        failures += 1
        since = now if since is None else since
        one_miss = now if one_miss is None else one_miss
        if verdict is None and failures >= 2 and now - since >= AFTER_SECONDS and now - heard >= QUIET_SECONDS:
            verdict = now
    return one_miss, verdict


for label, split, up, words in (("one pool, a healthy engine", False, True, 40.4),
                                ("two pools, a healthy engine", True, True, 40.4),
                                ("two pools, the engine gone", True, False, 0.0)):
    checks = run(REPLY, split, engine_up=up)
    missed = sum(1 for _, answered in checks if answered is None)
    one_miss, verdict = first_alarm(checks, words_until=words)
    show = lambda t: "never" if t is None else f"{t:4.1f} s"
    print(f"{label:28s} checks {len(checks):2d}, missed {missed:2d} | one miss: {show(one_miss):7s} verdict: {show(verdict)}")

# Output:
# one pool, a healthy engine   checks 12, missed  1 | one miss: 27.4 s  verdict: never
# two pools, a healthy engine  checks 15, missed  0 | one miss: never   verdict: never
# two pools, the engine gone   checks  6, missed  6 | one miss:  5.0 s  verdict: 21.0 s