polygram 0.12.0-rc.33 → 0.12.0-rc.35

package/lib/handlers/config-ui.js

@@ -78,9 +78,24 @@ function createFormatConfigInfoText({ pm, db, getClaudeSessionId } = {}) {
     const agent = (topicConfig && topicConfig.agent) || chatConfig.agent;
     const ver = MODEL_VERSIONS_DESC[model] || model;
     const sess = getClaudeSessionId(db, sessionKey)?.slice(0, 8) || 'new';
+    // Running vs configured: cli can't hot-swap model/effort, so a /model or
+    // /effort change is PENDING until the session reloads (on the next message).
+    // Show the truth — the live proc's spawn-time value (proc.model/proc.effort)
+    // vs the configured one — so the card never claims a model the session
+    // isn't actually running (the "says opus, runs sonnet" confusion). SDK
+    // applies live (its proc value tracks config) so no drift line ever shows.
+    const proc = alive ? pm.get(sessionKey) : null;
+    const runModel = proc && proc.model;
+    const runEffort = proc && proc.effort;
+    const modelLine = (runModel && runModel !== model)
+      ? `Model: ${runModel} (running) → ${model} (pending — applies on your next message)`
+      : `Model: ${model} (${ver})`;
+    const effortLine = (runEffort && runEffort !== effort)
+      ? `Effort: ${runEffort} (running) → ${effort} (pending — applies on your next message)`
+      : `Effort: ${effort}`;
     const head =
-      `Model: ${model} (${ver})\n` +
-      `Effort: ${effort}\n` +
+      `${modelLine}\n` +
+      `${effortLine}\n` +
       `Agent: ${agent}\n` +
       `Process: ${alive ? 'warm' : 'cold'}\n` +
       `Session: ${sess}`;

package/lib/handlers/edit-redelivery.js

@@ -0,0 +1,121 @@
+'use strict';
+
+/**
+ * Post-turn edit re-delivery (0.12.0). When the user edits a Telegram message AFTER claude's turn
+ * has finished, re-dispatch the edited message as a NEW turn so claude acts on the change — the
+ * "an edit is just a message" model. The mid-turn case (turn still in flight) stays with the
+ * existing injector (lib/handlers/edit-correction.js); this is the post-turn path.
+ *
+ * Spec: docs/0.12.0-edit-redelivery-spec.md (twice-reviewed). Key correctness points the review
+ * surfaced:
+ *   - Convey the change via reply_to carrying the OLD text (the caller captures it before
+ *     recordInbound overwrites the row) — replying to the live row would quote the NEW text, so
+ *     claude would see no before/after and couldn't tell it's an edit.
+ *   - GATE on the REAL edited message, NOT the synthetic: a self-reply_to trips shouldHandle's
+ *     `repliesToOtherUser` and drops paired users in mention-gated groups.
+ *   - The synthetic is `_isReplay`-tagged → no new editable row, never replay-eligible, error
+ *     reply suppressed.
+ *   - A re-edit while our re-run is in flight FOLDS via inject (the interlock) rather than
+ *     starting a second turn.
+ *
+ * @param {object} deps
+ * @param {object} deps.pm                    ProcessManager (get(sessionKey).inFlight, injectUserMessage)
+ * @param {object} deps.config
+ * @param {Function} deps.getSessionKey       (chatId, threadId, chatConfig) => sessionKey
+ * @param {Function} deps.shouldHandle        (msg, chatConfig, botUsername) => boolean — the real gate
+ * @param {Function} deps.dispatchHandleMessage (sessionKey, chatId, msg, bot) => void
+ * @param {object} deps.bot
+ * @param {Function} [deps.react]             (chatId, msgId) => void|Promise — on-edit acknowledgment
+ * @param {Function} [deps.logEvent]
+ * @param {object} [deps.logger]
+ * @returns {(editedMsg, oldText, botUsername, mentionRe?) => boolean} true when a fresh turn was
+ *   dispatched. botUsername / mentionRe are passed at CALL time (not construction): they are
+ *   resolved asynchronously via getMe and live in the createBot scope, so capturing them in the
+ *   factory (built in main()) would both be out of scope and freeze the empty initial values.
+ */
+function createEditRedelivery({
+  pm, config, getSessionKey, shouldHandle, dispatchHandleMessage, bot,
+  react, logEvent = () => {}, logger = console,
+} = {}) {
+  // botUsername / mentionRe arrive at CALL time — see @returns. Constructing with them threw
+  // `ReferenceError: mentionRe is not defined` at boot (rc.34): the factory runs in main() where
+  // those createBot locals don't exist. The edited_message handler passes the live values.
+  return function maybePostTurnEdit(editedMsg, oldText, botUsername, mentionRe = null) {
+    try {
+      if (!editedMsg?.chat) return false;
+      const chatId = editedMsg.chat.id.toString();
+      const chatConfig = config.chats[chatId];
+      if (!chatConfig) return false;
+
+      // Per-chat / bot-level opt-out (shared with the mid-turn injector). Default on.
+      const optOut = chatConfig.editCorrection != null
+        ? chatConfig.editCorrection === false
+        : config.bot?.editCorrection === false;
+      if (optOut) return false;
+
+      const newText = editedMsg.text || editedMsg.caption || '';
+      if (!newText) return false;                              // blanked / media-only → nothing to act on
+      // Changed-guard: skip metadata-only edits (link-preview load fires edited_message too). The
+      // caller MUST have read oldText before recordInbound overwrote the row; null = unknown → proceed.
+      if (oldText != null && oldText === newText) return false;
+
+      const threadId = editedMsg.message_thread_id?.toString() || null;
+      const sessionKey = getSessionKey(chatId, threadId, chatConfig);
+
+      // Interlock: a turn is in flight (most likely OUR own re-run, whose _isReplay row reads
+      // not-live so the mid-turn injector skipped it and fell through to here). Fold the re-edit
+      // via inject instead of spawning a SECOND re-dispatch turn for the same message.
+      const proc = pm?.get?.(sessionKey);
+      if (proc?.inFlight) {
+        pm.injectUserMessage?.(sessionKey, {
+          content: `[edit] I edited my message again — it now reads: ${newText}`,
+          priority: 'next',
+          msgId: editedMsg.message_id,
+        });
+        logEvent('edit-redelivery-folded', { chat_id: chatId, session_key: sessionKey, msg_id: editedMsg.message_id });
+        return false;
+      }
+
+      // GATE on the REAL edited message (its real from / new text / its own real reply_to, if any).
+      // NOT the synthetic — a self-reply_to would trip shouldHandle.repliesToOtherUser and drop a
+      // paired user editing an un-mentioned message in a mention-gated group.
+      if (!shouldHandle(editedMsg, chatConfig, botUsername)) return false;
+
+      // Acknowledge immediately: a silent edit produces no new bubble, so show it registered before
+      // claude's reply lands (the rc.33 lesson). Best-effort; never blocks the re-dispatch.
+      try { react?.(chatId, editedMsg.message_id); } catch { /* best-effort */ }
+
+      // Synthetic turn: NEW text in the body, OLD text in the reply_to so claude sees the change.
+      // reply_to_message carries `from` + `text` so resolveReplyTo takes the telegram branch and
+      // renders the OLD text — NOT db.getMessage (which now holds the overwritten new text).
+      const cleanNew = mentionRe ? newText.replace(mentionRe, '').trim() : newText.trim();
+      const synthetic = {
+        chat: editedMsg.chat,
+        message_id: editedMsg.message_id,
+        from: editedMsg.from,
+        text: cleanNew,
+        date: editedMsg.date,
+        ...(threadId && { message_thread_id: Number(threadId) }),
+        reply_to_message: {
+          message_id: editedMsg.message_id,
+          from: editedMsg.from,
+          text: oldText || '',
+          date: editedMsg.date,
+        },
+        _isReplay: true,   // no new editable row, not replay-eligible, error reply suppressed
+      };
+      dispatchHandleMessage(sessionKey, chatId, synthetic, bot);
+      logEvent('edit-redelivered', {
+        chat_id: chatId, session_key: sessionKey, msg_id: editedMsg.message_id,
+        old_len: (oldText || '').length, new_len: newText.length,
+      });
+      return true;
+    } catch (e) {
+      // Never throw out of the edited_message handler.
+      logger.error?.(`[edit-redelivery] ${e.message}`);
+      return false;
+    }
+  };
+}
+
+module.exports = { createEditRedelivery };

package/lib/handlers/slash-commands.js

@@ -186,6 +186,30 @@ function createSlashCommands({
       return { anyActive: !applied };
     };
 
+    // cli can't hot-swap model/effort live (they are spawn-time --model /
+    // --effort flags). The change is persisted to chatConfig and applies when
+    // the session next (re)spawns — getOrSpawn's reload-on-drift makes that the
+    // user's NEXT message, conversation preserved (--resume). So give an honest
+    // suffix per backend instead of the misleading "I'll switch when I finish".
+    // (Pre-fix this checked backendName === 'channels', but 0.12.0 renamed the
+    // cli backend 'channels' → 'cli', so it never fired and every cli user got
+    // the wrong message — Review F#10 regression.)
+    const cliAwareSuffix = (anyActive) => {
+      const liveBackend = typeof pm.getBackend === 'function' ? pm.getBackend(sessionKey) : null;
+      if (liveBackend === 'cli') {
+        const proc = typeof pm.get === 'function' ? pm.get(sessionKey) : null;
+        return proc && proc.inFlight
+          ? ' — applies after this turn (conversation kept)'
+          : ' — applies on your next message (conversation kept)';
+      }
+      // cli but cold (no live proc): the next message cold-spawns with the new flag.
+      if (!liveBackend && (chatConfig.pm || config.bot?.pm) === 'cli') {
+        return ' — applies on your next message';
+      }
+      // SDK: applied live (anyActive false) or no live session to push into.
+      return anyActive ? ' — I\'ll switch when I finish' : '';
+    };
+
     // /model X
     if (botAllowsCommands && text.startsWith('/model ')) {
       const newModel = text.slice(7).trim();
@@ -199,18 +223,7 @@ function createSlashCommands({
         }), 'log model change');
         const { anyActive } = await applyConfigChange('model', newModel);
         const ver = (modelVersionsDesc && modelVersionsDesc[newModel]) || newModel;
-        // Review F#10: channels backend can't apply model/effort changes
-        // live — its setModel/applyFlagSettings throw UNSUPPORTED_OPERATION,
-        // pm.setModel returns false → `anyActive` is true → user saw the
-        // misleading "I'll switch when I finish" message. Now we detect
-        // the channels backend explicitly and give an honest answer:
-        // settings are persisted to chatConfig and take effect on the next
-        // /reset or /new (channels lacks an in-place re-init path).
-        const backendName = typeof pm.getBackend === 'function' ? pm.getBackend(sessionKey) : null;
-        const suffix = backendName === 'channels'
-          ? ` — applies on next /reset (channels)`
-          : (anyActive ? ` — I'll switch when I finish` : '');
-        await sendReply(`Model → ${newModel} (${ver})${suffix}`);
+        await sendReply(`Model → ${newModel} (${ver})${cliAwareSuffix(anyActive)}`);
       } else {
         await sendReply(`Unknown model. Use: opus, sonnet, haiku`);
       }
@@ -229,18 +242,7 @@ function createSlashCommands({
           user: cmdUser, user_id: cmdUserId, source: 'command',
         }), 'log effort change');
         const { anyActive } = await applyConfigChange('effort', newEffort);
