polygram 0.8.0-rc.2 → 0.8.0-rc.21

package/polygram.js

@@ -31,6 +31,16 @@ const { ProcessManager } = require('./lib/process-manager');
 // pick-at-startup. Phase 4 deletes the CLI version after Phase 5
 // soak proves SDK stable. See docs/0.8.0-architecture-decisions.md.
 const { ProcessManagerSdk } = require('./lib/process-manager-sdk');
+const { createAutosteerBuffer, makePostToolBatchHook } = require('./lib/autosteer-buffer');
+const { makeRouterPolicy, createPmRouter } = require('./lib/pm-router');
+const { canonicalizeToolInput } = require('./lib/canonical-json');
+const {
+  buildApprovalKeyboard,
+  buildApprovalKeyboardWithAlways,
+  formatToolInputForCard,
+  approvalCardText,
+} = require('./lib/approval-ui');
+const { makeSessionStartHook } = require('./lib/history-preload');
 const agentLoader = require('./lib/agent-loader');
 const USE_SDK = process.env.POLYGRAM_USE_SDK === '1';
 const { createSender } = require('./lib/telegram');
@@ -698,6 +708,91 @@ function formatPrompt(msg, sessionCtx, attachments = []) {
 
 let pm = null; // ProcessManager, created in main()
 
+// 0.8.0-rc.9: per-session autosteer buffer. Holds user follow-ups
+// that arrive mid-turn so the SDK pm's PostToolBatch hook can drain
+// them into `additionalContext` on each tool boundary. Replaces the
+// rc.6/rc.7 approach of pushing priority:'now' SDKUserMessages
+// directly (which violated the SDK's m87 transcript-shape gate when
+// the assistant was mid-tool-use).
+const autosteerBuffer = createAutosteerBuffer();
+
+// 0.8.0-rc.14: track msg_ids that received the AUTOSTEERED ✍ ack, per
+// session, so we can clear those reactions when the in-flight turn
+// finishes. Pre-rc.14 the ✍ persisted forever because each autosteer
+// invocation runs in its OWN handleMessage scope (own reactor), and
+// the TRIGGER message's reactor.clear() at turn-end couldn't reach
+// across to other messages. Without this map, users see ✍ stuck on
+// every follow-up and don't know whether the bot incorporated them.
+const autosteeredMsgRefs = new Map(); // sessionKey → [{chatId, msgId}]
+
+async function clearAutosteeredReactions(sessionKey) {
+  const list = autosteeredMsgRefs.get(sessionKey);
+  if (!list || list.length === 0) return;
+  autosteeredMsgRefs.delete(sessionKey);
+  if (!bot) return;
+  for (const { chatId: cid, msgId } of list) {
+    try {
+      await tg(bot, 'setMessageReaction', {
+        chat_id: cid, message_id: msgId, reaction: [],
+      }, { source: 'autosteer-clear', botName: BOT_NAME });
+    } catch (err) {
+      // Ack-clear failures are silent — the ✍ stays on screen
+      // but doesn't block the in-flight turn's reply UX.
+    }
+  }
+}
+
+// 0.8.0-rc.14: tool-less-turn drain. PostToolBatch hook only fires
+// on tool boundaries — when a Query produces a turn that uses ZERO
+// tools (just a text answer), the autosteerBuffer never gets
+// drained and any user follow-ups buffered during that turn
+// disappear silently into the next tool-using turn (or never, if
+// the chat is purely conversational).
+//
+// Workaround: at every success exit in handleMessage, check if
+// the buffer still has items and dispatch them as a synthetic
+// next turn via pm.send. The bot replies to the drained content
+// in a fresh turn — UX-wise the user sees TWO replies (one to
+// the trigger message, one to "B + C") which is the same as if
+// they'd sent the messages without autosteer. Better than losing.
+async function drainStaleAutosteerBuffer(sessionKey, chatId, threadId) {
+  const stale = autosteerBuffer.drain(sessionKey);
+  if (stale.length === 0) return;
+  const followUpPrompt = stale.join('\n\n');
+  logEvent('autosteer-stale-drain', {
+    chat_id: chatId,
+    session_key: sessionKey,
+    message_count: stale.length,
+    text_len: followUpPrompt.length,
+  });
+  // Dispatch as a fresh pm.send via setImmediate so we don't
+  // block the current handleMessage's success-path return. No
+  // streamer / reactor — the synthetic turn gets a plain bubble
+  // reply (no streaming preview, no progress reactions). User
+  // already saw their ✍ ack on the original follow-up; this
+  // turn's existence is the substantive response.
+  setImmediate(async () => {
+    try {
+      const chatConfig = config.chats[chatId];
+      if (!chatConfig) return;
+      const result = await sendToProcess(sessionKey, followUpPrompt, {
+        streamer: null, reactor: null, sourceMsgId: null,
+      });
+      if (result?.text && bot) {
+        await tg(bot, 'sendMessage', {
+          chat_id: chatId,
+          text: result.text,
+          ...(threadId ? { message_thread_id: threadId } : {}),
+        }, { source: 'autosteer-stale-reply', botName: BOT_NAME }).catch((err) => {
+          console.error(`[${BOT_NAME}] autosteer-stale-reply send: ${err.message}`);
+        });
+      }
+    } catch (err) {
+      console.error(`[${BOT_NAME}] autosteer-stale-drain dispatch: ${err.message}`);
+    }
+  });
+}
+
 function spawnClaude(sessionKey, ctx) {
   const { chatConfig, existingSessionId, label, chatId } = ctx;
   // 0.7.3: Claude Code's Chrome-extension integration (browser
@@ -784,6 +879,10 @@ function buildSdkOptions(sessionKey, ctx) {
     try {
       agentBundle = agentLoader.loadAgent(chatConfig.agent, {
         homeDir: CHILD_HOME,
+        // Pass cwd so the loader checks Claude Code's project-level
+        // path (`<cwd>/.claude/agents/<name>.md`) before the
+        // user-level path or polygram's directory convention.
+        cwd: chatConfig.cwd,
         logger: console,
       });
     } catch (err) {
@@ -817,6 +916,35 @@ function buildSdkOptions(sessionKey, ctx) {
   const useCanUseTool = apprCfg && apprCfg.adminChatId
     && Array.isArray(apprCfg.gatedTools) && apprCfg.gatedTools.length > 0;
 
+  // 0.8.0-rc.9 (factored to lib/autosteer-buffer.js in rc.17): the
+  // PostToolBatch hook drains the autosteer buffer for THIS session
+  // and injects queued user follow-ups as `additionalContext` on
+  // each tool boundary, wrapped in `<channel source="user-followup">`
+  // which Claude is trained to trust as legitimate out-of-band user
+  // context.
+  const postToolBatchHook = makePostToolBatchHook({
+    buffer: autosteerBuffer,
+    sessionKey,
+    chatId: ctx?.chatId ?? null,
+    logEvent,
+    logger: console,
+  });
+
+  // 0.8.0-rc.21: SessionStart hook preloads recent polygram-DB
+  // history into a fresh Query (no resume). Without this, every
+  // /new or daemon-boot starts the agent blank — even though the
+  // chat has been running for weeks. Skips when source is
+  // 'resume' or 'compact' (transcript already populated).
+  const sessionStartHook = ctx?.chatId
+    ? makeSessionStartHook({
+        db,
+        chatId: ctx.chatId,
+        threadId: ctx.threadId ?? null,
+        logEvent,
+        logger: console,
+      })
+    : null;
+
   const baseOpts = {
     model: chatConfig.model || config.defaults.model,
     effort: chatConfig.effort || config.defaults.effort,
@@ -828,6 +956,12 @@ function buildSdkOptions(sessionKey, ctx) {
     permissionMode: useCanUseTool ? 'default' : 'bypassPermissions',
     allowDangerouslySkipPermissions: !useCanUseTool,
     ...(useCanUseTool && { canUseTool: makeCanUseTool(sessionKey) }),
+    hooks: {
+      PostToolBatch: [{ hooks: [postToolBatchHook] }],
+      ...(sessionStartHook && {
+        SessionStart: [{ hooks: [sessionStartHook] }],
+      }),
+    },
     executable: 'node',
     ...(existingSessionId && { resume: existingSessionId }),
     ...(process.env.POLYGRAM_CLAUDE_BIN && {
@@ -1123,51 +1257,9 @@ async function handleSendOverIpc(req) {
 }
 
 // ─── Approvals ─────────────────────────────────────────────────────
-
-// Format a tool_input for the inline keyboard card. Clip aggressively so
-// the card doesn't exceed Telegram's 4096-char limit.
-function formatToolInputForCard(input) {
-  let s;
-  try { s = typeof input === 'string' ? input : JSON.stringify(input, null, 2); }
-  catch { s = String(input); }
-  if (s.length <= 1200) return s;
-  return s.slice(0, 900) + '\n…[clipped]…\n' + s.slice(-200);
-}
-
-function buildApprovalKeyboard(approvalId, token) {
-  return {
-    inline_keyboard: [[
-      { text: '✅ Approve', callback_data: `approve:${approvalId}:${token}` },
-      { text: '❌ Deny',    callback_data: `deny:${approvalId}:${token}` },
-    ]],
-  };
-}
-
-// 0.8.0 Phase 2 step 6: 4-button approval keyboard for SDK canUseTool
-// flow. Adds "Always allow" and "Always deny" rows that persist the
-// decision into chat_tool_decisions (via callback_query handler),
-// so subsequent invocations of the same tool with the same input
-// short-circuit without prompting.
-//
-// Callback_data conventions:
-//   approve:<id>:<token>          — one-time allow
-//   deny:<id>:<token>             — one-time deny
-//   approve-always:<id>:<token>   — allow + persist
-//   deny-always:<id>:<token>      — deny + persist
-function buildApprovalKeyboardWithAlways(approvalId, token) {
-  return {
-    inline_keyboard: [
-      [
-        { text: '✅ Approve', callback_data: `approve:${approvalId}:${token}` },
-        { text: '❌ Deny',    callback_data: `deny:${approvalId}:${token}` },
-      ],
-      [
-        { text: '🔁 Always allow', callback_data: `approve-always:${approvalId}:${token}` },
-        { text: '🚫 Always deny',  callback_data: `deny-always:${approvalId}:${token}` },
-      ],
-    ],
-  };
-}
+// rc.20: pure UI builders moved to lib/approval-ui.js for testability.
+// Imported above (buildApprovalKeyboard, buildApprovalKeyboardWithAlways,
+// approvalCardText, formatToolInputForCard).
 
 // /model and /effort inline keyboard. `show` controls which row(s) appear:
 // 'model', 'effort', or 'all'. The current value gets a ✓ marker so the
@@ -1236,54 +1328,10 @@ function formatConfigInfoText(chatConfig, show, sessionKey) {
   return body;
 }
 
-function approvalCardText(row, opts = {}) {
-  // No parse_mode is used on this card — tool_name/turn_id/tool_input
-  // originate from the Claude subprocess and could contain Markdown special
-  // chars or tg:// links crafted for phishing. Plain text renders as-is.
-  const heading = opts.resolvedBy
-    ? opts.resolvedBy
-    : `Approval needed — ${row.tool_name}`;
-  const body = formatToolInputForCard(
-    typeof row.tool_input_json === 'string'
-      ? safeParse(row.tool_input_json)
-      : row.tool_input_json,
-  );
-  const ttl = Math.max(0, Math.round((row.timeout_ts - Date.now()) / 1000));
-  const footer = opts.resolvedBy
-    ? ''
-    : `\n\n⏱ expires in ${ttl}s`;
-  return `${heading}\nChat: ${row.requester_chat_id}\nTurn: ${row.turn_id || '-'}\n\n${body}${footer}`;
-}
+// rc.20: approvalCardText + safeParse moved to lib/approval-ui.js.
 
-function safeParse(s) {
-  try { return JSON.parse(s); } catch { return s; }
-}
-
-/**
- * 0.8.0 Phase 2 step 6: canonical-JSON-stringify of a tool input
- * object. Keys sorted alphabetically; no whitespace. Used as the
- * dedup key for chat_tool_decisions match_type='exact' lookups
- * and as the input_pattern stored on "Always allow" clicks.
- *
- * Why canonical: Claude can reorder JSON keys between retries of
- * the same tool call (different SDK versions, different temperature
- * sampling). Without canonicalisation, the dedup digest would
- * differ for semantically-identical calls and the user would see
- * the same approval card twice (ship-breaker M8 mitigation).
- */
-function canonicalizeToolInput(input) {
-  if (input == null || typeof input !== 'object') {
-    return JSON.stringify(input);
-  }
-  const sortRec = (v) => {
-    if (Array.isArray(v)) return v.map(sortRec);
-    if (v == null || typeof v !== 'object') return v;
-    const out = {};
-    for (const k of Object.keys(v).sort()) out[k] = sortRec(v[k]);
-    return out;
-  };
-  return JSON.stringify(sortRec(input));
-}
+// 0.8.0-rc.18+: canonicalizeToolInput moved to lib/canonical-json.js
+// for testability. Same function, no behavior change.
 
 /**
  * 0.8.0 Phase 2 step 6: SDK canUseTool callback. Hands back to the
@@ -1709,16 +1757,38 @@ async function handleConfigCallback(ctx) {
     user: cmdUser, user_id: cmdUserId, source: 'inline-button',
   }), `log ${setting} change`);
 
-  // Graceful respawn of the topic's session that the card is in. With
+  // Graceful application of the change to the topic's session. With
   // isolateTopics=false sessionKey is the chat (one shared session). With
   // isolateTopics=true sessionKey carries the topic, so other topics'
   // in-flight turns are not disturbed and the card update + button toast
-  // only affect the user's own context. Mirrors the text-command flow in
-  // handleMessage's requestRespawnForSession.
+  // only affect the user's own context.
+  //
+  // CLI pm: requestRespawn drains pending turns then kills the process;
+  //   the next user message spawns fresh with the updated chatConfig.
+  // SDK pm: applies live to the running Query via setModel /
+  //   applyFlagSettings — no respawn needed, change takes effect for the
+  //   rest of the in-flight turn AND all future ones. Falls back to
+  //   {killed: false} if neither method is available, leaving the new
+  //   chatConfig value to be picked up by the next cold spawn.
   const callbackThreadId = ctx.callbackQuery.message?.message_thread_id?.toString() || null;
   const callbackSessionKey = getSessionKey(chatId, callbackThreadId, chatConfig);
   const reason = setting === 'model' ? 'model-change' : 'effort-change';
-  const respawn = pm.requestRespawn(callbackSessionKey, reason);
+  // Feature-detect on the routed pm for this specific session, not on
+  // the router itself (the router exposes every method as a forwarding
+  // shim so `typeof pm.X` is always 'function').
+  const pmForCb = pm.pickFor(callbackSessionKey);
+  let respawn;
+  if (typeof pmForCb.requestRespawn === 'function') {
+    respawn = pmForCb.requestRespawn(callbackSessionKey, reason);
+  } else if (setting === 'effort' && typeof pmForCb.applyFlagSettings === 'function') {
+    const ok = await pmForCb.applyFlagSettings(callbackSessionKey, { effortLevel: value });
+    respawn = { killed: ok };
+  } else if (setting === 'model' && typeof pmForCb.setModel === 'function') {
+    const ok = await pmForCb.setModel(callbackSessionKey, value);
+    respawn = { killed: ok };
+  } else {
+    respawn = { killed: false };
+  }
   const anyActive = !respawn.killed;
 
   // Re-render the card with updated ✓ + the same help text shown initially.
@@ -1873,8 +1943,8 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   // usage report. Only meaningful under SDK pm (CLI pm has no
   // getContextUsage equivalent); CLI path replies with a hint.
   if (botAllowsCommands && text === '/context') {
-    if (!USE_SDK) {
-      await sendReply('📚 /context requires the SDK pm (set POLYGRAM_USE_SDK=1 to enable).');
+    if (!pm.isSdkFor(sessionKey)) {
+      await sendReply('📚 /context requires the SDK pm. This chat is on the CLI pm path.');
       return;
     }
     const entry = pm.get(sessionKey);
@@ -1885,13 +1955,18 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     }
     try {
       const u = await q.getContextUsage();
-      const pct = ((u?.percentage ?? 0) * 100).toFixed(0);
+      // SDK returns percentage in 0-100 scale (verified rc.3 prod
+      // — saw "77" for a 77%-used context). Display directly.
+      const pct = (u?.percentage ?? 0).toFixed(0);
       const total = (u?.totalTokens ?? 0).toLocaleString();
       const max = (u?.maxTokens ?? 0).toLocaleString();
       const lines = [`📚 Context: ${total} / ${max} tokens (${pct}%)`];
       if (u?.model) lines.push(`Model: ${u.model}`);
       if (u?.isAutoCompactEnabled && u?.autoCompactThreshold) {
-        const thrPct = (u.autoCompactThreshold * 100).toFixed(0);
+        // autoCompactThreshold scale is currently unverified; assume
+        // matches percentage (0-100). If it turns out to be 0-1 we'll
+        // see something like "Auto-compact at 0%" and can flip back.
+        const thrPct = u.autoCompactThreshold.toFixed(0);
         lines.push(`Auto-compact at ${thrPct}%.`);
       }
       // Top-3 categories by token cost so the user knows where the
@@ -1914,9 +1989,10 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   }
   if (botAllowsCommands && (text === '/new' || text === '/reset')) {
     let drained = 0;
-    if (typeof pm.resetSession === 'function') {
+    const target = pm.pickFor(sessionKey);
+    if (typeof target.resetSession === 'function') {
       try {
-        const r = await pm.resetSession(sessionKey, { reason: text.slice(1) });
+        const r = await target.resetSession(sessionKey, { reason: text.slice(1) });
         drained = r?.drainedPendings ?? 0;
       } catch (err) {
         console.error(`[${label}] resetSession ${text}: ${err.message}`);
@@ -1938,48 +2014,39 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     await sendReply('✨ Started a fresh session.');
     return;
   }
-  // 0.8.0 Phase 2 step 1: /steer <text> — mid-turn steering. Pushes
-  // a priority:'now' user message onto the active Query so Claude
-  // sees it without waiting for the in-flight turn to fully
-  // complete. SDK pm only — CLI pm has no steer primitive (its
-  // stream-json transport is request-response, not interruptible
-  // mid-turn). Falls back to /new under CLI pm.
-  if (botAllowsCommands && text.startsWith('/steer ')) {
-    const steerText = text.slice(7).trim();
-    if (!steerText) { await sendReply('Usage: /steer <text>'); return; }
-    if (!USE_SDK || typeof pm.steer !== 'function') {
-      await sendReply('🛞 /steer requires the SDK pm (set POLYGRAM_USE_SDK=1 to enable).');
-      return;
-    }
-    if (!pm.has(sessionKey)) {
-      await sendReply('🛞 No active session — /steer only works mid-turn. Send a message first, then /steer while it\'s thinking.');
-      return;
-    }
-    const ok = pm.steer(sessionKey, steerText);
-    if (ok) {
-      logEvent('steer-command', {
-        chat_id: chatId, text_len: steerText.length,
-        user: cmdUser, user_id: cmdUserId,
-      });
-      // Quiet ack so user knows it landed; the actual response will
-      // arrive as the in-flight turn's continuation.
-      await sendReply('🛞 Steering applied. Watching for the response.');
-    } else {
-      await sendReply('🛞 Couldn\'t apply steer — session may have just closed.');
-    }
-    return;
-  }
-  // Graceful respawn of the user's CURRENT session only. With
-  // isolateTopics=false the sessionKey is just the chat (one shared
-  // session for the whole chat — every topic respawns implicitly).
-  // With isolateTopics=true each topic is a separate session, and a
-  // /model in topic A should NOT disturb topic B's in-flight turn or
-  // post a phantom "✓ Using sonnet now" in a topic that didn't ask.
-  // Pre-0.6.5 this iterated pm.keys() by chat prefix and incorrectly
-  // fanned out across all topics under isolateTopics=true.
-  const requestRespawnForSession = (reason) => {
-    const res = pm.requestRespawn(sessionKey, reason);
-    return { queued: res.queued, anyActive: !res.killed };
+  // 0.8.0-rc.9: /steer command removed. Mid-turn user input is
+  // handled implicitly by autosteer — any follow-up message during
+  // an in-flight SDK turn flows through autosteerBuffer +
+  // PostToolBatch hook. No explicit command needed; matches Claude
+  // Code interactive UX where you just keep typing.
+  // Graceful application of a model/effort change to the user's CURRENT
+  // session only. With isolateTopics=false the sessionKey is just the
+  // chat (one shared session for the whole chat — every topic
+  // respawns implicitly). With isolateTopics=true each topic is a
+  // separate session, and a /model in topic A should NOT disturb
+  // topic B's in-flight turn or post a phantom "✓ Using sonnet now"
+  // in a topic that didn't ask.
+  //
+  // CLI pm: requestRespawn drains pending turns then kills the process;
+  //   the next user message spawns fresh with the updated chatConfig.
+  // SDK pm: applies live to the running Query via setModel /
+  //   applyFlagSettings — no respawn needed, change takes effect for
+  //   the rest of the in-flight turn AND all future ones.
+  const applyConfigChange = async (reason, setting, value) => {
+    const target = pm.pickFor(sessionKey);
+    if (typeof target.requestRespawn === 'function') {
+      const res = target.requestRespawn(sessionKey, reason);
+      return { queued: res.queued, anyActive: !res.killed };
+    }
+    if (setting === 'effort' && typeof target.applyFlagSettings === 'function') {
+      const ok = await target.applyFlagSettings(sessionKey, { effortLevel: value });
+      return { queued: 0, anyActive: !ok };
+    }
+    if (setting === 'model' && typeof target.setModel === 'function') {
+      const ok = await target.setModel(sessionKey, value);
+      return { queued: 0, anyActive: !ok };
+    }
+    return { queued: 0, anyActive: false };
   };
 
   if (botAllowsCommands && text.startsWith('/model ')) {
@@ -1993,7 +2060,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         old_value: oldModel, new_value: newModel,
         user: cmdUser, user_id: cmdUserId, source: 'command',
       }), 'log model change');
-      const { anyActive } = requestRespawnForSession('model-change');
+      const { anyActive } = await applyConfigChange('model-change', 'model', newModel);
       const ver = MODEL_VERSIONS[newModel] || newModel;
       const suffix = anyActive ? ` — I'll switch when I finish` : '';
       await sendReply(`Model → ${newModel} (${ver})${suffix}`);
@@ -2013,7 +2080,7 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
         old_value: oldEffort, new_value: newEffort,
         user: cmdUser, user_id: cmdUserId, source: 'command',
       }), 'log effort change');
-      const { anyActive } = requestRespawnForSession('effort-change');
+      const { anyActive } = await applyConfigChange('effort-change', 'effort', newEffort);
       const suffix = anyActive ? ` — I'll switch when I finish` : '';
       await sendReply(`Effort → ${newEffort}${suffix}`);
     } else {
@@ -2366,34 +2433,59 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
   // chatConfig.autosteer === false). CLI pm always falls through
   // to the queue-FIFO path (no steer primitive on stream-json).
   //
-  // The steered message gets a 🛞 reaction so the user knows it
+  // The steered message gets a ✍ reaction so the user knows it
   // landed; no separate reply is generated (the in-flight turn's
   // response covers both messages, OpenClaw-style).
+  //
+  // Reaction emoji must be from Telegram's curated allowlist
+  // (~60 standard emoji per core.telegram.org/bots/api#availablereactions).
+  // 🛞 (steering wheel) is NOT on it — Telegram returns
+  // 400: REACTION_INVALID. ✍ ("writing/noting") is on the list and
+  // conveys "incorporating this".
   const chatAutosteer = chatConfig.autosteer != null
     ? chatConfig.autosteer
     : config.bot?.autosteer;
-  const autosteerEnabled = USE_SDK && chatAutosteer !== false;
-  if (autosteerEnabled && typeof pm.steer === 'function' && pm.has(sessionKey)) {
+  // 0.8.0-rc.9: autosteer now drives through autosteerBuffer +
+  // PostToolBatch hook (in buildSdkOptions), not pm.steer's direct
+  // inputController push. The hook fires on every tool boundary
+  // and injects queued follow-ups as <channel source="user-followup">
+  // additionalContext — the SDK-trusted framing that survives the
+  // m87 transcript-shape gate.
+  //
+  // We still gate on the SDK pm path: under CLI pm there's no
+  // PostToolBatch hook surface, so autosteer falls through to the
+  // regular FIFO send (same UX as 0.7.x).
+  const autosteerEnabled = chatAutosteer !== false
+    && pm.isSdkFor(sessionKey);
+  if (autosteerEnabled && pm.has(sessionKey)) {
     const entry = pm.get(sessionKey);
     if (entry?.inFlight) {
-      const ok = pm.steer(sessionKey, prompt);
+      const ok = autosteerBuffer.append(sessionKey, prompt);
       if (ok) {
-        // Quiet ack — no chat-bubble reply, just a reaction so the
-        // user sees their message was incorporated. The in-flight
-        // turn's response will address both questions.
-        tg(bot, 'setMessageReaction', {
-          chat_id: chatId,
-          message_id: msg.message_id,
-          reaction: [{ type: 'emoji', emoji: '🛞' }],
-        }, { source: 'autosteer-ack', botName: BOT_NAME }).catch((err) => {
-          console.error(`[${label}] autosteer reaction: ${err.message}`);
-        });
+        // Track this msg_id so the in-flight turn's success / abort
+        // / error path can clear the ✍ reaction at turn-end.
+        const refs = autosteeredMsgRefs.get(sessionKey) || [];
+        refs.push({ chatId, msgId: msg.message_id });
+        autosteeredMsgRefs.set(sessionKey, refs);
         logEvent('autosteer', {
           chat_id: chatId, msg_id: msg.message_id,
           text_len: prompt?.length ?? 0,
         });
         stopTyping();
-        reactor.stop();
+        // 0.8.0-rc.11: route the ✍ ack through the reactor's
+        // serialized apply chain. Pre-rc.11 we used a direct
+        // setMessageReaction(✍) racing with the reactor's
+        // QUEUED→👀 apply AND a follow-up reactor.clear() — three
+        // concurrent network calls, final state was whichever
+        // landed last at Telegram. Symptom: 👀 sometimes stuck,
+        // ✍ sometimes vanished, reactions disappeared "almost
+        // immediately" or got stuck arbitrarily.
+        //
+        // setState('AUTOSTEERED') is terminal so it bypasses the
+        // 800ms throttle and flushes synchronously through
+        // applyChain — so it serializes after any in-flight
+        // QUEUED apply and lands as the final visible reaction.
+        await reactor.setState('AUTOSTEERED');
         markReplied();
         return;
       }
@@ -2454,8 +2546,9 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // Only fires when pm.resetSession is available (SDK pm
       // path); CLI pm doesn't have the method.
       const cls = classifyError(result.error);
-      if (cls.autoRecover === 'reset_session' && typeof pm.resetSession === 'function') {
-        pm.resetSession(sessionKey, { reason: cls.kind })
+      const recoverTarget = pm.pickFor(sessionKey);
+      if (cls.autoRecover === 'reset_session' && typeof recoverTarget.resetSession === 'function') {
+        recoverTarget.resetSession(sessionKey, { reason: cls.kind })
           .catch((err) => console.error(`[${label}] auto-reset failed: ${err.message}`));
         logEvent('auto-recover', {
           chat_id: chatId, kind: cls.kind, action: 'reset_session',
@@ -2477,23 +2570,42 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // every answered message is chat noise (plus triggers reaction
       // notifications for other group members).
       reactor.clear().catch(() => {});
+      // 0.8.0-rc.14: also clear ✍ reactions on every follow-up
+      // message that was autosteered into THIS turn — they live in
+      // separate handleMessage scopes whose reactors are already GC'd.
+      clearAutosteeredReactions(sessionKey).catch(() => {});
+      // rc.14: tool-less-turn drain. PostToolBatch hook fires only
+      // on tool boundaries; if this turn produced ZERO tools, the
+      // hook never fired and the autosteer buffer still has the
+      // user's follow-ups. Dispatch them as a synthetic next turn
+      // so the bot at least addresses them (better than losing).
+      drainStaleAutosteerBuffer(sessionKey, chatId, threadId).catch(() => {});
 
       // 0.8.0 Phase 2 step 4: 85%-context-full live hint. After a
       // successful turn, peek at SDK's getContextUsage(); if past
       // 85%, post a quiet hint so the user knows /new will help.
       // SDK pm only — CLI pm has no equivalent (no Query object,
-      // no getContextUsage). Per-bot opt-out via
-      // config.bot.contextHint = false.
-      if (USE_SDK && config.bot?.contextHint !== false) {
+      // no getContextUsage). OPT-IN per-chat or per-bot
+      // (rc.12+) — most chats don't want the noise. Per-chat takes
+      // precedence over per-bot so admins (Ivan DM) can opt in
+      // without forcing it on every other chat.
+      const chatCtxHint = chatConfig.contextHint != null
+        ? chatConfig.contextHint
+        : config.bot?.contextHint;
+      if (pm.isSdkFor(sessionKey) && chatCtxHint === true) {
         const entry = pm.get(sessionKey);
         const q = entry?.query;
         if (q && typeof q.getContextUsage === 'function') {
           q.getContextUsage().then((usage) => {
+            // SDK returns percentage in 0-100 scale, not 0-1.
+            // Pre-rc.4 we treated it as a 0-1 ratio and multiplied
+            // by 100, which displayed "7700% full" for a 77%-used
+            // context (and fired below the intended 85% threshold).
             const pct = usage?.percentage ?? 0;
-            if (pct < 0.85) return;
+            if (pct < 85) return;
             return tg(bot, 'sendMessage', {
               chat_id: chatId,
-              text: `📚 Context window ${(pct * 100).toFixed(0)}% full. Send /new to start fresh — older messages will start dropping soon.`,
+              text: `📚 Context window ${pct.toFixed(0)}% full. Send /new to start fresh — older messages will start dropping soon.`,
               ...(threadId ? { message_thread_id: threadId } : {}),
             }, { source: 'context-full-hint', botName: BOT_NAME });
           }).catch((err) => {
@@ -2512,6 +2624,31 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     // those still markReplied silently.
     if (result.text === 'NO_REPLY') { markReplied(); return; }
     if (!result.text) {
+      // 0.8.0-rc.7: tool-only completion is NOT an error. Under SDK
+      // pm, a turn that ends after running tools (no closing text
+      // block) leaves result.text empty even though the bot DID
+      // respond — via tool side effects the user already saw. Don't
+      // post a "No response generated" apology in that case; it's
+      // confusing and it spams the chat. Just clear the reactor
+      // (otherwise 👀 stays stuck — reactor.stop() doesn't remove
+      // the emoji visually) and silently mark replied.
+      const toolOnlyTurn = (result.metrics?.numToolUses ?? 0) > 0
+        && (result.metrics?.numAssistantMessages ?? 0) > 0;
+      if (toolOnlyTurn) {
+        await reactor.clear().catch(() => {});
+        clearAutosteeredReactions(sessionKey).catch(() => {});
+        // Tool-only turns DID fire PostToolBatch — buffer was drained
+        // — but autosteers received AFTER the last tool-result still
+        // wouldn't be merged. Defensive drain here too.
+        drainStaleAutosteerBuffer(sessionKey, chatId, threadId).catch(() => {});
+        logEvent('tool-only-completion', {
+          chat_id: chatId, msg_id: msg.message_id, bot: BOT_NAME,
+          num_tool_uses: result.metrics?.numToolUses,
+          num_assistant_messages: result.metrics?.numAssistantMessages,
+        });
+        markReplied();
+        return;
+      }
       // 0.7.1: if the fallback send itself fails, throw rather than
       // silently markReplied — the user gets nothing AND the inbound
       // is marked replied so boot replay won't redispatch. Same
@@ -2537,6 +2674,12 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       logEvent('telegram-empty-response-fallback', {
         chat_id: chatId, msg_id: msg.message_id, bot: BOT_NAME,
       });
+      // 0.8.0-rc.7: clear the THINKING/QUEUED emoji on the user's
+      // message so 👀 doesn't stay stuck after the apology lands.
+      // reactor.stop() (in the finally block) only kills timers; it
+      // does NOT remove the visible emoji. Without this clear, the
+      // user sees 👀 next to their message indefinitely.
+      await reactor.clear().catch(() => {});
       markReplied();
       return;
     }
@@ -2661,7 +2804,16 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     const abortedByUser = isSessionRecentlyAborted(sessionKey);
     if (abortedByUser) {
       await streamer.finalize('').catch(() => {});
-      // Leave reaction as-is — no 🤯 / 😨; user asked for stop.
+      // 0.8.0-rc.13: clear the in-flight emoji on abort so the user
+      // sees a clean message after their /stop ack — pre-rc.13 the
+      // last 👀 / 🤔 / ✍ stayed stuck on the message indefinitely
+      // because reactor.stop() (in finally) only kills timers, not
+      // the visible reaction. We DON'T set 🤯/😨 (those are for
+      // unexpected errors); the user just wants their stop honored.
+      await reactor.clear().catch(() => {});
+      // rc.14: clear ✍ on autosteered followups too (per-msg
+      // reactors are already GC'd in their own handleMessage scopes).
+      await clearAutosteeredReactions(sessionKey).catch(() => {});
     } else {
       await streamer.finalize('', { errorSuffix: 'stream interrupted' }).catch(() => {});
       if (/wall-clock ceiling|idle with no Claude activity/i.test(err?.message || '')) {
@@ -2716,7 +2868,7 @@ function createBot(token) {
   // Cached once @botUsername is known — was recompiling per inbound msg.
   let mentionRe = null;
   // Hoisted admin-command matcher; was re-allocated per message.
-  const ADMIN_CMD_RE = /^\/(model|effort|config|pair-code|pairings|unpair|new|reset|context|steer)(\s|$)/;
+  const ADMIN_CMD_RE = /^\/(model|effort|config|pair-code|pairings|unpair|new|reset|context)(\s|$)/;
   const PAIR_CLAIM_RE = /^\/pair\s+\S+/;
 
   // The filter in main() guarantees config.chats only contains chats owned
@@ -2860,16 +3012,25 @@ function createBot(token) {
       // sessionKey is the chat itself, so killing one session is
       // the same as killing the chat — behavior unchanged for the
       // common case.
-      if (USE_SDK && typeof pm.interrupt === 'function') {
-        await pm.interrupt(sessionKey).catch((err) =>
+      const stopTarget = pm.pickFor(sessionKey);
+      if (typeof stopTarget.interrupt === 'function') {
+        await stopTarget.interrupt(sessionKey).catch((err) =>
           console.error(`[${BOT_NAME}] interrupt failed: ${err.message}`));
-        if (typeof pm.drainQueue === 'function') {
-          pm.drainQueue(sessionKey, 'INTERRUPTED');
+        if (typeof stopTarget.drainQueue === 'function') {
+          stopTarget.drainQueue(sessionKey, 'INTERRUPTED');
         }
       } else {
-        await pm.kill(sessionKey).catch((err) =>
+        await stopTarget.kill(sessionKey).catch((err) =>
           console.error(`[${BOT_NAME}] abort kill failed: ${err.message}`));
       }
+      // 0.8.0-rc.13: drop any buffered autosteer follow-ups for this
+      // session — otherwise they'd be injected into the NEXT turn
+      // (stale steer leak across abort boundary, which is what the
+      // user just asked us not to do).
+      autosteerBuffer.clear(sessionKey);
+      // rc.14: also clear ✍ reactions on already-autosteered
+      // messages from this aborted turn — they're now dead context.
+      clearAutosteeredReactions(sessionKey).catch(() => {});
       logEvent('abort-requested', {
         chat_id: chatId, user_id: msg.from?.id || null,
         had_active: hadActive,
@@ -3308,17 +3469,32 @@ async function main() {
   });
 
   const cap = config.maxWarmProcesses || DEFAULT_MAX_WARM_PROCS;
-  // 0.8.0 Phase 3: pick pm implementation via env flag. Default
-  // (POLYGRAM_USE_SDK unset) keeps the CLI-based pm — same as 0.7.x.
-  // Set POLYGRAM_USE_SDK=1 to switch to the SDK-backed pm.
-  // Phase 5 soak: enable on umi-assistant first, watch for
-  // regressions, then enable on shumabit.
-  const PMClass = USE_SDK ? ProcessManagerSdk : ProcessManager;
-  const spawnFn = USE_SDK ? buildSdkOptions : spawnClaude;
-  console.log(`[polygram] using ${USE_SDK ? 'SDK' : 'CLI'} ProcessManager`);
-  pm = new PMClass({
+
+  // 0.8.0-rc.6: per-chat pm selection. Three modes:
+  //   1. POLYGRAM_USE_SDK=1 with no POLYGRAM_SDK_CHATS list  → all chats SDK
+  //   2. POLYGRAM_SDK_CHATS=id1,id2,...                       → those chats
+  //      use SDK; everyone else uses CLI (both pms live in the daemon)
+  //   3. neither set                                          → all chats CLI
+  // The per-chat mode lets us soak SDK pm against real traffic in one
+  // chat (Ivan's DM) while keeping partner-facing chats on the
+  // battle-tested CLI path. When both pms run, killChat /shutdown
+  // broadcast to both; everything else routes per-sessionKey via
+  // pickPmFor() based on the chat's set membership.
+  // rc.17: router policy + proxy live in lib/pm-router.js for
+  // testability. Policy parses env config and produces
+  // pickPmKindFor; createPmRouter wraps the cli/sdk pms with the
+  // routed surface.
+  const { sdkActive, sdkAllChats, sdkSomeChats, sdkChatIdSet, pickPmKindFor } = makeRouterPolicy({
+    useSdkAll: USE_SDK,
+    sdkChats: String(process.env.POLYGRAM_SDK_CHATS || '').split(','),
+    getChatIdFromKey,
+  });
+
+  // Shared callbacks: identical instance passed to both pms so a
+  // chat's lifecycle events look the same regardless of which pm
+  // is handling it.
+  const pmOpts = {
     cap,
-    spawnFn,
     db,
     logger: console,
     onInit: (sessionKey, event, entry) => {
@@ -3344,6 +3520,14 @@ async function main() {
       const head = entry.pendingQueue?.[0];
       const s = head?.context?.streamer;
       if (s) s.onChunk(partial).catch(() => {});
+      // 0.8.0-rc.16: heartbeat the reactor so long text generation
+      // doesn't trip the 10s STALL → 🥱 / 30s TIMEOUT → 😨 promotion.
+      // Pre-rc.16 the reactor only got setState calls at turn start
+      // (THINKING) and per-tool (CODING/TOOL/...); pure text turns
+      // hit STALL within 10s of streaming. heartbeat() re-arms the
+      // stall timers without changing the visible emoji.
+      const r = head?.context?.reactor;
+      if (r && typeof r.heartbeat === 'function') r.heartbeat();
     },
     onToolUse: (sessionKey, toolName, entry) => {
       const head = entry.pendingQueue?.[0];
@@ -3352,14 +3536,15 @@ async function main() {
       // 0.7.0 (Phase J): opt-in subagent announce. When Claude uses
       // the Task tool to spawn a subagent, post a brief informational
       // message to the chat so the user knows a heavier turn is in
-      // progress. Off by default (per-bot or per-chat
-      // `announceSubagents: true` opts in). Per-chat debounce 30s
-      // prevents announce-storms in tool-heavy turns.
+      // progress. ON by default (rc.9+) — set per-chat
+      // `announceSubagents: false` (or per-bot) to silence.
+      // Per-chat debounce 30s prevents announce-storms in tool-heavy
+      // turns.
       const chatCfg = config.chats[entry.chatId] || {};
-      const optIn = chatCfg.announceSubagents != null
-        ? chatCfg.announceSubagents
-        : config.bot?.announceSubagents;
-      if (toolName === 'Task' && optIn === true) {
+      const optOut = chatCfg.announceSubagents != null
+        ? chatCfg.announceSubagents === false
+        : config.bot?.announceSubagents === false;
+      if (toolName === 'Task' && !optOut) {
         if (shouldAnnounce(entry.chatId)) {
           announce({
             send: (b, method, params, m) => tg(b, method, params, m),
@@ -3385,24 +3570,26 @@ async function main() {
     // 0.8.0 Phase 2 step 5: SDK auto-compaction observability. Fires
     // when SDK emits SDKCompactBoundaryMessage (between turns or
     // mid-turn — see Phase 0 gate 8.5). Surfaces a quiet system
-    // status note to the chat so the user knows context was
-    // reorganised. Off by default per-bot (announceCompact !== true).
+    // status note to the chat so the user knows the bot is busy
+    // reorganising context (compaction can take seconds, during
+    // which the bot looks unresponsive). ON by default (rc.12+) —
+    // set per-chat or per-bot `announceCompact: false` to silence.
     // Only fires under SDK pm — the CLI pm has no equivalent event.
+    //
+    // Wording is intentionally non-technical — the user doesn't
+    // care about "compaction" or "tokens"; they just want to know
+    // the bot didn't hang.
     onCompactBoundary: async (sessionKey, msg, entry) => {
       const chatCfg = config.chats[entry.chatId] || {};
-      const optIn = chatCfg.announceCompact != null
-        ? chatCfg.announceCompact
-        : config.bot?.announceCompact;
-      if (optIn !== true) return;
-      const meta = msg.compact_metadata || {};
-      const summary = meta.pre_tokens && meta.post_tokens
-        ? ` (${(meta.pre_tokens / 1000).toFixed(0)}K → ${(meta.post_tokens / 1000).toFixed(0)}K tokens)`
-        : '';
+      const optOut = chatCfg.announceCompact != null
+        ? chatCfg.announceCompact === false
+        : config.bot?.announceCompact === false;
+      if (optOut) return;
       const threadId = entry.threadId || undefined;
       try {
         await tg(bot, 'sendMessage', {
           chat_id: entry.chatId,
-          text: `🗜️ Memory compacted${summary} — earlier context summarised.`,
+          text: '💭 Catching up on history, one moment…',
           ...(threadId ? { message_thread_id: threadId } : {}),
         }, { source: 'compact-boundary', botName: BOT_NAME });
       } catch (err) {
@@ -3433,7 +3620,28 @@ async function main() {
         ...(threadId && { message_thread_id: threadId }),
       }, { source: 'respawn-confirm', botName: BOT_NAME }).catch(() => {});
     },
-  });
+  };
+
+  // Instantiate the actual pm(s). When sdkActive is false we still
+  // build a CLI pm; SDK pm is null. When sdkActive is true we always
+  // build BOTH so chats outside the SDK list still get the CLI path.
+  const cliPm = new ProcessManager({ ...pmOpts, spawnFn: spawnClaude });
+  const sdkPm = sdkActive
+    ? new ProcessManagerSdk({ ...pmOpts, spawnFn: buildSdkOptions })
+    : null;
+
+  // Routing pm: same surface as a single pm, but per-method routing
+  // through pickPmKindFor(sessionKey). Per-method semantics
+  // documented in lib/pm-router.js.
+  pm = createPmRouter({ cliPm, sdkPm, pickPmKindFor });
+
+  if (sdkAllChats) {
+    console.log('[polygram] using SDK ProcessManager (all chats)');
+  } else if (sdkSomeChats) {
+    console.log(`[polygram] router active: SDK pm for chats {${Array.from(sdkChatIdSet).join(',')}}, CLI pm for everyone else`);
+  } else {
+    console.log('[polygram] using CLI ProcessManager');
+  }
 
   console.log(`polygram (LRU cap=${cap}, SQLite source of truth)`);
   console.log(`Chats: ${Object.entries(config.chats).map(([id, c]) => `${c.name} (${c.model}/${c.effort})`).join(', ')}`);