polygram 0.10.0-rc.2 → 0.10.0-rc.21

package/lib/process-manager.js

@@ -48,6 +48,37 @@ const CALLBACK_TO_EVENT = {
   // onApprovalRequired to route tmux prompts through the SAME
   // approval card UI used by SDK's canUseTool flow.
   onApprovalRequired:           'approval-required',
+  // rc.7: tmux backend autosteer "NEW-TURN" extra reply. Fires when
+  // the TUI's queue dequeued an autosteered paste as a fresh user
+  // turn (because primary turn ended before fold could happen). The
+  // payload is { msgId, text, sessionId, backend } and polygram
+  // routes it to Telegram as a reply to the autosteered msgId. SDK
+  // backend never emits this — its PostToolBatch fold path
+  // guarantees one combined reply.
+  onExtraTurnReply:             'extra-turn-reply',
+  // rc.9: pair-of with onExtraTurnReply. Fires the MOMENT TmuxProcess
+  // sees the dequeued user-message in JSONL, which is the start of
+  // turn 2 — gives polygram a hook to re-engage typing indicator and
+  // re-apply the ✍ reaction on the autosteered msg (otherwise the
+  // user sees a silent gap from when clearAutosteeredReactions fired
+  // at primary turn 1 success until the extra-turn reply lands).
+  // Payload: { msgId, sessionId, backend }.
+  onExtraTurnStarted:           'extra-turn-started',
+  // rc.11.1: observability — autosteer resolution + match-miss events.
+  // - autosteer-resolution: { msgId, via: 'fold'|'new-turn' } —
+  //   confirms which JSONL signal resolved each autosteered msgId.
+  // - autosteer-match-miss: { phase, *_head, pending_count } —
+  //   fires when JSONL has the queue/dequeue signal but content
+  //   doesn't match any pending. The signature of the rc.11.1 bug
+  //   (oneLine ' / ' vs newline mismatch) would have shown up here.
+  onAutosteerResolution:        'autosteer-resolution',
+  onAutosteerMatchMiss:         'autosteer-match-miss',
+  // R8: tmux backend autosteer paste failure. TmuxProcess.injectUserMessage
+  // fires `inject-fail` when its fire-and-forget paste rejects. Before
+  // this was wired the event had no consumer — a failed autosteer was
+  // silent until the stale-turn sweep caught it turnTimeoutMs later.
+  // The handler logs the failure and clears the ✍ on the failed msgId.
+  onInjectFail:                 'inject-fail',
 };
 
 class ProcessManager {
@@ -82,6 +113,10 @@ class ProcessManager {
     this.procs = new Map();           // sessionKey → Process
     this._lruWaiters = [];            // [{ resolve, reject, timer }]
     this._shuttingDown = false;
+    // sessionKey → in-flight start() Promise. Lets a concurrent
+    // getOrSpawn for the same key await the spawn instead of
+    // returning a proc whose start() hasn't resolved (see getOrSpawn).
+    this._starting = new Map();
   }
 
   // ─── Introspection ───────────────────────────────────────────────
@@ -116,7 +151,20 @@ class ProcessManager {
     if (this._shuttingDown) throw new Error('shutdown');
 
     const existing = this.procs.get(sessionKey);
-    if (existing && !existing.closed) return existing;
+    if (existing && !existing.closed) {
+      // getOrSpawn registers the proc in this.procs BEFORE awaiting
+      // start(). A concurrent getOrSpawn for the same key (a second
+      // Telegram message landing during the ~11s tmux spawn) would
+      // otherwise get this still-spawning proc and call send() on it
+      // — pasting a turn into a TUI that is not ready, which silently
+      // drops the paste and returns an empty turn (shumorobot
+      // production 2026-05-16: msg 2 of a 3-message burst returned
+      // "No response generated"). Await the in-flight spawn so every
+      // caller receives a proc whose start() has fully resolved.
+      const pendingStart = this._starting.get(sessionKey);
+      if (pendingStart) await pendingStart;
+      return existing;
+    }
 
     // Provisional new-process cost — ask the factory but don't start yet.
     const newProc = this.processFactory(sessionKey, spawnContext);
@@ -138,11 +186,17 @@ class ProcessManager {
     this._wireCallbacks(newProc);
     this.procs.set(sessionKey, newProc);
     newProc.lastUsedTs = Date.now();
+    // Publish the in-flight start() Promise so concurrent getOrSpawn
+    // callers (above) can await it instead of racing the spawn.
+    const startP = newProc.start(spawnContext);
+    this._starting.set(sessionKey, startP);
     try {
-      await newProc.start(spawnContext);
+      await startP;
     } catch (err) {
       this.procs.delete(sessionKey);
       throw err;
+    } finally {
+      this._starting.delete(sessionKey);
     }
     return newProc;
   }

package/lib/sdk/callbacks.js

@@ -37,6 +37,64 @@ function createSdkCallbacks({
   getThreadIdFromKey,
   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}`);
+      });
+    }
+  }
+
   return {
     onInit: (sessionKey, event, entry) => {
       dbWrite(() => db.upsertSession({
@@ -54,6 +112,11 @@ 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);
     },
 
     onStreamChunk: (sessionKey, partial, entry) => {
@@ -153,6 +216,162 @@ 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 */) => {
+      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',
+        });
+      } catch (err) {
+        logger.error?.(`[${botName}] extra-turn-started handler: ${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 */) => {
+      try {
+        logEvent('autosteer-resolution', {
+          chat_id: getChatIdFromKey(sessionKey),
+          session_key: sessionKey,
+          msg_id: payload?.msgId,
+          via: payload?.via,
+          backend: payload?.backend || 'tmux',
+        });
+      } catch (err) {
+        logger.error?.(`[${botName}] autosteer-resolution handler: ${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 */) => {
+      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',
+        });
+      } catch (err) {
+        logger.error?.(`[${botName}] autosteer-match-miss 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
+    // wired the event had NO consumer — a failed autosteer was silent
+    // until the stale-turn sweep caught it `turnTimeoutMs` later, so
+    // the ✍ reaction sat on the message for up to 5 minutes with no
+    // reply coming. This surfaces it immediately: log the failure for
+    // diagnosis and clear the ✍ on the autosteered msgId so the user
+    // is not left looking at a "noted, working on it" signal for a
+    // message that never reached the agent. tmux-only — the SDK
+    // backend's injectUserMessage never emits inject-fail.
+    onInjectFail: (sessionKey, payload /* , entry */) => {
+      try {
+        const msgId = payload?.msgId;
+        logEvent('inject-fail', {
+          chat_id: getChatIdFromKey(sessionKey),
+          session_key: sessionKey,
+          msg_id: msgId ?? null,
+          error: (payload?.err || '').slice(0, 200),
+          backend: payload?.backend || 'tmux',
+        });
+        if (bot && msgId != null) {
+          const chatId = getChatIdFromKey(sessionKey);
+          tg(bot, 'setMessageReaction', {
+            chat_id: chatId,
+            message_id: msgId,
+            reaction: [],
+          }, { source: 'inject-fail-clear', botName }).catch((err) => {
+            logger.error?.(`[${botName}] inject-fail ✍ clear failed: ${err.message}`);
+          });
+        }
+      } catch (err) {
+        logger.error?.(`[${botName}] inject-fail handler: ${err.message}`);
+      }
+    },
+
+    // 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