polygram 0.12.0-rc.8 → 0.12.0

package/lib/sdk/callbacks.js

@@ -50,65 +50,23 @@ function createSdkCallbacks({
   chunkMarkdownText,
   deliverReplies,
   processAndDeliverAgentText,
+  // 0.12 interactive questions: (payload) => renders the Telegram keyboard when
+  // claude calls the `ask` tool. Optional — omitted in tests / SDK-only callers.
+  renderQuestion,
+  // 0.13 D3: session-scoped feedback controller (lib/feedback/session-feedback.js)
+  // — visuals for cycles with NO pending turn (wakeups, fireUserMessage
+  // self-checks, injected messages picked up as their own cycle). Optional.
+  sessionFeedback = null,
   logger = console,
 } = {}) {
-  // rc.9: typing-indicator state for autosteer NEW-TURN extraction.
-  // Keyed by sessionKey. extra-turn-started installs a 4-second
-  // sendChatAction loop + tracks the autosteered msgId; extra-turn-
-  // reply tears it down and clears ✍. SDK backend never installs
-  // entries (it doesn't emit either event). Per-session, not per-msg,
-  // because the TUI's queue is FIFO and we only watch one extra turn
-  // at a time per session.
-  const extraTurnTracker = new Map(); // sessionKey → { msgId, intervalHandle, chatId }
-
-  function startExtraTurnVisuals(sessionKey, msgId) {
-    if (!bot) return;
-    const chatId = getChatIdFromKey(sessionKey);
-    // Re-apply ✍ on the autosteered msg — clearAutosteeredReactions
-    // fired when primary turn 1 succeeded, so the reaction is gone.
-    // Best-effort; failures don't block.
-    tg(bot, 'setMessageReaction', {
-      chat_id: chatId,
-      message_id: msgId,
-      reaction: [{ type: 'emoji', emoji: '✍' }],
-    }, { source: 'extra-turn-started', botName }).catch((err) => {
-      logger.error?.(`[${botName}] extra-turn ✍ re-apply failed: ${err.message}`);
-    });
-    // Typing indicator loop — Telegram's typing action expires after
-    // ~5s of inactivity, so we re-emit every 4s. Stops on extra-turn-
-    // reply (or session close — see kill cleanup at the bottom of
-    // this comment chain if needed).
-    const tick = () => {
-      tg(bot, 'sendChatAction', {
-        chat_id: chatId,
-        action: 'typing',
-      }, { source: 'extra-turn-typing', botName }).catch(() => {});
-    };
-    tick();
-    const handle = setInterval(tick, 4_000);
-    const prev = extraTurnTracker.get(sessionKey);
-    if (prev?.intervalHandle) clearInterval(prev.intervalHandle);
-    extraTurnTracker.set(sessionKey, { msgId, intervalHandle: handle, chatId });
-  }
-
-  function stopExtraTurnVisuals(sessionKey, msgId) {
-    const entry = extraTurnTracker.get(sessionKey);
-    if (!entry) return;
-    if (entry.intervalHandle) clearInterval(entry.intervalHandle);
-    extraTurnTracker.delete(sessionKey);
-    // Clear ✍ on the autosteered msg — the reply itself is now the
-    // "answered" signal. Use the tracker's chatId so we don't depend
-    // on the caller passing it.
-    if (bot && entry.chatId != null) {
-      tg(bot, 'setMessageReaction', {
-        chat_id: entry.chatId,
-        message_id: msgId ?? entry.msgId,
-        reaction: [],
-      }, { source: 'extra-turn-reply-clear', botName }).catch((err) => {
-        logger.error?.(`[${botName}] extra-turn ✍ clear failed: ${err.message}`);
-      });
-    }
-  }
+  // 0.13 P4: the rc.9 extraTurnTracker (tmux NEW-TURN typing/✍ bridge) was
+  // deleted — zero 'extra-turn-started'/'extra-turn-reply' emitters exist on
+  // any backend since the 0.12 tmux deletion. Cycles with no pending turn
+  // are owned by the session feedback controller (lib/feedback/) now.
+  // 0.12.0 background-work visibility (Use 3): sessionKey → message_id of the live
+  // "⏳ working in background" status message, so the cleared/close paths can edit
+  // it to a final state instead of leaving it dangling as "working".
+  const bgStatusMsgIds = new Map();
 
   return {
     onInit: (sessionKey, event, entry) => {
@@ -147,11 +105,21 @@ function createSdkCallbacks({
     onClose: (sessionKey, code, entry) => {
       logger.log?.(`[${entry.label}] Process exited (code ${code})`);
       logEvent('process-close', { chat_id: entry.chatId, session_key: sessionKey, code });
-      // rc.9: if a session closes mid-extra-turn (turn 2 crashed,
-      // user /stop, daemon kill), tear down typing-indicator + ✍
-      // visuals so we don't leak the interval and aren't stuck
-      // showing "writing…" on a dead session.
-      stopExtraTurnVisuals(sessionKey, null);
+      // 0.13 D3: a session closing mid-autonomous-cycle must tear down the
+      // controller's visuals (typing loop + anchor reaction) — the safety net
+      // against a forever-typing leak on a dead session.
+      sessionFeedback?.endCycle(sessionKey);
+      // 0.12.0 bg-work visibility: if a "⏳ working in background" status is still
+      // up when the session closes, its shell died with the session — edit to a
+      // final state so it doesn't dangle as "working" forever.
+      const bgMid = bgStatusMsgIds.get(sessionKey);
+      if (bgMid != null && bot) {
+        bgStatusMsgIds.delete(sessionKey);
+        tg(bot, 'editMessageText', {
+          chat_id: entry.chatId, message_id: bgMid,
+          text: '⏹ Background work ended (session restarted).',
+        }, { source: 'bg-work-status', botName }).catch(() => {});
+      }
     },
 
     onStreamChunk: (sessionKey, partial, entry) => {
@@ -179,6 +147,13 @@ function createSdkCallbacks({
       const head = entry.pendingQueue?.[0];
       const r = head?.context?.reactor;
       if (r && typeof r.heartbeat === 'function') r.heartbeat();
+      // 0.13 D3 (the voice-ack gap): on cli, onFirstStream never fires, so a
+      // turn whose reactor was never set (👂 voice-ack held, THINKING skipped)
+      // stayed on the ear forever on tool-less turns. The pane heartbeat is
+      // the first life sign — promote ONCE from never-set; later polls no-op.
+      if (r && typeof r.setState === 'function' && r.currentState == null) {
+        r.setState('THINKING');
+      }
     },
 
     onToolUse: (sessionKey, toolName, entry) => {
@@ -324,71 +299,110 @@ function createSdkCallbacks({
       }
     },
 
-    // rc.9: pair-of with onExtraTurnReply. Fires the moment
-    // TmuxProcess sees the dequeued user-message in JSONL → turn 2
-    // is starting. Re-engages typing indicator + ✍ on the
-    // autosteered msg so the user has a visible "still working on
-    // this" signal during the gap between primary turn 1 ending and
-    // the extra reply landing. Without this, Ivan saw a few seconds
-    // of nothing (✍ cleared by clearAutosteeredReactions, no
-    // typing).
-    onExtraTurnStarted: (sessionKey, payload /* , entry */) => {
+    // 0.12.0 background-work visibility (Use 3). CliProcess emits this when a
+    // detached `run_in_background` shell is first observed running idle past its
+    // turn ('running') and again when it clears ('cleared'). We post ONE bot
+    // status message and edit it to done — so a long job reads as working, not
+    // stuck. Direct tg send (NOT via claude — this is a bot status indicator),
+    // keyed by sessionKey so the cleared/close paths can find it to edit.
+    // 0.12 interactive questions: claude called the `ask` tool. Render the
+    // 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.
+    // 0.13 D3: 'turn-start' (UPS) finally consumed. A pickup with NO pending
+    // turn is an autonomous/injected cycle starting — pre-P4 nothing showed
+    // until text landed. Engage the session feedback controller (typing +
+    // optional anchor 🤔 on the picked-up message, which the ledger names).
+    onTurnStart: (sessionKey, payload, entry) => {
       try {
-        const msgId = payload?.msgId;
-        if (msgId == null) return;
-        startExtraTurnVisuals(sessionKey, msgId);
-        logEvent('extra-turn-started', {
-          chat_id: getChatIdFromKey(sessionKey),
-          session_key: sessionKey,
-          msg_id: msgId,
-          backend: payload?.backend || 'tmux',
-        });
+        if (!sessionFeedback) return;
+        const hasPending = payload?.hasPending ?? (entry?.pendingQueue?.length > 0);
+        if (hasPending) return;   // normal turns own their per-turn visuals
+        sessionFeedback.startAutonomousCycle(sessionKey, { anchorMsgId: payload?.anchorMsgId ?? null });
       } catch (err) {
-        logger.error?.(`[${botName}] extra-turn-started handler: ${err.message}`);
+        logger.error?.(`[${botName}] onTurnStart failed: ${err.message}`);
       }
     },
 
-    // rc.11.1: autosteer-resolution telemetry. Fires when the JSONL
-    // tail confirms which path the autosteer resolved through:
-    //   - via:'fold' — TUI absorbed the paste as queued_command
-    //     attachment inside the current turn (one combined reply).
-    //   - via:'new-turn' — TUI dequeued as a fresh user turn
-    //     (extra-turn-reply pathway).
-    // Querying `kind='autosteer-resolution'` in the events DB gives
-    // a complete audit trail of every autosteer's fate.
-    onAutosteerResolution: (sessionKey, payload /* , entry */) => {
+    // 0.13 D3: the cycle settled — end any autonomous visuals.
+    onIdle: (sessionKey /* , entry */) => {
+      try { sessionFeedback?.endCycle(sessionKey); }
+      catch (err) { logger.error?.(`[${botName}] onIdle failed: ${err.message}`); }
+    },
+
+    onQuestionResumed: (sessionKey, entry) => {
       try {
-        logEvent('autosteer-resolution', {
-          chat_id: getChatIdFromKey(sessionKey),
-          session_key: sessionKey,
-          msg_id: payload?.msgId,
-          via: payload?.via,
-          backend: payload?.backend || 'tmux',
-        });
+        const ctx = entry?.pendingQueue?.[0]?.context;
+        // 0.13 D1 (S8): the answer landed — claude is working again. Resume
+        // the per-turn typing loop that onQuestionAsked paused. Fires before
+        // the reactor re-arm and independently of it (typing must come back
+        // even if this turn carries no reactor).
+        ctx?.typing?.resume?.();
+        const r = ctx?.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}] autosteer-resolution handler: ${err.message}`);
+        logger.error?.(`[${botName}] onQuestionResumed failed: ${err.message}`);
       }
     },
 
-    // rc.11.1: autosteer-match-miss telemetry. Fires when JSONL has
-    // a queue-folded or top-level user-message that LOOKS LIKE an
-    // autosteer dequeue but no pending content matched. This is the
-    // signature of a content-encoding mismatch (the exact rc.11.1
-    // bug — oneLine ' / ' vs newline form). The payload includes
-    // head-snippets of both sides for diff-by-eye in the events DB.
-    onAutosteerMatchMiss: (sessionKey, payload /* , entry */) => {
+    onQuestionAsked: async (sessionKey, payload, entry) => {
       try {
-        logEvent('autosteer-match-miss', {
-          chat_id: getChatIdFromKey(sessionKey),
-          session_key: sessionKey,
-          phase: payload?.phase,
-          text_head: payload?.text_head ?? payload?.prompt_head,
-          pending_head: payload?.pending_head,
-          pending_count: payload?.pending_count,
-          backend: payload?.backend || 'tmux',
-        });
+        // 0.13 D1 (S8): waiting-on-user — pause the per-turn typing loop the
+        // moment the keyboard goes up. "typing…" while the bot waits on the
+        // USER is the inverted signal; D1 keeps the turn (and its typing
+        // loop) alive through the whole wait, so without this pause every
+        // ask-wait would show continuous typing. Guarded no-op on dead turns.
+        try { entry?.pendingQueue?.[0]?.context?.typing?.pause?.(); } catch { /* guarded */ }
+        if (typeof renderQuestion !== 'function') return;
+        await renderQuestion({ sessionKey, ...payload });
       } catch (err) {
-        logger.error?.(`[${botName}] autosteer-match-miss handler: ${err.message}`);
+        logger.error?.(`[${botName}] onQuestionAsked failed: ${err.message}`);
+      }
+    },
+
+    onBgWorkStatus: async (sessionKey, payload) => {
+      try {
+        if (!bot) return;
+        const chatId = getChatIdFromKey(sessionKey);
+        const threadIdRaw = getThreadIdFromKey(sessionKey);
+        const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;
+        const state = payload?.state;
+        if (state === 'running') {
+          if (bgStatusMsgIds.has(sessionKey)) return; // already showing one
+          const res = await tg(bot, 'sendMessage', {
+            chat_id: chatId,
+            text: '⏳ Working in the background — I\'ll keep an eye on it and report when it\'s done.',
+            ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+          }, { source: 'bg-work-status', botName });
+          const mid = res?.message_id ?? res?.result?.message_id ?? null;
+          if (mid != null) bgStatusMsgIds.set(sessionKey, mid);
+          logEvent('bg-work-status', {
+            chat_id: chatId, session_key: sessionKey, thread_id: threadIdRaw,
+            state: 'running', message_id: mid,
+          });
+        } else if (state === 'cleared') {
+          const mid = bgStatusMsgIds.get(sessionKey);
+          bgStatusMsgIds.delete(sessionKey);
+          if (mid == null) return;
+          await tg(bot, 'editMessageText', {
+            chat_id: chatId, message_id: mid, text: '✅ Background work finished.',
+          }, { source: 'bg-work-status', botName }).catch(() => {});
+          logEvent('bg-work-status', {
+            chat_id: chatId, session_key: sessionKey, thread_id: threadIdRaw,
+            state: 'cleared', message_id: mid,
+          });
+        }
+      } catch (err) {
+        logger.error?.(`[${botName}] bg-work-status handler: ${err.message}`);
       }
     },
 
@@ -571,6 +585,42 @@ function createSdkCallbacks({
       }
     },
 
+    // 0.12.0-rc.13: per-chat compaction warning. CliProcess emits
+    // 'compaction-warn' when context crosses the chat's threshold at turn-end
+    // (proactive) or claude is auto-compacting now (reactive). Post a chat
+    // message proposing /compact so the user can compact on their terms BEFORE
+    // an auto-compaction interrupts a turn (and detaches the channels bridge).
+    // Opt-in per chat (lib/compaction-warn.js) — CliProcess only emits when
+    // enabled, so no extra config gate is needed here. Best-effort send.
+    onCompactionWarn: (sessionKey, payload /* , entry */) => {
+      try {
+        const chatId = getChatIdFromKey(sessionKey);
+        const threadIdRaw = getThreadIdFromKey(sessionKey);
+        const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;
+        const kind = payload?.kind === 'reactive' ? 'reactive' : 'proactive';
+        logEvent('compaction-warn', {
+          chat_id: chatId,
+          session_key: sessionKey,
+          kind,
+          pct: payload?.pct ?? null,
+          backend: payload?.backend ?? 'cli',
+        });
+        if (!bot) return;
+        const text = kind === 'reactive'
+          ? '🗜️ Auto-compacting now — context filled up. If this turn goes quiet, please resend. (Tip: running `/compact` at a natural break avoids mid-task compactions.)'
+          : `📚 Heads up — this chat's context is ~${payload?.pct ?? '?'}% full. To avoid an auto-compaction that can interrupt a turn, run \`/compact\` (optionally with a hint, e.g. \`/compact keep the recent decisions\`) at a natural break — or \`/new\` for a fresh start.`;
+        tg(bot, 'sendMessage', {
+          chat_id: chatId,
+          text,
+          ...(threadId ? { message_thread_id: threadId } : {}),
+        }, { source: 'compaction-warn', botName }).catch((err) => {
+          logger.error?.(`[${botName}] compaction-warn send failed: ${err.message}`);
+        });
+      } catch (err) {
+        logger.error?.(`[${botName}] compaction-warn handler: ${err.message}`);
+      }
+    },
+
     // 0.10.0 rc.42 #8: tmux backend hook-tail error observability.
     // Persistent failures of the hook ndjson tail degrade H3 idle-
     // ceiling accuracy and H4 Stop-synth coverage with no surface
@@ -752,58 +802,6 @@ function createSdkCallbacks({
       }
     },
 
-    // rc.7: tmux backend autosteer NEW-TURN extra reply. Fires when
-    // the TUI's queue dequeued an autosteered paste as a fresh user
-    // turn — typically when the primary turn was a short / cached
-    // reply that finished before the paste could fold in. The
-    // payload carries { msgId, text, sessionId, backend }; msgId is
-    // the Telegram message_id of the autosteered user message
-    // (so the reply lands as a Telegram reply to that message,
-    // matching how Ivan visually expects autosteer to behave).
-    //
-    // SDK backend NEVER emits this — its PostToolBatch fold path
-    // guarantees one combined reply via the primary pm.send().
-    // This is purely a tmux-backend bridge.
-    onExtraTurnReply: (sessionKey, payload /* , entry */) => {
-      try {
-        const text = payload?.text;
-        const msgId = payload?.msgId;
-        // rc.9: ALWAYS tear down extra-turn visuals first, even if
-        // text/msgId are missing — otherwise the typing-indicator
-        // loop would run forever for that session.
-        stopExtraTurnVisuals(sessionKey, msgId);
-        if (!text || msgId == null) return;
-        const chatId = getChatIdFromKey(sessionKey);
-        const threadIdRaw = getThreadIdFromKey(sessionKey);
-        const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;
-        if (!bot) {
-          logger.error?.(`[${botName}] extra-turn-reply: bot not ready, dropping ${text.length} chars`);
-          return;
-        }
-        const params = {
-          chat_id: chatId,
-          text,
-          reply_to_message_id: msgId,
-          ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
-        };
-        // Don't await — keep the pm event loop unblocked.
-        tg(bot, 'sendMessage', params,
-          { source: 'extra-turn-reply', botName }).catch((err) => {
-            logger.error?.(`[${botName}] extra-turn-reply send failed: ${err.message}`);
-          });
-        logEvent('extra-turn-reply', {
-          chat_id: chatId,
-          session_key: sessionKey,
-          thread_id: threadIdRaw,
-          msg_id: msgId,
-          text_len: text.length,
-          backend: payload?.backend || 'tmux',
-        });
-      } catch (err) {
-        logger.error?.(`[${botName}] extra-turn-reply handler: ${err.message}`);
-      }
-    },
-
     // SDK auto-compaction observability. Fires when SDK emits
     // SDKCompactBoundaryMessage. Surfaces a quiet system status note
     // to the chat so the user knows the bot is busy reorganising

package/lib/session-key.js

@@ -106,10 +106,39 @@ function getTopicConfig(chatConfig, threadId) {
   return overrides;
 }
 
+/**
+ * Resolve the config object a per-chat/topic setting (model/effort) should be
+ * WRITTEN to, given where the command/card was used. When in a topic, return
+ * (creating if needed) that topic's override entry — so a /model in the Music
+ * topic targets Music alone and matches what the per-topic card displays,
+ * instead of leaking to the chat root and every other topic that inherits it
+ * (the 2026-06-12 "/model in Music does nothing" bug). At the chat level
+ * (no thread), the writable scope is the chat config itself.
+ *
+ * @returns {{ scope: object, threadId: (string|null) }}
+ */
+function getConfigWriteScope(chatConfig, threadId) {
+  const tid = (threadId == null || threadId === '') ? null : String(threadId);
+  // Mirror getSessionKey's isolation rule: a per-topic override only takes
+  // effect when isolateTopics === true (otherwise every topic shares the
+  // chatId-keyed session and topics[tid].model is silently ignored — the
+  // 2026-06-12 review found the topic-scope fix re-broke /model on the DEFAULT
+  // non-isolated chats and made the card lie). So write the topic scope ONLY
+  // when isolated; otherwise write the chat root (the session that actually
+  // runs), and report threadId:null so the audit row reflects chat-level reach.
+  if (tid && chatConfig?.isolateTopics === true) {
+    chatConfig.topics = chatConfig.topics || {};
+    chatConfig.topics[tid] = chatConfig.topics[tid] || {};
+    return { scope: chatConfig.topics[tid], threadId: tid };
+  }
+  return { scope: chatConfig, threadId: null };
+}
+
 module.exports = {
   getSessionKey,
   getChatIdFromKey,
   getThreadIdFromKey,
   getTopicName,
   getTopicConfig,
+  getConfigWriteScope,
 };

package/lib/telegram/album-reactions.js

@@ -0,0 +1,50 @@
+/**
+ * album-reactions — apply one status reaction to every message of a Telegram
+ * album (the anchor + its siblings), so a multi-file send shows the same emoji
+ * on each item instead of only the first.
+ *
+ * Background: Telegram delivers an album as N separate messages sharing a
+ * media_group_id; polygram coalesces them into ONE turn anchored on the first.
+ * The status reactor therefore only ever reacted to that anchor, leaving the
+ * sibling files with no visible reaction (the rc.16 observation). This mirrors
+ * the reactor's emoji onto the siblings.
+ *
+ * Semantics:
+ *   - The ANCHOR (first id) is awaited so a failure surfaces to the reactor's
+ *     own error handling (same as the single-message path).
+ *   - SIBLINGS are best-effort: a failure on one must not drop the anchor's
+ *     reaction or the other siblings (and must not throw — reactions are
+ *     cosmetic). They also can't share the anchor's fate of being retried.
+ *   - Calls are sequential to respect Telegram's setMessageReaction rate limit
+ *     (~5/s/chat) — an album is ≤10 items so this stays well within budget.
+ */
+
+'use strict';
+
+/**
+ * @param {object}   opts
+ * @param {Function} opts.tg        async (bot, method, params, meta) => any
+ * @param {*}        opts.bot
+ * @param {string}   opts.chatId
+ * @param {number[]} opts.msgIds    [anchor, ...siblings] — anchor first
+ * @param {string|null} opts.emoji  emoji to set, or null/'' to clear
+ * @param {string}   [opts.botName]
+ */
+async function applyReactionToMessages({ tg, bot, chatId, msgIds, emoji, botName } = {}) {
+  const reaction = emoji ? [{ type: 'emoji', emoji }] : [];
+  const ids = Array.isArray(msgIds) ? msgIds : [];
+  for (let i = 0; i < ids.length; i++) {
+    const params = { chat_id: chatId, message_id: ids[i], reaction };
+    const meta = {
+      source: i === 0 ? 'status-reaction' : 'status-reaction-album-sibling',
+      botName,
+    };
+    if (i === 0) {
+      await tg(bot, 'setMessageReaction', params, meta);          // anchor: surface failure
+    } else {
+      await tg(bot, 'setMessageReaction', params, meta).catch(() => {});  // siblings: best-effort
+    }
+  }
+}
+
+module.exports = { applyReactionToMessages };

package/lib/telegram/parse.js

@@ -94,8 +94,15 @@ function parseResponse(text, { stickerMap = {}, emojiToSticker = {} } = {}) {
   }
 
   // Solo-emoji shortcuts (single emoji → sticker if mapped, else reaction).
-  const emojiOnly = /^\p{Emoji_Presentation}$/u.test(trimmed)
-    || /^\p{Emoji}️?$/u.test(trimmed);
+  // Keycap-base guard (2026-06-10 "2+2 → 4" dropped reply): Unicode \p{Emoji}
+  // includes 0-9/#/* (keycap bases), so a bare single-digit answer parsed as
+  // a reaction with text:'' and the channels dispatcher dropped it. A solo
+  // digit/hash/asterisk is always TEXT; real keycap emoji (4️⃣) are
+  // multi-codepoint and never hit this branch anyway. The optional ️
+  // also catches a stray variation selector on a digit ("4️") — same class.
+  const emojiOnly = !/^[0-9#*]️?$/.test(trimmed)
+    && (/^\p{Emoji_Presentation}$/u.test(trimmed)
+      || /^\p{Emoji}️?$/u.test(trimmed));
 
   if (emojiOnly && trimmed) {
     if (emojiToSticker[trimmed]) {

package/lib/telegram/typing.js

@@ -78,9 +78,13 @@ function startTyping({
   const opts = threadId ? { message_thread_id: threadId } : {};
   let timer = null;
   let stopped = false;
+  // 0.13 D1 (S8): paused while the bot is waiting on the USER (an open `ask`).
+  // "typing…" is exactly the wrong signal at the one moment user action is
+  // required — and prod questions run 16+ min (≈600 misleading pings each).
+  let paused = false;
 
   const tick = async () => {
-    if (stopped) return;
+    if (stopped || paused) return;
     const s = getState(key);
     if (s.suspendedUntil > Date.now()) return;
     try {
@@ -120,11 +124,22 @@ function startTyping({
   timer = setInterval(tick, intervalMs);
   timer.unref?.();
 
-  return () => {
+  const stop = () => {
     stopped = true;
     if (timer) clearInterval(timer);
     timer = null;
   };
+  // 0.13 D1: question lifecycle controls. pause() silences ticks without
+  // tearing the loop down; resume() restarts immediately (the answer landed,
+  // claude is working again). Attached to the stop function so every existing
+  // `stopTyping()` call site keeps working unchanged.
+  stop.pause = () => { paused = true; };
+  stop.resume = () => {
+    if (stopped) return;
+    paused = false;
+    tick();
+  };
+  return stop;
 }
 
 function resetChatTypingState(chatId) {

package/lib/tmux/startup-gate.js

@@ -60,6 +60,10 @@ const DEFAULT_SETTLE_MS = 500;
  * @param {number} [opts.pollMs=300]
  * @param {number} [opts.settleMs=500]
  * @param {string} [opts.timeoutCode='TUI_STARTUP_TIMEOUT']
+ * @param {Function} [opts.onTrigger]          — (name) => void, called AT FIRE
+ *   TIME (not gate resolution). Telemetry hung off the success-path return
+ *   misses the matched-then-died sequence (2026-06-10 prod: gate matched
+ *   session-age, then TMUX_SESSION_GONE). Errors are swallowed.
  * @param {object} [opts.logger=console]
  * @param {string} [opts.label='startup-gate']
  * @returns {Promise<{matchedTriggers: string[], elapsedMs: number}>}
@@ -74,6 +78,7 @@ async function runStartupGate({
   pollMs = DEFAULT_POLL_MS,
   settleMs = DEFAULT_SETTLE_MS,
   timeoutCode = 'TUI_STARTUP_TIMEOUT',
+  onTrigger = null,
   logger = console,
   label = 'startup-gate',
 } = {}) {
@@ -97,21 +102,28 @@ async function runStartupGate({
   // 30-second `can't find pane` spam with no diagnostic about WHY.
   let lastPane = null;
   // Progress-aware gate: timestamp of the last observed pane CHANGE (or
-  // trigger send). Seeded to startedAt so a pane that's frozen from the
-  // very first capture still trips stallMs. Only consulted when
-  // stallEnabled.
+  // trigger send). Only consulted when stallEnabled.
   let lastActivityAt = startedAt;
+  // Music incident (2026-06-01): the stall timer must NOT arm while the pane
+  // is still BLANK. A blank-and-unchanging pane means claude hasn't started
+  // rendering yet (slow cold-start), NOT that it wedged — the TUI for some
+  // topics takes 30-45s to first-render. Arming the stall timer on a blank
+  // pane killed a legitimate slow spawn at stallMs with a false "wedged".
+  // So the stall clock only runs once the pane has shown non-whitespace
+  // content; before that, only the absolute `deadlineMs` governs.
+  let sawContent = false;
 
   while (Date.now() < deadline) {
-    // Stall check (progress-aware): the pane has been doing nothing for
-    // stallMs. Distinct from the absolute deadline — fires early so a
-    // wedged TUI fails fast, while an actively-progressing one (download
-    // bar, dialog navigation) keeps resetting lastActivityAt below.
-    if (stallEnabled && Date.now() - lastActivityAt >= stallMs) {
+    // Stall check (progress-aware): the pane RENDERED something and has then
+    // been static for stallMs → genuinely wedged. Gated on sawContent so a
+    // blank cold-start isn't mistaken for a wedge. Fires early so a truly
+    // hung TUI fails fast, while an actively-progressing one (download bar,
+    // dialog navigation) keeps resetting lastActivityAt below.
+    if (stallEnabled && sawContent && Date.now() - lastActivityAt >= stallMs) {
       const err = new Error(
-        `[${label}] startup gate saw no pane activity for ${stallMs}ms for ${tmuxName} ` +
+        `[${label}] startup gate: pane rendered then went static for ${stallMs}ms for ${tmuxName} ` +
         `(matched: ${matchedTriggers.length ? matchedTriggers.join(', ') : 'none'}). ` +
-        `Pane appears wedged. Last pane content:\n` +
+        `Appears wedged. Last pane content:\n` +
         _formatPaneTail(lastPane),
       );
       err.code = timeoutCode;
@@ -147,6 +159,15 @@ async function runStartupGate({
       await new Promise(r => setTimeout(r, settleMs));
       continue;
     }
+    // First non-whitespace content = the TUI has started rendering. Only
+    // from here does the stall timer become meaningful (before this, a blank
+    // pane is cold-start, governed by the absolute deadline). Seed
+    // lastActivityAt at the moment content first appears so the stall window
+    // is measured from "rendered", not from spawn.
+    if (!sawContent && pane && pane.trim().length > 0) {
+      sawContent = true;
+      lastActivityAt = Date.now();
+    }
     // Progress signal: any change in pane content is activity → reset the
     // stall clock. A captureWide that returns the SAME bytes is NOT
     // activity (a frozen download bar at 24% reads identically each poll).
@@ -158,13 +179,22 @@ async function runStartupGate({
     for (const trigger of triggers) {
       if (seen.has(trigger.name)) continue;
       if (!trigger.regex.test(pane)) continue;
-      try {
-        await runner.sendControl(tmuxName, trigger.key);
-      } catch (err) {
-        logger.warn?.(`[${label}] sendControl(${trigger.key}) failed for trigger=${trigger.name}: ${err.message}`);
+      // `keys: [...]` sends a sequence (dialog navigation — e.g. Down,Enter
+      // to pick a non-default option); `key:` remains the single-key form.
+      // Sequence keys go as separate send-keys calls with a short delay —
+      // Ink dialogs can swallow the second key of a same-batch sequence.
+      const keySeq = Array.isArray(trigger.keys) ? trigger.keys : [trigger.key];
+      for (let ki = 0; ki < keySeq.length; ki++) {
+        if (ki > 0) await new Promise(r => setTimeout(r, Math.min(settleMs, 120)));
+        try {
+          await runner.sendControl(tmuxName, keySeq[ki]);
+        } catch (err) {
+          logger.warn?.(`[${label}] sendControl(${keySeq[ki]}) failed for trigger=${trigger.name}: ${err.message}`);
+        }
       }
       seen.add(trigger.name);
       matchedTriggers.push(trigger.name);
+      try { onTrigger?.(trigger.name); } catch { /* telemetry must not break the gate */ }
       matched = true;
       // Sending a key is activity — navigating the TUI counts as progress
       // even if the pre-transition pane text was static (e.g. a dialog we