polygram 0.15.0 → 0.16.0

package/lib/error/classify.js

@@ -214,14 +214,25 @@ const CODES = {
     isTransient: false,
     autoRecover: null,
   },
-  // TURN_TIMEOUT: per-turn time cap (idle default 10 min, configurable per
-  // chat/topic — UMI runs 60 min). Mirror of the tmux wall-clock ceiling —
-  // typically a runaway, not a wedge. Not transient (auto-retry would just
-  // runaway again). Copy must not name a number: the 2026-06-11 UMI false-⏱
-  // rendered "10-minute" under a 60-minute cap.
+  // TURN_TIMEOUT: per-turn time cap fired because the turn went QUIET with no
+  // detectable progress (0.16: the busy-aware checkpoint extends a turn that's
+  // provably working, so reaching this code means the probe saw no streaming /
+  // no active shell — a genuine stall/wedge, not a long-but-working turn). Not
+  // transient. Copy must not name a number (the 2026-06-11 UMI false-⏱ rendered
+  // "10-minute" under a 60-minute cap).
   TURN_TIMEOUT: {
     kind: 'turnTimeout',
-    userMessage: '⏱ This one ran past its time cap with no reply. Resend if the answer still matters.',
+    userMessage: '⏱ This one went quiet with no progress, so I stopped waiting — send /stop to clear it, or resend if you still need it.',
+    isTransient: false,
+    autoRecover: null,
+  },
+  // TURN_MAX_EXCEEDED (0.16): the busy-aware checkpoint kept extending a turn
+  // that WAS still working, until it hit the hard wall-clock backstop
+  // (turnHardMaxMs, default 90 min). Distinct from TURN_TIMEOUT (which means
+  // "went quiet") — here it ran genuinely long and we capped it for safety.
+  TURN_MAX_EXCEEDED: {
+    kind: 'turnMaxExceeded',
+    userMessage: '⏱ This ran past the max time and I had to stop it. Resend if you still need it — or break it into smaller steps.',
     isTransient: false,
     autoRecover: null,
   },
@@ -416,8 +427,38 @@ function detectWedgedSessionError(text) {
   return cls;
 }
 
