polygram 0.8.0-rc.1 → 0.8.0-rc.11

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.8.0-rc.1",
+  "version": "0.8.0-rc.11",
   "description": "Telegram integration for Claude Code that preserves the OpenClaw per-chat session model. Migration target for OpenClaw users. Multi-bot, multi-chat, per-topic isolation; SQLite transcripts; inline-keyboard approvals. Bundles /polygram:status|logs|pair-code|approvals admin commands and a history skill.",
   "keywords": [
     "telegram",

package/lib/attachments.js

@@ -1,10 +1,13 @@
 /**
- * Attachment filter — caps count + total size + MIME allowlist.
+ * Attachment filter — caps total size + per-file size + MIME allowlist.
  * Rejected items return a human-readable reason that we surface to the
  * user and log to the events table.
+ *
+ * No count cap: per-file (10 MB) and total-size (20 MB) bound resource
+ * usage already; an additional count limit just produces "skipped: max
+ * count" surprises on Telegram albums (up to 10 photos in one send).
  */
 
-const MAX_COUNT = 5;
 const MAX_FILE_BYTES = 10 * 1024 * 1024;
 const MAX_TOTAL_BYTES = 20 * 1024 * 1024;
 const MIME_ALLOW = [
@@ -16,7 +19,6 @@ const MIME_ALLOW = [
 ];
 
 function filterAttachments(attachments, opts = {}) {
-  const maxCount = opts.maxCount ?? MAX_COUNT;
   const maxFileBytes = opts.maxFileBytes ?? MAX_FILE_BYTES;
   const maxTotalBytes = opts.maxTotalBytes ?? MAX_TOTAL_BYTES;
   const mimeAllow = opts.mimeAllow ?? MIME_ALLOW;
@@ -26,10 +28,6 @@ function filterAttachments(attachments, opts = {}) {
   let totalBytes = 0;
 
   for (const a of attachments || []) {
-    if (accepted.length >= maxCount) {
-      rejected.push({ att: a, reason: `exceeds max count (${maxCount})` });
-      continue;
-    }
     const mime = a.mime_type || '';
     if (!mimeAllow.some((re) => re.test(mime))) {
       rejected.push({ att: a, reason: `mime not allowed (${mime || 'unknown'})` });
@@ -38,7 +36,7 @@ function filterAttachments(attachments, opts = {}) {
     const reported = a.size || 0;
     // Telegram sometimes reports file_size=0 or omits it. Pre-0.6.14
     // those bypassed the cumulative cap entirely (totalBytes + 0 always
-    // ≤ maxTotalBytes), so 5 size-0 attachments could blow through the
+    // ≤ maxTotalBytes), so unsized attachments could blow through the
     // 20 MB total cap. Treat unknown sizes as worst-case (= per-file
     // cap) for budgeting; the per-file cap is still enforced live by
     // the streaming download in polygram.js.
@@ -57,4 +55,4 @@ function filterAttachments(attachments, opts = {}) {
   return { accepted, rejected, totalBytes };
 }
 
-module.exports = { filterAttachments, MAX_COUNT, MAX_FILE_BYTES, MAX_TOTAL_BYTES, MIME_ALLOW };
+module.exports = { filterAttachments, MAX_FILE_BYTES, MAX_TOTAL_BYTES, MIME_ALLOW };

package/lib/autosteer-buffer.js

@@ -0,0 +1,80 @@
+/**
+ * Per-session buffer for mid-turn user follow-ups (autosteer + /steer).
+ *
+ * 0.8.0-rc.9: lands the steer mechanism that survived production. Earlier
+ * rcs pushed `priority:'now'` SDKUserMessages onto the SDK input
+ * iterable mid-tool-use; the CLI binary's `m87` gate rejected them with
+ * `result.subtype = error_during_execution` because the transcript shape
+ * (assistant ending with tool_use → next user message NOT being a
+ * tool_result) is malformed per Anthropic's API contract.
+ *
+ * The mechanism we landed on: append the follow-up to a per-session
+ * buffer; on every PostToolBatch hook fire, drain the buffer into the
+ * hook's `additionalContext` field wrapped in a `<channel
+ * source="user-followup">…</channel>` tag — the same framing Channels
+ * MCP uses, which Claude is trained to trust as legitimate
+ * out-of-band user context (vs. prompt-injection inside tool output,
+ * which the model defends against by refusing to follow).
+ *
+ * Spike result (post-tool-batch-spike-v2.mjs): with this framing, the
+ * marker "spike-marker-9d3e" injected via additionalContext was
+ * incorporated verbatim into the assistant's final answer. With the
+ * earlier `<user_message_during_turn>` framing, the model recognised
+ * it as prompt-injection-shaped and refused.
+ *
+ * Why a buffer module instead of inlining: per-sessionKey state lives
+ * outside the pm and outside polygram.js's handleMessage so both
+ * autosteer (handleMessage line ~2418) and /steer (line ~1975) can
+ * share it. pm-sdk binds a hook callback per spawn that closes over
+ * its sessionKey and drains this buffer.
+ *
+ * Edge: tool-less turns (Claude answers without firing a tool). The
+ * hook never fires, so a queued message would be lost. pm-sdk's
+ * onResult handler MUST drain the buffer at turn-end and push the
+ * remainder via `inputController.push(..., { shouldQuery: false })`
+ * for next-turn injection — no m87 risk because the previous turn
+ * ended cleanly with text/end_turn before the push lands.
+ */
+
+'use strict';
+
+function createAutosteerBuffer() {
+  // sessionKey → array of strings (in order of arrival)
+  const queues = new Map();
+
+  function append(sessionKey, text) {
+    if (!sessionKey || typeof text !== 'string' || text.length === 0) return false;
+    let q = queues.get(sessionKey);
+    if (!q) { q = []; queues.set(sessionKey, q); }
+    q.push(text);
+    return true;
+  }
+
+  function drain(sessionKey) {
+    const q = queues.get(sessionKey);
+    if (!q || q.length === 0) return [];
+    queues.delete(sessionKey);
+    return q;
+  }
+
+  function size(sessionKey) {
+    return queues.get(sessionKey)?.length ?? 0;
+  }
+
+  function clear(sessionKey) {
+    queues.delete(sessionKey);
+  }
+
+  // Format the drained messages as the additionalContext payload that
+  // Claude trusts. Multiple messages are joined with a blank line so
+  // the model sees them as a sequence within a single channel tag.
+  function formatForHook(messages) {
+    if (!messages || messages.length === 0) return null;
+    const body = messages.join('\n\n');
+    return `<channel source="user-followup">\n${body}\n</channel>`;
+  }
+
+  return { append, drain, size, clear, formatForHook };
+}
+
+module.exports = { createAutosteerBuffer };

package/lib/error-classify.js

@@ -97,7 +97,10 @@ const USER_MESSAGES = {
   missingToolInput: '⚠️ Session history looks corrupted. Try /new.',
   timeout:          '⏳ I went quiet too long without finishing. Try resending or simplifying.',
   format:           '⚠️ Invalid request format. Try rephrasing or /new.',
-  transient5xx:     '☁️ Anthropic is temporarily unavailable. Retrying once…',
+  // Used both for in-flight retry attempts AND for the post-retry-failed
+  // bubble-up message. Avoid promising "retrying once" since by the
+  // time the user reads it pm has already retried and given up.
+  transient5xx:     '☁️ Server hiccup — please try again in a moment.',
 };
 
 // Auto-recovery actions for kinds where the session is irrecoverable
@@ -183,15 +186,16 @@ function classify(err) {
   }
 
   // SDKAssistantMessage.error is a short string code from a fixed
-  // union — match those directly, not via regex.
+  // union — match those directly, not via regex. Result subtypes
+  // are checked LATER (after pattern matching) so a more-specific
+  // pattern in the message text (e.g. 'HTTP 401' inside an
+  // error_during_execution subtype) wins over the generic subtype
+  // mapping that defaults the entire error_during_execution class
+  // to transient.
   if (typeof err === 'string') {
     const sdkMessageError = matchSdkMessageError(err);
     if (sdkMessageError) return sdkMessageError;
   }
-  if (err?.subtype && typeof err.subtype === 'string') {
-    const sdkResultSubtype = matchSdkResultSubtype(err.subtype);
-    if (sdkResultSubtype) return sdkResultSubtype;
-  }
 
   const msg = extractMessage(err);
   for (const [kind, re] of Object.entries(PATTERNS)) {
@@ -205,6 +209,20 @@ function classify(err) {
     }
   }
 
+  // After pattern matching: try SDK result subtypes. A bare string
+  // like 'error_during_execution' (no message context) lands here
+  // and gets the friendly transient5xx kind. Object inputs with a
+  // subtype field also land here when their message text didn't
+  // match a more specific pattern.
+  if (typeof err === 'string') {
+    const sdkResultSubtype = matchSdkResultSubtype(err);
+    if (sdkResultSubtype) return sdkResultSubtype;
+  }
+  if (err?.subtype && typeof err.subtype === 'string') {
+    const sdkResultSubtype = matchSdkResultSubtype(err.subtype);
+    if (sdkResultSubtype) return sdkResultSubtype;
+  }
+
   // Fall-through: surface a snippet of the raw error so users at
   // least know SOMETHING happened. Same shape as before, just
   // routed through the classifier so callers get a uniform return.
@@ -252,8 +270,15 @@ function matchSdkMessageError(s) {
 
 // SDKResultMessage.subtype values (sdk.d.ts:3121). Most are
 // terminal-error indicators that don't have a clean pattern equivalent.
+//
+// `error_during_execution` is the SDK's catch-all for "something went
+// wrong mid-turn" — could be a transient stream/network blip OR a
+// systemic model issue. We treat it as transient (1 retry is cheap;
+// if it's systemic the second attempt fails fast). Pre-rc.5 this was
+// mapped to 'unknown' which fell through to the default "Hit a snag:
+// error_during_execution" template — leaking the SDK enum to users.
 const SDK_RESULT_SUBTYPE_MAP = {
-  error_during_execution:           'unknown',
+  error_during_execution:           'transient5xx',
   error_max_turns:                  'format',
   error_max_budget_usd:             'billing',
   error_max_structured_output_retries: 'format',
@@ -265,8 +290,12 @@ function matchSdkResultSubtype(s) {
   return {
     kind,
     userMessage: USER_MESSAGES[kind] ?? null,
-    isTransient: false, // result subtypes don't auto-retry; the
-                        // turn already burned its budget.
+    // Derive transience from the kind so error_during_execution →
+    // transient5xx → isTransient=true, matching the pattern-match
+    // branch's behaviour. pm guards retry with firstAssistantSeen=
+    // false, which prevents budget waste when the turn already had
+    // billable assistant output.
+    isTransient: kind === 'transient5xx' || kind === 'rateLimit',
     autoRecover: AUTO_RECOVER[kind] ?? null,
   };
 }

package/lib/process-manager-sdk.js

@@ -470,6 +470,7 @@ class ProcessManagerSdk {
             entry.inputController.push({
               type: 'user',
               message: { role: 'user', content: head.prompt },
+              parent_tool_use_id: null,
             });
           } catch (err) {
             entry.pendingQueue.shift();
@@ -655,6 +656,7 @@ class ProcessManagerSdk {
         entry.inputController.push({
           type: 'user',
           message: { role: 'user', content: prompt },
+          parent_tool_use_id: null,
         });
       } catch (err) {
         const idx = entry.pendingQueue.indexOf(pending);
@@ -754,13 +756,30 @@ class ProcessManagerSdk {
    * Returns true if push succeeded; false if session not found or
    * input controller closed.
    */
-  steer(sessionKey, text, { shouldQuery = true } = {}) {
+  steer(sessionKey, text, { shouldQuery = false } = {}) {
     const entry = this.procs.get(sessionKey);
     if (!entry || entry.closed) return false;
     try {
+      // 0.8.0-rc.7 (per v4 plan §0 row 9 + Phase 2 step 1's original
+      // shape): push with `shouldQuery: false` so the SDK appends to
+      // the transcript without trying to terminate the in-flight turn.
+      // The previous default `shouldQuery: true` triggered the CLI
+      // binary's `m87` gate (transcript well-formedness check) which
+      // emitted `result.subtype = error_during_execution` whenever a
+      // plain-text user message arrived while the assistant was mid-
+      // tool-use. With shouldQuery=false the message merges into the
+      // next natural user turn — the in-flight tools complete first,
+      // then the assistant sees the steered context.
+      //
+      // parent_tool_use_id is required by SDKUserMessage type
+      // (sdk.d.ts:3479-3498). The SDK runtime checks `!== null` in
+      // multiple places; omitting it falls through to wrong handling
+      // branches. The SDK's own `mz.send()` and `pz` replay set it
+      // to null explicitly.
       entry.inputController.push({
         type: 'user',
         message: { role: 'user', content: text },
+        parent_tool_use_id: null,
         priority: 'now',
         shouldQuery,
       });

package/lib/status-reactions.js

@@ -29,19 +29,30 @@
 // are progressively safer. All endings in this list are in Telegram's
 // default available reactions as of 2026-04.
 const STATES = {
-  QUEUED:   { label: 'queued',   chain: ['👀', '🤔']       },
-  THINKING: { label: 'thinking', chain: ['🤔']             },
-  CODING:   { label: 'coding',   chain: ['👨‍💻', '✍', '🤔'] },
-  WEB:      { label: 'web',      chain: ['⚡', '🔥', '🤔']  },
-  TOOL:     { label: 'tool',     chain: ['🔥', '🤔']       },
-  WRITING:  { label: 'writing',  chain: ['✍', '🤔']        },
-  DONE:     { label: 'done',     chain: ['👍']             },
-  ERROR:    { label: 'error',    chain: ['🤯', '🤔']       },
-  STALL:    { label: 'stall',    chain: ['🥱', '🤔']       },
-  TIMEOUT:  { label: 'timeout',  chain: ['😨', '🤯']       },
+  QUEUED:      { label: 'queued',      chain: ['👀', '🤔']       },
+  THINKING:    { label: 'thinking',    chain: ['🤔']             },
+  CODING:      { label: 'coding',      chain: ['👨‍💻', '✍', '🤔'] },
+  WEB:         { label: 'web',         chain: ['⚡', '🔥', '🤔']  },
+  TOOL:        { label: 'tool',        chain: ['🔥', '🤔']       },
+  WRITING:     { label: 'writing',     chain: ['✍', '🤔']        },
+  // 0.8.0-rc.11: terminal "your follow-up was incorporated into the
+  // in-flight turn" state. Used by polygram's autosteer block when a
+  // mid-turn user message is buffered for the next PostToolBatch
+  // injection.
+  AUTOSTEERED: { label: 'autosteered', chain: ['✍', '👀']        },
+  DONE:        { label: 'done',        chain: ['👍']             },
+  ERROR:       { label: 'error',       chain: ['🤯', '🤔']       },
+  STALL:       { label: 'stall',       chain: ['🥱', '🤔']       },
+  TIMEOUT:     { label: 'timeout',     chain: ['😨', '🤯']       },
 };
 
-const TERMINAL_STATES = new Set(['DONE', 'ERROR', 'TIMEOUT']);
+// Terminal states bypass throttle, disarm stall promotion, and the
+// reactor stays at this emoji until explicitly cleared. AUTOSTEERED
+// is included so setState('AUTOSTEERED') flushes immediately
+// (matters because the autosteer code path returns from
+// handleMessage right after — we don't want the apply to be
+// scheduled-and-cancelled by reactor.stop in the outer finally).
+const TERMINAL_STATES = new Set(['DONE', 'ERROR', 'TIMEOUT', 'AUTOSTEERED']);
 const DEFAULT_THROTTLE_MS = 800;
 // 0.7.4 (item A): after this long with no setState() call (Claude is
 // silently chugging on a long tool / model latency), auto-flip to STALL
@@ -132,24 +143,40 @@ function createReactionManager({
   let stallTimer = null;
   let freezeTimer = null;
   let stopped = false;
+  // 0.8.0-rc.11: serialize Telegram setMessageReaction calls. Without
+  // this, multiple flush()es race at the network layer because each
+  // calls `await apply(emoji)` from a separate stack — Telegram
+  // processes them in arbitrary order and the FINAL visible state is
+  // whichever apply landed last. Symptom: 👀 stuck on autosteered
+  // messages when the QUEUED apply landed AFTER our explicit ✍ apply.
+  // Chaining all applies through `applyChain` guarantees they're sent
+  // to Telegram in setState() invocation order.
+  let applyChain = Promise.resolve();
   // States the auto-stall path may transition to. Once we've already
   // shown STALL or TIMEOUT we don't downgrade or rearm — only an
   // explicit setState() call (Claude resumed) can move us forward.
   const STALL_PROMOTABLE = new Set(['THINKING', 'CODING', 'WEB', 'TOOL', 'WRITING']);
 
   const flush = async (stateName) => {
-    if (stopped) return;
+    if (stopped && !TERMINAL_STATES.has(stateName)) return;
     const spec = STATES[stateName];
     if (!spec) return;
     const emoji = resolveEmoji(spec.chain, availableEmojis);
     if (emoji === currentEmoji) return;
     currentEmoji = emoji;
     lastFlushTs = Date.now();
-    try {
-      await apply(emoji);
-    } catch (err) {
-      logError(`reaction apply failed (${stateName} → ${emoji}): ${err?.message || err}`);
-    }
+    // Chain through applyChain so concurrent flushes are sent to
+    // Telegram serially in invocation order. Returning the chain
+    // promise lets callers await this specific flush completing.
+    const myApply = applyChain.then(async () => {
+      try {
+        await apply(emoji);
+      } catch (err) {
+        logError(`reaction apply failed (${stateName} → ${emoji}): ${err?.message || err}`);
+      }
+    });
+    applyChain = myApply;
+    return myApply;
   };
 
   const clearStallTimers = () => {
@@ -217,8 +244,16 @@ function createReactionManager({
     clearStallTimers();
     if (currentEmoji == null) return;
     currentEmoji = null;
-    try { await apply(null); }
-    catch (err) { logError(`reaction clear failed: ${err?.message || err}`); }
+    // Same applyChain serialization as flush — clear() is a state
+    // transition, just to "no emoji". Without chaining, a clear()
+    // racing with a pending apply (e.g. THINKING flush in flight)
+    // could land BEFORE that apply, leaving the emoji visible.
+    const myApply = applyChain.then(async () => {
+      try { await apply(null); }
+      catch (err) { logError(`reaction clear failed: ${err?.message || err}`); }
+    });
+    applyChain = myApply;
+    return myApply;
   };
 
   const stop = () => {

package/package.json

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

@@ -31,6 +31,7 @@ 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 } = require('./lib/autosteer-buffer');
 const agentLoader = require('./lib/agent-loader');
 const USE_SDK = process.env.POLYGRAM_USE_SDK === '1';
 const { createSender } = require('./lib/telegram');
@@ -698,6 +699,14 @@ 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();
+
 function spawnClaude(sessionKey, ctx) {
   const { chatConfig, existingSessionId, label, chatId } = ctx;
   // 0.7.3: Claude Code's Chrome-extension integration (browser
@@ -817,6 +826,40 @@ function buildSdkOptions(sessionKey, ctx) {
   const useCanUseTool = apprCfg && apprCfg.adminChatId
     && Array.isArray(apprCfg.gatedTools) && apprCfg.gatedTools.length > 0;
 
+  // 0.8.0-rc.9: PostToolBatch hook drains the autosteer buffer for
+  // this session and injects queued user follow-ups as
+  // `additionalContext` on each tool boundary. Framing matters:
+  // wrapping in `<channel source="user-followup">…</channel>` is
+  // what Claude is trained to trust as legitimate out-of-band user
+  // context (verified live via post-tool-batch-spike-v2.mjs); the
+  // earlier `<user_message_during_turn>` framing tripped the
+  // model's prompt-injection defense and got refused.
+  const postToolBatchHook = async () => {
+    try {
+      const drained = autosteerBuffer.drain(sessionKey);
+      if (drained.length === 0) return { continue: true };
+      const additionalContext = autosteerBuffer.formatForHook(drained);
+      logEvent('autosteer-hook-drained', {
+        chat_id: ctx?.chatId ?? null,
+        session_key: sessionKey,
+        message_count: drained.length,
+      });
+      return {
+        continue: true,
+        hookSpecificOutput: {
+          hookEventName: 'PostToolBatch',
+          additionalContext,
+        },
+      };
+    } catch (err) {
+      console.error(`[${sessionKey}] PostToolBatch hook error: ${err.message}`);
+      // Never throw out of a hook — the SDK may treat it as a hard
+      // fail (`stop_hook_prevented` result subtype). Drop the
+      // queued messages on the floor; the user can re-send.
+      return { continue: true };
+    }
+  };
+
   const baseOpts = {
     model: chatConfig.model || config.defaults.model,
     effort: chatConfig.effort || config.defaults.effort,
@@ -828,6 +871,9 @@ function buildSdkOptions(sessionKey, ctx) {
     permissionMode: useCanUseTool ? 'default' : 'bypassPermissions',
     allowDangerouslySkipPermissions: !useCanUseTool,
     ...(useCanUseTool && { canUseTool: makeCanUseTool(sessionKey) }),
+    hooks: {
+      PostToolBatch: [{ hooks: [postToolBatchHook] }],
+    },
     executable: 'node',
     ...(existingSessionId && { resume: existingSessionId }),
     ...(process.env.POLYGRAM_CLAUDE_BIN && {
@@ -1709,16 +1755,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 +1941,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 +1953,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 +1987,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 +2012,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 +2058,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 +2078,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 +2431,54 @@ 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}`);
-        });
         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 +2539,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',
@@ -2484,16 +2570,20 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
       // 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) {
+      if (pm.isSdkFor(sessionKey) && config.bot?.contextHint !== false) {
         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 +2602,26 @@ 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(() => {});
+        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 +2647,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;
     }
@@ -2716,7 +2832,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,14 +2976,15 @@ 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}`));
       }
       logEvent('abort-requested', {
@@ -3308,17 +3425,37 @@ 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.
+  const sdkChatIdSet = new Set(
+    String(process.env.POLYGRAM_SDK_CHATS || '')
+      .split(',').map((s) => s.trim()).filter(Boolean)
+  );
+  const sdkAllChats = USE_SDK && sdkChatIdSet.size === 0;
+  const sdkSomeChats = sdkChatIdSet.size > 0;
+  const sdkActive = sdkAllChats || sdkSomeChats;
+
+  function pickPmKindFor(sessionKey) {
+    if (sdkAllChats) return 'sdk';
+    if (!sdkSomeChats) return 'cli';
+    const chatId = String(getChatIdFromKey(sessionKey) ?? '');
+    return sdkChatIdSet.has(chatId) ? 'sdk' : 'cli';
+  }
+
+  // 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) => {
@@ -3352,14 +3489,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),
@@ -3433,7 +3571,104 @@ 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). Methods that don't take a
+  // sessionKey (killChat by chatId, shutdown) broadcast to both.
+  // For optional methods (steer / setModel / applyFlagSettings /
+  // requestRespawn / drainQueue / interrupt / resetSession) we
+  // forward when the routed pm has the method and return a
+  // sentinel otherwise — so feature-detection at the call site
+  // still works via `typeof pm.pickFor(sessionKey).X === 'function'`.
+  pm = (() => {
+    function routedPm(sessionKey) {
+      return pickPmKindFor(sessionKey) === 'sdk' && sdkPm ? sdkPm : cliPm;
+    }
+    const router = {
+      pickFor: routedPm,
+      isSdkFor(sessionKey) {
+        return pickPmKindFor(sessionKey) === 'sdk' && !!sdkPm;
+      },
+      has(sessionKey) { return routedPm(sessionKey).has(sessionKey); },
+      get(sessionKey) { return routedPm(sessionKey).get(sessionKey); },
+      getOrSpawn(sessionKey, ctx) { return routedPm(sessionKey).getOrSpawn(sessionKey, ctx); },
+      send(sessionKey, prompt, opts) { return routedPm(sessionKey).send(sessionKey, prompt, opts); },
+      kill(sessionKey) { return routedPm(sessionKey).kill(sessionKey); },
+      async killChat(chatId) {
+        const tasks = [cliPm.killChat(chatId)];
+        if (sdkPm) tasks.push(sdkPm.killChat(chatId));
+        await Promise.all(tasks);
+      },
+      async shutdown() {
+        const tasks = [cliPm.shutdown()];
+        if (sdkPm) tasks.push(sdkPm.shutdown());
+        await Promise.all(tasks);
+      },
+      // Optional methods. The router returns a function — but the
+      // function returns a sentinel if the routed pm doesn't have
+      // the method. Sites that want feature-detection should use
+      // `pm.pickFor(sessionKey)` and check `typeof X === 'function'`
+      // there instead of probing `pm.X` directly.
+      steer(sessionKey, ...args) {
+        const target = routedPm(sessionKey);
+        return typeof target.steer === 'function' ? target.steer(sessionKey, ...args) : false;
+      },
+      resetSession(sessionKey, opts) {
+        const target = routedPm(sessionKey);
+        return typeof target.resetSession === 'function'
+          ? target.resetSession(sessionKey, opts)
+          : Promise.resolve({ closed: false, drainedPendings: 0 });
+      },
+      applyFlagSettings(sessionKey, settings) {
+        const target = routedPm(sessionKey);
+        return typeof target.applyFlagSettings === 'function'
+          ? target.applyFlagSettings(sessionKey, settings)
+          : Promise.resolve(false);
+      },
+      setModel(sessionKey, model) {
+        const target = routedPm(sessionKey);
+        return typeof target.setModel === 'function'
+          ? target.setModel(sessionKey, model)
+          : Promise.resolve(false);
+      },
+      requestRespawn(sessionKey, reason) {
+        const target = routedPm(sessionKey);
+        return typeof target.requestRespawn === 'function'
+          ? target.requestRespawn(sessionKey, reason)
+          : { killed: false, queued: 0 };
+      },
+      drainQueue(sessionKey, errCode) {
+        const target = routedPm(sessionKey);
+        return typeof target.drainQueue === 'function'
+          ? target.drainQueue(sessionKey, errCode)
+          : 0;
+      },
+      interrupt(sessionKey) {
+        const target = routedPm(sessionKey);
+        return typeof target.interrupt === 'function'
+          ? target.interrupt(sessionKey)
+          : Promise.resolve();
+      },
+    };
+    return router;
+  })();
+
+  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(', ')}`);