-        // Review F#10: channels backend can't apply model/effort changes
-        // live — its setModel/applyFlagSettings throw UNSUPPORTED_OPERATION,
-        // pm.setModel returns false → `anyActive` is true → user saw the
-        // misleading "I'll switch when I finish" message. Now we detect
-        // the channels backend explicitly and give an honest answer:
-        // settings are persisted to chatConfig and take effect on the next
-        // /reset or /new (channels lacks an in-place re-init path).
-        const backendName = typeof pm.getBackend === 'function' ? pm.getBackend(sessionKey) : null;
-        const suffix = backendName === 'channels'
-          ? ` — applies on next /reset (channels)`
-          : (anyActive ? ` — I'll switch when I finish` : '');
-        await sendReply(`Effort → ${newEffort}${suffix}`);
+        await sendReply(`Effort → ${newEffort}${cliAwareSuffix(anyActive)}`);
       } else {
         await sendReply(`Unknown effort. Use: low, medium, high, xhigh, max`);
       }

package/lib/process/cli-process.js

@@ -545,9 +545,15 @@ class CliProcess extends Process {
     // after this.
     const topicConfig = opts.threadId && opts.chatConfig?.topics?.[opts.threadId];
     const agent  = topicConfig?.agent  || opts.chatConfig?.agent  || opts.agent;
-    const model  = topicConfig?.model  || opts.chatConfig?.model  || opts.model;
-    const effort = topicConfig?.effort || opts.chatConfig?.effort || opts.effort;
+    const model  = this._resolveModel(opts);
+    const effort = this._resolveEffort(opts);
     const resolvedCwd = topicConfig?.cwd || opts.chatConfig?.cwd || opts.cwd;
+    // Record the spawn-time model/effort. cli has no live model/effort swap
+    // (they are spawn-time --model / --effort flags), so getOrSpawn detects a
+    // /model or /effort drift against these and reloads — --resume preserves
+    // the conversation, the new flag takes effect. See wouldReloadFor.
+    this.model = model;
+    this.effort = effort;
 
     // File-send outbound cap (bot → user). Backend-derived (cloud 50MB vs
     // local Bot API server 2GB via opts.localApi) with per-topic/chat
@@ -1744,6 +1750,38 @@ class CliProcess extends Process {
     return this._bgWorkSince !== null;
   }
 
+  /**
+   * Resolve the model / effort for a spawn context using the topic→chat→
+   * fallback precedence (mirrors the spawn path). Single source of truth shared
+   * by start() (which records this.model / this.effort) and wouldReloadFor()
+   * (which compares the current config to those spawn-time values).
+   */
+  _resolveModel(opts) {
+    const topicConfig = opts.threadId && opts.chatConfig?.topics?.[opts.threadId];
+    return topicConfig?.model || opts.chatConfig?.model || opts.model;
+  }
+
+  _resolveEffort(opts) {
+    const topicConfig = opts.threadId && opts.chatConfig?.topics?.[opts.threadId];
+    return topicConfig?.effort || opts.chatConfig?.effort || opts.effort;
+  }
+
+  /**
+   * getOrSpawn calls this before reusing a warm proc. cli can't hot-swap model
+   * or effort (spawn-time flags), so when the resolved config has drifted from
+   * what we spawned with AND we are idle, the proc must be killed + cold-
+   * respawned (--resume keeps the conversation; the new --model / --effort takes
+   * effect). In-flight → false: fold the message into the running turn; the
+   * drift reloads on the next idle dispatch. SDK procs apply model live and do
+   * NOT implement this method, so process-manager only reloads when it exists.
+   * @returns {boolean}
+   */
+  wouldReloadFor(spawnContext) {
+    if (this.inFlight || this.closed) return false;
+    return this._resolveModel(spawnContext) !== this.model
+        || this._resolveEffort(spawnContext) !== this.effort;
+  }
+
   /**
    * Stall-watchdog for detached background work (0.12.0 background-work
    * lifecycle, shumorobot Music 7h frozen-Chrome download). Runs on the
@@ -2629,8 +2667,18 @@ class CliProcess extends Process {
    */
   writeQuestionAnswer(toolCallId, result) {
     this._openQuestions.delete(toolCallId);
-    if (this._openQuestions.size === 0) this._stopQuestionKeepAlive();
-    return this._writeToBridge({ kind: 'question_answer', tool_call_id: toolCallId, result: result ?? {} });
+    const noneLeft = this._openQuestions.size === 0;
+    if (noneLeft) this._stopQuestionKeepAlive();
+    const wrote = this._writeToBridge({ kind: 'question_answer', tool_call_id: toolCallId, result: result ?? {} });
+    // Re-light progress: claude is about to resume working on the answer. The per-turn reactor
+    // cleared when claude posted its reply + asked, and no tool hooks fired during the wait, so
+    // it stayed cleared — the post-answer work was invisible ("why don't I see it working after
+    // submit?", hire topic 2026-06-09). On a REAL answer (cancelled/timeout END the turn → let
+    // the normal teardown clear), signal polygram to re-arm the turn's working reaction.
+    if (noneLeft && result && !result.cancelled && !result.timedout) {
+      this.emit('question-resumed');
+    }
+    return wrote;
   }
 
   _startQuestionKeepAlive() {

package/lib/process-manager.js

@@ -58,6 +58,11 @@ const CALLBACK_TO_EVENT = {
   // the `ask` tool. The callback (polygram) renders the Telegram inline keyboard;
   // the user's tap/typed answer routes back via pm.answerQuestion → writeQuestionAnswer.
   onQuestionAsked:              'question-asked',
+  // 0.12.0 question-progress-resume: CliProcess emits 'question-resumed' (no payload) when a
+  // blocking `ask` resolves with a real answer and the turn resumes working. The callback
+  // re-arms the per-turn reactor (it cleared during the wait, no hooks re-lit it). See
+  // docs/0.12.0-question-resume-progress-spec.md.
+  onQuestionResumed:            'question-resumed',
   onQueueDrop:                  'queue-drop',
   onThinking:                   'thinking',
   // Tmux backend: TUI shows in-pane approval prompt. SDK backend
@@ -237,7 +242,23 @@ class ProcessManager {
       // caller receives a proc whose start() has fully resolved.
       const pendingStart = this._starting.get(sessionKey);
       if (pendingStart) await pendingStart;
-      return existing;
+      // Reload-on-drift (cli): a warm cli proc can't hot-swap model/effort
+      // (spawn-time flags). If the resolved config has drifted and the proc is
+      // idle, kill it (preserves session_id) and fall through to a cold respawn
+      // → --resume keeps the conversation, the new --model/--effort takes
+      // effect. In-flight cli procs and SDK procs (no wouldReloadFor — they
+      // apply model live) are reused unchanged.
+      if (typeof existing.wouldReloadFor === 'function' && existing.wouldReloadFor(spawnContext)) {
+        this._logEvent('cli-config-reload', {
+          sessionKey,
+          from_model: existing.model,
+          from_effort: existing.effort,
+        });
+        await this.kill(sessionKey, 'config-reload');
+        // fall through to the cold-spawn path below — respawns with --resume
+      } else {
+        return existing;
+      }
     }
 
     // Provisional new-process cost — ask the factory but don't start yet.

package/lib/questions/questions.js

@@ -62,14 +62,18 @@ function renderCurrent(state, callbackBase) {
   lines.push(String(q.question ?? ''));
   lines.push('');
   opts.forEach((o, i) => {
-    const mark = multi && state.toggles[i] ? '☑️ ' : '• ';
+    // Multi-select renders as a checklist (☐ unchecked / ☑️ checked) so it's legible as a
+    // tap-to-toggle-then-Submit control, NOT a single-select button. Single-select keeps `•`.
+    const mark = multi ? (state.toggles[i] ? '☑️ ' : '☐ ') : '• ';
     lines.push(`${mark}${truncLabel(o.label)}${o.description ? ` — ${o.description}` : ''}`);
     if (o.preview) lines.push(String(o.preview).slice(0, MAX_PREVIEW));
   });
-  if (multi) lines.push('\nTap options to toggle, then Submit.');
+  if (multi) lines.push('\nTap to check/uncheck — pick one or more, then Submit.');
 
   const rows = opts.map((o, i) => ([{
-    text: `${multi && state.toggles[i] ? '☑️ ' : ''}${truncLabel(o.label)}`,
+    // The checkbox glyph on the BUTTON is the load-bearing affordance: an unchecked option
+    // must show ☐ (not a bare label) or it reads like a single-select tap-to-submit button.
+    text: `${multi ? (state.toggles[i] ? '☑️ ' : '☐ ') : ''}${truncLabel(o.label)}`,
     callback_data: `${callbackBase}:opt:${i}`,
   }]));
   if (multi) {

package/lib/sdk/callbacks.js

@@ -352,6 +352,24 @@ function createSdkCallbacks({
     // Telegram inline keyboard via the question handler (late-bound from polygram).
     // payload: {chatId, threadId, turnId, toolCallId, questions}. The handler
     // itself is anti-hang (answers claude {cancelled} on any send failure).
+    // 0.12 interactive questions: the blocking `ask` resolved → the turn is resuming work. The
+    // per-turn reactor cleared when claude posted its reply + asked, and no hooks fired during
+    // the wait, so it never came back — the post-answer work showed no progress ("why don't I
+    // see it working after submit?"). Re-arm the head pending's reactor to THINKING. setState is
+    // a safe no-op if the reactor was stopped; typing is unaffected (its per-turn loop runs to
+    // turn-end). Guarded — never throws on a torn-down turn.
+    onQuestionResumed: (sessionKey, entry) => {
+      try {
+        const r = entry?.pendingQueue?.[0]?.context?.reactor;
+        if (r && typeof r.setState === 'function') {
+          r.setState('THINKING');
+          logEvent('question-resumed', { chat_id: getChatIdFromKey(sessionKey), session_key: sessionKey });
+        }
+      } catch (err) {
+        logger.error?.(`[${botName}] onQuestionResumed failed: ${err.message}`);
+      }
+    },
+
     onQuestionAsked: async (sessionKey, payload) => {
       try {
         if (typeof renderQuestion !== 'function') return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.12.0-rc.33",
+  "version": "0.12.0-rc.35",
   "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

@@ -66,6 +66,7 @@ const { createHandleConfigCallback } = require('./lib/handlers/config-callback')
 const { createHandleAbort } = require('./lib/handlers/abort');
 const { createAutosteerHandlers } = require('./lib/handlers/autosteer');
 const { createEditCorrectionInjector } = require('./lib/handlers/edit-correction');
+const { createEditRedelivery } = require('./lib/handlers/edit-redelivery');
 const { createSlashCommands } = require('./lib/handlers/slash-commands');
 const { createApprovals } = require('./lib/handlers/approvals');
 const { canonicalizeToolInput } = require('./lib/canonical-json');
@@ -643,6 +644,7 @@ let handleAbortIfRequested = null;
 let autosteer = null;
 let dispatchSlashCommand = null;
 let maybeInjectEditCorrection = null;
+let maybePostTurnEdit = null;
 
 // rc.20: approvalCardText + safeParse moved to lib/approvals/ui.js.
 // 0.9.0 commit 29: makeCanUseTool / handleApprovalCallback /
@@ -2053,6 +2055,10 @@ function createBot(token) {
     }
     const chatId = ctx.editedMessage.chat.id.toString();
     if (!knownChat(chatId)) return;
+    // 0.12.0 spec §3 (HARD): read the OLD text BEFORE recordInbound overwrites the row — the
+    // post-turn changed-guard compares it, and the re-dispatch quotes it in reply_to so claude sees
+    // the before/after. Reading after recordInbound would yield the new text (useless).
+    const oldText = db.getMessage(chatId, ctx.editedMessage.message_id)?.text ?? null;
     recordInbound(ctx.editedMessage);
     logEvent('message-edited', {
       chat_id: chatId,
@@ -2061,16 +2067,15 @@ function createBot(token) {
     });
     console.log(`[${BOT_NAME}] edited ${chatId}/${ctx.editedMessage.message_id}`);
 
-    // 0.9.0: typo-correction injection. If the SDK still has this turn
-    // in flight (handler_status in dispatched/processing AND
-    // pm.get(sk).inFlight), inject a `[edit] corrected: <NEW>` note
-    // via the same channel autosteer uses. Lets users fix typos
-    // mid-turn without /stop + resend. No-op when the turn already
-    // completed.
+    // Mid-turn (turn still in flight) → fold into the running turn via the 0.9.0 injector. Post-turn
+    // (idle) — OR the injector no-ops because the turn just settled at the boundary — → re-dispatch
+    // the edited message as a NEW turn (0.12.0 edit re-delivery). `injected===false` gives the
+    // self-contained boundary fall-through.
     try {
-      maybeInjectEditCorrection?.(ctx.editedMessage);
+      const injected = maybeInjectEditCorrection?.(ctx.editedMessage);
+      if (!injected) maybePostTurnEdit?.(ctx.editedMessage, oldText, botUsername, mentionRe);
     } catch (err) {
-      console.error(`[${BOT_NAME}] edit-correction injector error: ${err.message}`);
+      console.error(`[${BOT_NAME}] edit handler error: ${err.message}`);
     }
   });
 
@@ -2505,6 +2510,17 @@ async function main() {
     getIsShuttingDown: () => isShuttingDown,
     logger: console,
   }));
+  // 0.12.0 post-turn edit re-delivery: constructed AFTER dispatchHandleMessage is assigned (above).
+  // An edit while a turn is in flight folds via maybeInjectEditCorrection; an edit after the turn
+  // (or when the injector no-ops at the boundary) re-dispatches as a new turn. The on-edit 👀 is a
+  // pre-turn ack for the cold-spawn gap; the synthetic turn's own reactor then takes over the msg.
+  maybePostTurnEdit = createEditRedelivery({
+    pm, config, getSessionKey, shouldHandle, dispatchHandleMessage, bot,
+    react: (chatId, msgId) => applyReactionToMessages({
+      tg, bot, chatId, msgIds: [msgId], emoji: '👀', botName: BOT_NAME,
+    }).catch(() => {}),
+    logEvent, logger: console,
+  });
   ({ pollBot, startPollWatchdog } = createPollLoop({
     db, dbWrite, config, botName: BOT_NAME,
     isWellFormedMessage, getTopicName,