+/**
+ * 0.16: decide how the streamed-reply catch (polygram.js handleMessage) should
+ * cap the bubble + set the reactor when a turn ends in error. Extracted as a
+ * pure fn so the decision is unit-testable (the catch itself isn't unit-reachable).
+ *
+ * Returns { errorSuffix, reactorState }:
+ *   - errorSuffix: appended to streamer.finalize('') (null = no suffix)
+ *   - reactorState: reactor.setState(...) value
+ *
+ * Turn-end timeouts (TURN_TIMEOUT = went quiet, TURN_MAX_EXCEEDED = hit hard cap)
+ * are real stops → the "stream interrupted" suffix is honest here. Note: the cli
+ * backend's TURN_TIMEOUT err.message is `turn timeout (...)` which does NOT match
+ * the legacy /wall-clock ceiling|idle.../ regex, so we branch on err.code, not
+ * the message text (a v1-review correction).
+ */
+function classifyTurnEndError(err) {
+  const code = err?.code;
+  // The cli backend sets err.code (TURN_TIMEOUT / TURN_MAX_EXCEEDED). The SDK +
+  // tmux backends reject with a MESSAGE and NO code (e.g. "Turn exceeded 1800s
+  // wall-clock ceiling" / "Timeout: 600s idle with no Claude activity"), so we
+  // MUST keep the legacy message regex as a fallback — without it those
+  // backends' timeouts flip from the calm ⏱ TIMEOUT reactor to the scary ERROR
+  // one (regression caught in the 0.16 code review).
+  const isTimeout = code === 'TURN_TIMEOUT'
+    || code === 'TURN_MAX_EXCEEDED'
+    || /wall-clock ceiling|idle with no Claude activity/i.test(err?.message || '');
+  return { errorSuffix: 'stream interrupted', reactorState: isTimeout ? 'TIMEOUT' : 'ERROR' };
+}
+
 module.exports = {
   classify,
+  classifyTurnEndError,
   detectWedgedSessionError,
   isTransientHttpError,
   PATTERNS,

package/lib/process/cli-process.js

@@ -97,7 +97,8 @@ const INPUT_LEDGER_CAP = 64;
 // (Envelope shape verified from prod JSONL + the P0 spike — Q1.)
 const UPS_ENVELOPE_TURN_ID_RE = /<channel\s[^>]*turn_id="([0-9a-f-]{36})"/g;
 const DEFAULT_TURN_TIMEOUT_MS = 600_000; // 10 min idle cap (resets on each reply — Review F#13)
-const DEFAULT_TURN_ABSOLUTE_MS = 1_800_000; // 30 min absolute wall-clock ceiling (no reset)
+const DEFAULT_TURN_ABSOLUTE_MS = 1_800_000; // 30 min busy-aware checkpoint interval (0.16: re-arms while working)
+const DEFAULT_TURN_HARD_MAX_MS = 5_400_000; // 90 min hard wall-clock backstop (0.16: extension can't exceed this)
 const DEFAULT_INTERRUPT_GRACE_MS = 5_000; // after Ctrl-C, wait this long for Claude to ack before synthesizing 'interrupted'
 const DEFAULT_MAX_REPLIES_PER_TURN = 20; // P1 #12: cap on quiet-window resets to prevent chatty-Claude hang
 const PING_INTERVAL_MS = 10_000;
@@ -223,6 +224,7 @@ class CliProcess extends Process {
     deliveryWatchdogMs = DEFAULT_DELIVERY_WATCHDOG_MS,
     turnTimeoutMs = DEFAULT_TURN_TIMEOUT_MS,
     turnAbsoluteMs = DEFAULT_TURN_ABSOLUTE_MS,
+    turnHardMaxMs = DEFAULT_TURN_HARD_MAX_MS,
     bgWorkStallMs = DEFAULT_BG_WORK_STALL_MS,
     interruptGraceMs = DEFAULT_INTERRUPT_GRACE_MS,
     maxRepliesPerTurn = DEFAULT_MAX_REPLIES_PER_TURN,
@@ -258,6 +260,7 @@ class CliProcess extends Process {
     this.deliveryWatchdogMs = deliveryWatchdogMs;
     this.turnTimeoutMs = turnTimeoutMs;
     this.turnAbsoluteMs = turnAbsoluteMs;
+    this.turnHardMaxMs = turnHardMaxMs;
     this.bgWorkStallMs = bgWorkStallMs;
     this.interruptGraceMs = interruptGraceMs;
     this.maxRepliesPerTurn = maxRepliesPerTurn;
@@ -2083,7 +2086,12 @@ class CliProcess extends Process {
       // Added absoluteTimer as the true wall-clock ceiling at 30 min so a
       // legitimate 15-min "replies every 60s" turn isn't killed mid-stream
       // while still bounding runaways.
-      const fireTimeout = (reason) => {
+      // 0.16: `reason` ∈ {'idle','absolute','hard-max'}. The absolute checkpoint
+      // (_checkpointAbsolute) passes its already-captured `probeResult` so we
+      // don't double capture-pane on the give-up path. err.code is mapped from
+      // reason: 'hard-max' → TURN_MAX_EXCEEDED (ran long while working), else
+      // → TURN_TIMEOUT (went quiet / idle).
+      const fireTimeout = (reason, probeResult = null) => {
         if (!this.pendingTurns.has(turnId)) return;
         const pending = this.pendingTurns.get(turnId);
         // 0.13 D1 (S9): unblock any open ask FIRST — claude must never stay
@@ -2105,7 +2113,11 @@ class CliProcess extends Process {
         if (pending._activityQuietTimer) clearTimeout(pending._activityQuietTimer);
         if (pending._onStop) this.off('stop-hook', pending._onStop);
         this.inFlight = this.pendingTurns.size > 0;
-        const turnTimeoutMs = reason === 'absolute' ? this.turnAbsoluteMs : (opts.maxTurnMs || this.turnTimeoutMs);
+        const turnTimeoutMs = reason === 'hard-max'
+          ? (pending._turnHardMaxMs || this.turnHardMaxMs)
+          : reason === 'absolute'
+            ? this.turnAbsoluteMs
+            : (opts.maxTurnMs || this.turnTimeoutMs);
 
         // 0.13 D1 ceiling-resolve: a ceiling expiring on a turn with delivered
         // replies RESOLVES it — the user already has their answer; rejecting
@@ -2150,10 +2162,10 @@ class CliProcess extends Process {
         // 0.12.3 wedge characterization (docs/0.13-turn-wedge-autorecovery-spec.md):
         // a zero-reply turn hit the ceiling = claude wedged (no hooks AND no
         // "esc to interrupt" the whole window). Capture the TUI pane tail + busy
-        // flags to learn WHAT state claude is stuck in (a tool, an unrecognized
-        // prompt, the idle ❯, blank). Fire-and-forget: never blocks or changes
-        // the kill path; the tmux session is still alive at this point.
-        this.probeBusyState().then((probe) => {
+        // flags to learn WHAT state claude is stuck in. 0.16: reuse the probe the
+        // absolute checkpoint already captured (probeResult) to avoid a second
+        // capture-pane; only probe fresh on the idle-timer path (no prior probe).
+        const logProbe = (probe) => {
           this._logEvent('turn-timeout-pane', {
             reason,
             streaming: probe.streaming,
@@ -2162,10 +2174,12 @@ class CliProcess extends Process {
             captured: probe.captured,
             pane_tail: probe.paneTail,
           });
-        }).catch(() => { /* telemetry best-effort — never throws into the kill path */ });
+        };
+        if (probeResult) { try { logProbe(probeResult); } catch { /* best-effort */ } }
+        else this.probeBusyState().then(logProbe).catch(() => { /* telemetry best-effort */ });
         this.emit('idle');
         const err = new Error(`turn timeout (${turnTimeoutMs}ms, reason=${reason})`);
-        err.code = 'TURN_TIMEOUT';
+        err.code = reason === 'hard-max' ? 'TURN_MAX_EXCEEDED' : 'TURN_TIMEOUT';
         reject(err);
       };
       const pending = {
@@ -2179,15 +2193,24 @@ class CliProcess extends Process {
         // hardTimer = idle ceiling. Resets on any activity (_noteActivity)
         // so a chatty or tool-heavy turn isn't killed at 10 min wall-clock.
         hardTimer: setTimeout(() => fireTimeout('idle'), opts.maxTurnMs || this.turnTimeoutMs),
-        // absoluteTimer = wall-clock ceiling. Does NOT reset. Bounds true
-        // runaways. 30 min default — high enough that legitimate
-        // multi-step refactors complete, low enough to catch infinite
-        // chatter.
-        absoluteTimer: setTimeout(() => fireTimeout('absolute'), this.turnAbsoluteMs),
+        // absoluteTimer = busy-aware checkpoint (0.16). Fires every
+        // turnAbsoluteMs (30min) as a LIVENESS CHECK: if the turn is provably
+        // working (streaming/active shell + progress since last checkpoint) and
+        // under the hard backstop, re-arm; else give up. Replaces the old
+        // one-shot 30-min guillotine that cut actively-working turns.
+        absoluteTimer: setTimeout(() => this._checkpointAbsolute(turnId), this.turnAbsoluteMs),
         // Review F#13: attach fireTimeout so activity can reset the idle
         // timer (creates a fresh setTimeout with the same closure).
         _fireTimeout: fireTimeout,
         startedAt: Date.now(),
+        // 0.16: hard wall-clock backstop for this turn (per-send override →
+        // instance default). The checkpoint never extends past this.
+        _turnHardMaxMs: opts.maxTurnHardMs || this.turnHardMaxMs,
+        // 0.16: checkpoint progress-tracking (MF-A) — extend only if activity
+        // advanced since the previous checkpoint, not just "a shell exists".
+        _lastCheckpointActivityAt: Date.now(),
+        _lastCheckpointPaneTail: null,
+        _extended: false,
       };
       this.pendingTurns.set(turnId, pending);
 
@@ -2332,6 +2355,81 @@ class CliProcess extends Process {
     this._interruptGraceTimer.unref?.();
   }
 
+  /**
+   * 0.16 busy-aware ceiling checkpoint. Armed by the per-turn absoluteTimer
+   * every `turnAbsoluteMs` (30min). Decides whether to EXTEND a still-working
+   * turn or give up:
+   *
+   *   - replied turn → resolve gracefully (delegate to fireTimeout, which takes
+   *     the line-2118 ceiling-resolve branch).
+   *   - probe says working AND progress advanced since last checkpoint AND
+   *     elapsed < hard backstop → re-arm (turn stays pending, /stop keeps
+   *     working, the live reply lands in the same bubble). Ping once.
+   *   - not working / no progress → give up as 'idle' → TURN_TIMEOUT (went quiet).
+   *   - elapsed ≥ hard backstop → give up as 'hard-max' → TURN_MAX_EXCEEDED.
+   *
+   * MF-A: "working" requires evidence of PROGRESS (streaming now, or activity /
+   * pane changed since the last checkpoint), not merely a shell's existence — a
+   * hung/zombie background shell would otherwise extend to the hard max.
+   * MF-C: re-check pendingTurns AFTER the async probe (the turn can resolve /
+   * abort / kill during the capture-pane round-trip — TOCTOU), and reassign
+   * pending.absoluteTimer so teardown sites clear the live handle.
+   */
+  async _checkpointAbsolute(turnId) {
+    if (!this.pendingTurns.has(turnId)) return;
+    let pending = this.pendingTurns.get(turnId);
+    // Replied turn (or consumed-acked): the ceiling RESOLVES it, never extends.
+    if ((pending.replies?.length || 0) > 0
+        || (pending.seen === true && pending._consumedAcked === true)) {
+      pending._fireTimeout('absolute');
+      return;
+    }
+    let probe = null;
+    try { probe = await this.probeBusyState(); } catch { probe = null; }
+    // MF-C TOCTOU: the turn may have settled during the capture-pane await.
+    if (!this.pendingTurns.has(turnId)) return;
+    pending = this.pendingTurns.get(turnId);
+    // Also bail if the turn entered finalization DURING the probe — a reply
+    // landed, or it's in stop-grace, or it consumed-acked. Re-arming or pinging
+    // now would resurrect a settling turn (spurious "still working" right as the
+    // real answer lands). It will finalize through its own quiet/grace path.
+    if (pending._stopGracePending
+        || (pending.replies?.length || 0) > 0
+        || (pending.seen === true && pending._consumedAcked === true)) return;
+    const now = Date.now();
+    const elapsed = now - pending.startedAt;
+    const maxMs = pending._turnHardMaxMs || this.turnHardMaxMs;
+    const streaming = !!(probe && probe.streaming);
+    const hasShell = !!(probe && (probe.backgroundShell || probe.shellCount > 0));
+    const lastAct = Math.max(this._lastActivityAt || 0, this._lastHookEventAt || 0);
+    // MF-A progress delta: streaming NOW is live proof; otherwise require that
+    // activity advanced OR the pane changed since the previous checkpoint.
+    const progressed = streaming
+      || (lastAct > (pending._lastCheckpointActivityAt || pending.startedAt))
+      || (!!probe && probe.paneTail != null && probe.paneTail !== pending._lastCheckpointPaneTail);
+    const working = (streaming || hasShell) && progressed;
+
+    if (working && elapsed < maxMs) {
+      pending._lastCheckpointActivityAt = lastAct || pending._lastCheckpointActivityAt;
+      pending._lastCheckpointPaneTail = (probe && probe.paneTail) || pending._lastCheckpointPaneTail;
+      // MF-C: reassign the live handle so cleanup sites clear THIS timer.
+      pending.absoluteTimer = setTimeout(() => this._checkpointAbsolute(turnId), this.turnAbsoluteMs);
+      this._logEvent('turn-extended', {
+        turn_id: turnId, elapsed_ms: elapsed, streaming, shell_count: probe ? probe.shellCount : 0,
+      });
+      // Progress ping ONCE per turn (first extension) — emits an event polygram
+      // turns into a single "still working" message (honest: probe-confirmed).
+      if (!pending._extended) {
+        pending._extended = true;
+        this.emit('turn-extended', { sessionKey: this.sessionKey, turnId, elapsedMs: elapsed });
+      }
+      return;
+    }
+    // Give up: hard-max (was working but ran too long) vs idle (went quiet).
+    const reason = elapsed >= maxMs ? 'hard-max' : 'idle';
+    pending._fireTimeout(reason, probe);
+  }
+
   /**
    * Is claude actually still working, regardless of the resolved-turn flag?
    *
@@ -2425,6 +2523,16 @@ class CliProcess extends Process {
     return this._bgWorkSince !== null;
   }
 
+  /**
+   * 0.16 (MF-B): does any in-flight turn have a busy-aware ceiling EXTENSION
+   * active? Such a turn can hold its slot up to the hard backstop, so the LRU
+   * treats it as a durable pin (soft-overflow) rather than a transient turn.
+   */
+  hasExtendedTurn() {
+    for (const p of this.pendingTurns.values()) if (p._extended) return true;
+    return false;
+  }
+
   /**
    * Resolve the model / effort for a spawn context using the topic→chat→
    * fallback precedence (mirrors the spawn path). Single source of truth shared

package/lib/process-manager.js

@@ -53,6 +53,12 @@ const CALLBACK_TO_EVENT = {
   // posts/edits a "⏳ working in background" status message so a long job reads as
   // working, not stuck. See docs/0.12.0-background-work-lifecycle-plan.md.
   onBgWorkStatus:               'bg-work-status',
+  // 0.16 busy-aware ceiling: CliProcess emits 'turn-extended' the FIRST time a
+  // turn passes the 30-min checkpoint while still provably working. The callback
+  // posts a one-time "⏳ still working — /stop to cancel" message so a long turn
+  // reads as alive (not the old false "stream interrupted"). See
+  // docs/0.16-turn-ceiling-busy-aware-spec.md.
+  onTurnExtended:               'turn-extended',
   // 0.12 interactive questions: CliProcess emits 'question-asked'
   // {sessionKey, chatId, threadId, turnId, toolCallId, questions} when claude calls
   // the `ask` tool. The callback (polygram) renders the Telegram inline keyboard;
@@ -351,6 +357,12 @@ class ProcessManager {
   _hasPinnedSession() {
     for (const p of this.procs.values()) {
       if (!p.inFlight && p.hasActiveBackgroundWork()) return true;
+      // 0.16 (MF-B): an extended busy-aware-ceiling turn is a DURABLE blocker —
+      // it can hold its slot up to the hard backstop (90min), not "seconds" like
+      // a normal in-flight turn. Treat it as a pin so getOrSpawn SOFT-overflows
+      // (spawn over budget + warn) instead of park-then-reject, which would deny
+      // service to other chats for the full 5-min LRU wait.
+      if (p.inFlight && typeof p.hasExtendedTurn === 'function' && p.hasExtendedTurn()) return true;
     }
     return false;
   }
@@ -359,6 +371,7 @@ class ProcessManager {
     const keys = [];
     for (const [k, p] of this.procs.entries()) {
       if (!p.inFlight && p.hasActiveBackgroundWork()) keys.push(k);
+      else if (p.inFlight && typeof p.hasExtendedTurn === 'function' && p.hasExtendedTurn()) keys.push(k);
     }
     return keys;
   }

package/lib/sdk/callbacks.js

@@ -411,6 +411,41 @@ function createSdkCallbacks({
       }
     },
 
+    // 0.16 busy-aware ceiling: CliProcess emits 'turn-extended' the FIRST time a
+    // turn passes the 30-min checkpoint while still provably working. Post ONE
+    // honest "still working — /stop" message so a long turn reads as alive
+    // instead of the old false "stream interrupted". The cli side flags
+    // _extended once per turn, so this fires at most once per long turn.
+    // Opt-out per chat via progressPings:false. NO "ask how it's going" — a
+    // foreground-streaming turn can't answer (review F1).
+    onTurnExtended: async (sessionKey, payload) => {
+      try {
+        if (!bot) return;
+        const chatId = getChatIdFromKey(sessionKey);
+        const chatCfg = (config && config.chats && config.chats[chatId]) || {};
+        // Precedence: per-chat overrides default (a chat can re-enable pings even
+        // if the global default disables them, and vice-versa). Default ON.
+        const chatPings = chatCfg.progressPings;
+        const enabled = chatPings !== undefined
+          ? chatPings !== false
+          : (config && config.defaults && config.defaults.progressPings) !== false;
+        if (!enabled) return;
+        const threadIdRaw = getThreadIdFromKey(sessionKey);
+        const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;
+        await tg(bot, 'sendMessage', {
+          chat_id: chatId,
+          text: '⏳ Still working on this — it\'s taking a while. Send /stop to cancel.',
+          ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+        }, { source: 'turn-extended', botName });
+        logEvent('turn-extended-ping', {
+          chat_id: chatId, session_key: sessionKey, thread_id: threadIdRaw,
+          elapsed_ms: payload?.elapsedMs ?? null,
+        });
+      } catch (err) {
+        logger.error?.(`[${botName}] turn-extended handler: ${err.message}`);
+      }
+    },
+
     // R8: a failed autosteer paste. injectUserMessage fires
     // `inject-fail` when its fire-and-forget paste rejects (tmux
     // server gone, paste-buffer error, etc.). Before this handler was

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "description": "Telegram daemon for Claude Code that preserves the OpenClaw per-chat session model. Migration path for OpenClaw users moving to Claude Code.",
   "main": "lib/ipc/client.js",
   "bin": {

package/polygram.js

@@ -108,7 +108,7 @@ const { startTyping } = require('./lib/telegram/typing');
 const { createReactionManager, classifyToolName } = require('./lib/telegram/reactions');
 const { createMediaGroupBuffer } = require('./lib/media-group-buffer');
 const { applyReactionToMessages } = require('./lib/telegram/album-reactions');
-const { classify: classifyError, detectWedgedSessionError, isTransientHttpError } = require('./lib/error/classify');
+const { classify: classifyError, classifyTurnEndError, detectWedgedSessionError, isTransientHttpError } = require('./lib/error/classify');
 const { createAutoResumeTracker, isAutoResumable } = require('./lib/db/auto-resume');
 const { resolveReplayWindowMs } = require('./lib/db/replay-window');
 const { pruneEvents, resolveRetentionPolicy, validatePolicy } = require('./lib/db/events-retention');
@@ -510,6 +510,10 @@ async function sendToProcess(sessionKey, prompt, context = {}, { onDispatched }
   const chatConfig = config.chats[chatId];
   const timeoutMs = (chatConfig.timeout || config.defaults.timeout) * 1000;
   const maxTurnMs = (chatConfig.maxTurn || config.defaults?.maxTurn || 1800) * 1000;
+  // 0.16 busy-aware ceiling: hard wall-clock backstop for a turn that keeps
+  // extending while provably working (cli backend). Per-chat → default →
+  // 90 min. The checkpoint never extends a turn past this.
+  const maxTurnHardMs = (chatConfig.maxTurnHard || config.defaults?.maxTurnHard || 5400) * 1000;
 
   // 0.12 Phase 2.1: HeartbeatReactor binding removed for CliProcess.
   // 0.11.0-channels needed a random-cycling working-pool reactor because
@@ -540,7 +544,7 @@ async function sendToProcess(sessionKey, prompt, context = {}, { onDispatched }
   // starts, which is the correct UX (and what the user already expects).
   const release = await stdinLock.acquire(sessionKey);
   try {
-    const turnP = pm.send(sessionKey, prompt, { timeoutMs, maxTurnMs, context });
+    const turnP = pm.send(sessionKey, prompt, { timeoutMs, maxTurnMs, maxTurnHardMs, context });
     // Phase 3 §4: pm.send synchronously kicks off the turn — the
     // process is now inFlight. Signal the committed-intent latch so
     // it can release; a concurrent handler will then correctly see
@@ -1711,12 +1715,14 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // On shutdown, leave the reactor state as-is — boot-replay's
       // fresh dispatch will set its own reactor.
     } else {
-      await streamer.finalize('', { errorSuffix: 'stream interrupted' }).catch(() => {});
-      if (/wall-clock ceiling|idle with no Claude activity/i.test(err?.message || '')) {
-        reactor.setState('TIMEOUT');
-      } else {
-        reactor.setState('ERROR');
-      }
+      // 0.16: branch the bubble suffix + reactor on err.code via the pure
+      // classifyTurnEndError helper (the cli TURN_TIMEOUT message is
+      // `turn timeout (...)`, which does NOT match the legacy regex — branch on
+      // code, not text). TURN_TIMEOUT (went quiet) / TURN_MAX_EXCEEDED (hit hard
+      // cap) → TIMEOUT reactor; anything else → ERROR.
+      const { errorSuffix, reactorState } = classifyTurnEndError(err);
+      await streamer.finalize('', errorSuffix ? { errorSuffix } : {}).catch(() => {});
+      reactor.setState(reactorState);
     }
     throw err;
   } finally {