polygram 0.8.0-rc.46 → 0.8.0-rc.48

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.46",
+  "version": "0.8.0-rc.48",
   "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/config.example.json

@@ -98,9 +98,17 @@
       "cwd": "/Users/you/admin-agent",
       "requireMention": true,
       "isolateTopics": true,
+      "_comment_topics": "rc.48: each topic entry is EITHER a string (legacy: just a label) OR an object with optional fields {name, agent, cwd, model, effort, permissionMode}. Object form lets a topic override chat-level config. Per-topic permissionMode overrides chat-level — typical use: scope one topic to permissionMode:'default' (so settings.json gates apply) while the rest of the chat stays on bypassPermissions. Object form requires isolateTopics: true (each topic gets its own SDK Query); polygram emits a startup warning otherwise.",
       "topics": {
         "100": "Customer A",
-        "200": "Customer B"
+        "200": {
+          "name": "Customer B",
+          "agent": "customer-b-helper",
+          "cwd": "/Users/you/customer-b-projects",
+          "model": "opus",
+          "effort": "high",
+          "permissionMode": "default"
+        }
       }
     },
 

package/lib/agent-loader.js

@@ -283,15 +283,27 @@ function loadAgent(agentName, { homeDir = process.env.HOME, cwd = null, logger =
 
 /**
  * Compose a chat's final SdkOptions from defaults + agent + per-chat
- * overrides. Precedence: chatConfig > agent > defaults.
+ * overrides + per-topic overrides. Precedence (highest to lowest):
+ *   topicConfig > chatConfig > agent.raw > defaults
+ *
+ * rc.48 added the per-topic layer (`topicConfig` arg). Per-topic
+ * overrides are the principal rc.48 use case — typically loosening
+ * an agent's `bypassPermissions` default to `default` for a sensitive
+ * topic (so canUseTool prompts fire there) while keeping the rest of
+ * the chat in bypass mode. Per-topic permissionMode MUST override the
+ * chat-level one for this to work.
  *
  * @param {object} chatConfig — config.chats[chatId].
  * @param {AgentBundle|null} agentBundle — null if chat has no agent.
  * @param {object} defaults — config.defaults.
+ * @param {object} [topicConfig] — per-topic overrides from
+ *   getTopicConfig(chatConfig, threadId). Empty object when there's
+ *   no active topic, no override config, or topic uses legacy string
+ *   form. Highest precedence — overrides chatConfig.
  *
  * @returns {object} SdkOptions for `query({ options: ... })`.
  */
-function composeSdkOptions(chatConfig = {}, agentBundle = null, defaults = {}) {
+function composeSdkOptions(chatConfig = {}, agentBundle = null, defaults = {}, topicConfig = {}) {
   // Start with defaults — these are the lowest-priority.
   const opts = { ...defaults };
 
@@ -302,16 +314,18 @@ function composeSdkOptions(chatConfig = {}, agentBundle = null, defaults = {}) {
     if (agentBundle.mcpServers && Object.keys(agentBundle.mcpServers).length) {
       opts.mcpServers = { ...(opts.mcpServers || {}), ...agentBundle.mcpServers };
     }
-    // Agent-level model/effort/etc — only if chatConfig doesn't
-    // override.
+    // Agent-level model/effort/etc — only if chatConfig AND
+    // topicConfig don't override.
     for (const key of ['model', 'effort', 'thinking', 'permissionMode']) {
-      if (agentBundle.raw?.[key] != null && chatConfig[key] == null) {
+      if (agentBundle.raw?.[key] != null
+          && chatConfig[key] == null
+          && topicConfig?.[key] == null) {
         opts[key] = agentBundle.raw[key];
       }
     }
   }
 
-  // Chat-level overrides (highest priority).
+  // Chat-level overrides.
   for (const [k, v] of Object.entries(chatConfig)) {
     if (v == null) continue;
     // Don't override the spread system-prompt with `agent` config
@@ -320,6 +334,18 @@ function composeSdkOptions(chatConfig = {}, agentBundle = null, defaults = {}) {
     opts[k] = v;
   }
 
+  // rc.48: per-topic overrides (highest priority). Same `agent` exclusion
+  // — `agent` here is a polygram name reference, NOT an SdkOptions
+  // field. polygram's spawn flow resolves topicConfig.agent into the
+  // correct agentBundle BEFORE calling composeSdkOptions, so by the
+  // time we get here, agentBundle already reflects the topic's agent
+  // choice and the `agent` string itself shouldn't leak into opts.
+  for (const [k, v] of Object.entries(topicConfig || {})) {
+    if (v == null) continue;
+    if (k === 'agent') continue;
+    opts[k] = v;
+  }
+
   return opts;
 }
 

package/lib/process-manager-sdk.js

@@ -193,6 +193,17 @@ class ProcessManagerSdk {
     onStreamChunk = null,
     onToolUse = null,
     onAssistantMessageStart = null,
+    // rc.47: fires when an SDK assistant message arrives with NO head
+    // pending in entry.pendingQueue — i.e. an autonomous turn (typical
+    // ScheduleWakeup case where the agent self-fires without a
+    // corresponding pm.send). Polygram wires this to a Telegram-send
+    // function that derives chat_id (always) and thread_id (when
+    // isolateTopics) from the sessionKey via getChatIdFromKey /
+    // getThreadIdFromKey, then forwards the text to the right chat/
+    // topic. Pre-rc.47 these messages were silently dropped at the
+    // `&& head` gate in _handleEvent. Subagent messages
+    // (parent_tool_use_id != null) are still filtered upstream.
+    onAutonomousAssistantMessage = null,
     onCompactBoundary = null,
     onQueueDrop = null,
     onThinking = null,
@@ -211,6 +222,7 @@ class ProcessManagerSdk {
     this.onStreamChunk = onStreamChunk;
     this.onToolUse = onToolUse;
     this.onAssistantMessageStart = onAssistantMessageStart;
+    this.onAutonomousAssistantMessage = onAutonomousAssistantMessage;
     this.onCompactBoundary = onCompactBoundary;
     this.onQueueDrop = onQueueDrop;
     this.onThinking = onThinking;
@@ -425,6 +437,23 @@ class ProcessManagerSdk {
       return;
     }
 
+    if (msg.type === 'assistant' && !head) {
+      // rc.47: autonomous assistant message — no user-initiated
+      // pm.send is in flight. Typical cause: ScheduleWakeup fired,
+      // the agent emitted a self-driven response. Pre-rc.47 these
+      // were silently dropped by the `&& head` gate. Now we route
+      // them via onAutonomousAssistantMessage so polygram can
+      // forward the text to the right Telegram chat/topic.
+      if (msg.parent_tool_use_id != null) return;
+      const text = extractAssistantText(msg);
+      if (!text) return;
+      if (this.onAutonomousAssistantMessage) {
+        try { this.onAutonomousAssistantMessage(entry.sessionKey, msg, entry); }
+        catch (err) { this.logger.error?.(`[${entry.label}] onAutonomousAssistantMessage: ${err.message}`); }
+      }
+      return;
+    }
+
     if (msg.type === 'assistant' && head) {
       // Subagent filter (Phase 1 step 7): top-level only.
       if (msg.parent_tool_use_id != null) return;

package/lib/session-key.js

@@ -16,8 +16,25 @@
  * topic's conversation can't bleed into Billing topic's memory. This
  * matches OpenClaw's model and is the right call when topics represent
  * genuinely separate projects.
+ *
+ * rc.48: per-topic config overrides. `topics[threadId]` can be either a
+ * string (legacy: just a label) or an object with optional fields:
+ *   { name, agent, cwd, model, effort, permissionMode }
+ * Object form lets a topic override chat-level config — typically used
+ * to scope a single topic to a different agent (e.g. music-curation),
+ * a different working dir, or to switch from `bypassPermissions` to
+ * `default` so canUseTool prompts fire for sensitive operations in
+ * that topic only. See getTopicConfig.
+ *
+ * Per-topic overrides only take effect when isolateTopics: true (each
+ * topic has its own SDK Query). With isolateTopics: false all topics
+ * share one Query; the Query's options are fixed at first-spawn time.
+ * polygram emits a one-time startup warning if topic overrides are
+ * configured on a non-isolating chat.
  */
 
+'use strict';
+
 function getSessionKey(chatId, threadId, chatConfig) {
   const isolate = chatConfig?.isolateTopics === true;
   if (threadId && isolate) return `${chatId}:${threadId}`;
@@ -28,4 +45,71 @@ function getChatIdFromKey(sessionKey) {
   return sessionKey.split(':')[0];
 }
 
-module.exports = { getSessionKey, getChatIdFromKey };
+/**
+ * Inverse of `getChatIdFromKey`: returns the thread_id portion of an
+ * isolated-topic sessionKey, or null when there's no thread suffix.
+ * Used by rc.47 autonomous-wakeup routing — when ScheduleWakeup
+ * fires inside a polygram-spawned Query without a corresponding
+ * pm.send, we derive (chat_id, thread_id) from sessionKey to route
+ * the autonomous output back to the right Telegram chat/topic.
+ */
+function getThreadIdFromKey(sessionKey) {
+  if (typeof sessionKey !== 'string' || !sessionKey) return null;
+  const idx = sessionKey.indexOf(':');
+  if (idx < 0) return null;
+  const thread = sessionKey.slice(idx + 1);
+  return thread || null;
+}
+
+/**
+ * Resolve the human-readable name for a topic. Handles both the legacy
+ * string form (`topics["100"] = "Orders"`) and the rc.48 object form
+ * (`topics["200"] = { name: "Music", agent: "music-curation" }`). Falls
+ * back to the threadId itself if the topic has no name field.
+ */
+function getTopicName(chatConfig, threadId) {
+  if (threadId == null || threadId === '') return null;
+  const t = chatConfig?.topics?.[threadId];
+  if (typeof t === 'string') return t;
+  if (t && typeof t === 'object' && typeof t.name === 'string' && t.name) {
+    return t.name;
+  }
+  return String(threadId);
+}
+
+/**
+ * rc.48: extract per-topic SdkOptions overrides. Returns the topic
+ * entry's overridable fields (model, effort, cwd, agent,
+ * permissionMode), excluding `name` (which is a polygram label, not
+ * an SdkOptions field — see getTopicName).
+ *
+ * Returns `{}` for:
+ *   - missing threadId
+ *   - missing chatConfig.topics
+ *   - threadId not present in topics
+ *   - legacy string topic entry (label-only, no overrides)
+ *   - object with only `name`
+ *
+ * Callers (composeSdkOptions, polygram's spawn flow) merge this on
+ * top of chat-level config. Per-topic overrides take HIGHEST
+ * precedence — including overriding the chat-level permissionMode,
+ * which is the principal rc.48 use case (loosen one topic from the
+ * agent's `bypassPermissions` default to `default`).
+ */
+function getTopicConfig(chatConfig, threadId) {
+  if (threadId == null || threadId === '') return {};
+  const t = chatConfig?.topics?.[threadId];
+  if (!t || typeof t !== 'object') return {};
+  // Strip `name` — that's the label, not an override. Everything else
+  // in the entry is an override candidate.
+  const { name, ...overrides } = t;
+  return overrides;
+}
+
+module.exports = {
+  getSessionKey,
+  getChatIdFromKey,
+  getThreadIdFromKey,
+  getTopicName,
+  getTopicConfig,
+};

package/package.json

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

@@ -30,7 +30,7 @@ const { ProcessManager } = require('./lib/process-manager');
 // callbacks), so the rest of polygram.js doesn't branch beyond the
 // 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 { ProcessManagerSdk, extractAssistantText } = require('./lib/process-manager-sdk');
 // rc.42: autosteer-buffer module deleted. Native SDK priority push
 // (pm.injectUserMessage) replaces the buffer + PostToolBatch detour.
 const { createAutosteeredRefs } = require('./lib/autosteered-refs');
@@ -195,12 +195,13 @@ function isWellFormedMessage(msg) {
 }
 
 // ─── Session key — moved to lib/session-key.js so tests can import it. ─
-const { getSessionKey, getChatIdFromKey } = require('./lib/session-key');
-
-function getTopicName(chatConfig, threadId) {
-  if (!threadId) return null;
-  return chatConfig.topics?.[threadId] || threadId;
-}
+const {
+  getSessionKey,
+  getChatIdFromKey,
+  getThreadIdFromKey,
+  getTopicName,
+  getTopicConfig,
+} = require('./lib/session-key');
 
 function getSessionLabel(chatConfig, threadId) {
   const topic = getTopicName(chatConfig, threadId);
@@ -826,30 +827,52 @@ function spawnClaude(sessionKey, ctx) {
  * mcpServers, optional resume sessionId for continuity.
  */
 function buildSdkOptions(sessionKey, ctx) {
-  const { chatConfig, existingSessionId, label, chatId } = ctx;
+  const { chatConfig, existingSessionId, label, chatId, threadId } = ctx;
+
+  // rc.48: per-topic config overrides. When `topics[threadId]` is an
+  // object (not a legacy string label), these fields take precedence
+  // over chat-level config. Principal use case: scope a single topic
+  // to a different agent, cwd, or permissionMode (e.g. flip music
+  // topic from `bypassPermissions` to `default` so settings.json
+  // permissions.allow gates apply).
+  //
+  // Per-topic overrides only apply meaningfully when isolateTopics is
+  // true — each topic has its own SDK Query. With isolateTopics: false
+  // all topics share one Query whose options are fixed at first-spawn.
+  // Startup validation (validateTopicConfigs) emits a one-time warning
+  // when a chat has topic overrides + isolateTopics: false.
+  const topicConfig = getTopicConfig(chatConfig, threadId);
+  const effectiveAgent = topicConfig.agent || chatConfig.agent;
 
   // Per-chat agent (D14): if pinned, load & compose. Failure is
   // non-fatal — chat falls back to defaults; logged for ops.
   let agentBundle = null;
-  if (chatConfig.agent) {
+  if (effectiveAgent) {
     try {
-      agentBundle = agentLoader.loadAgent(chatConfig.agent, {
+      agentBundle = agentLoader.loadAgent(effectiveAgent, {
         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,
+        // user-level path or polygram's directory convention. rc.48:
+        // topic-level cwd takes precedence so topic-scoped agents
+        // load from the topic's project dir.
+        cwd: topicConfig.cwd || chatConfig.cwd,
         logger: console,
       });
     } catch (err) {
       console.error(`[${label}] agent-loader: ${err.message}`);
       logEvent('agent-load-failed', {
-        chat_id: chatId, agent: chatConfig.agent, error: err.message,
+        chat_id: chatId, agent: effectiveAgent, error: err.message,
+        topic: threadId || null,
       });
     }
   }
 
-  console.log(`[${label}] Spawning SDK Query (${chatConfig.model}/${chatConfig.effort})`);
+  const effectiveModel = topicConfig.model || chatConfig.model;
+  const effectiveEffort = topicConfig.effort || chatConfig.effort;
+  const agentSuffix = effectiveAgent && effectiveAgent !== chatConfig.agent
+    ? ` agent=${effectiveAgent}` : '';
+  console.log(`[${label}] Spawning SDK Query (${effectiveModel}/${effectiveEffort}${agentSuffix})`);
 
   // Env: SHADOW semantics (gate 33) — must enumerate every var
   // pollygram needs in the spawned worker.
@@ -916,10 +939,11 @@ function buildSdkOptions(sessionKey, ctx) {
     }),
   };
 
-  // Compose with agent overlay + chat-level config. agent-loader
-  // precedence: chatConfig > agent > defaults. The chatConfig keys
-  // we care about for SDK options are model/effort/cwd/thinking;
-  // others (agent, chrome, isolateTopics) are polygram-only.
+  // Compose with agent overlay + chat-level config + per-topic overrides.
+  // agent-loader precedence: topicConfig > chatConfig > agent > defaults.
+  // The chatConfig keys we care about for SDK options are
+  // model/effort/cwd/thinking; others (agent, chrome, isolateTopics)
+  // are polygram-only and stripped by composeSdkOptions.
   const composed = agentLoader.composeSdkOptions(
     {
       // chat-level overrides — only the keys SDK understands.
@@ -930,8 +954,19 @@ function buildSdkOptions(sessionKey, ctx) {
     },
     agentBundle,
     baseOpts,
+    topicConfig,  // rc.48: highest precedence — overrides chat-level fields.
   );
 
+  // rc.48: keep permissionMode + allowDangerouslySkipPermissions
+  // consistent. baseOpts sets allowDangerouslySkipPermissions=true when
+  // permissionMode='bypassPermissions'. If a topic flipped permissionMode
+  // to anything else (typically 'default' to gate via settings.json),
+  // also disable allowDangerouslySkipPermissions so the SDK actually
+  // honours the permission gates instead of skipping them.
+  if (composed.permissionMode && composed.permissionMode !== 'bypassPermissions') {
+    composed.allowDangerouslySkipPermissions = false;
+  }
+
   // Append polygram's display constraints to the systemPrompt.
   // Infrastructure-layer hint — the agent's own prompt covers
   // business logic; polygram adds "your output renders in Telegram,
@@ -3665,6 +3700,50 @@ async function main() {
       const r = head?.context?.reactor;
       if (r && typeof r.heartbeat === 'function') r.heartbeat();
     },
+    // rc.47: autonomous wakeup forwarding. Fires when an SDK
+    // assistant message arrives with no head pending — typical
+    // ScheduleWakeup case where the agent self-fires without an
+    // inbound user message. We derive chat_id (always) and thread_id
+    // (when isolateTopics) from the sessionKey, then send the text
+    // to that chat/topic. Subagent messages were already filtered
+    // upstream (parent_tool_use_id != null check in pm-sdk).
+    //
+    // Best-effort send: failures are logged but don't propagate —
+    // an autonomous turn that can't be delivered shouldn't crash
+    // the daemon. Telemetry emitted as `autonomous-wakeup-message`
+    // so we can audit how often these fire and whether any get lost.
+    onAutonomousAssistantMessage: (sessionKey, msg /* , entry */) => {
+      try {
+        const text = extractAssistantText(msg);
+        if (!text) return;
+        const chatId = getChatIdFromKey(sessionKey);
+        const threadIdRaw = getThreadIdFromKey(sessionKey);
+        const threadId = threadIdRaw ? parseInt(threadIdRaw, 10) : null;
+        if (!bot) {
+          console.error(`[${BOT_NAME}] autonomous wakeup: bot not ready, dropping ${text.length} chars`);
+          return;
+        }
+        const params = {
+          chat_id: chatId,
+          text,
+          ...(Number.isInteger(threadId) && { message_thread_id: threadId }),
+        };
+        // Don't `await` — keep the pm-sdk event loop unblocked. The
+        // tg() wrapper handles its own retries / chunking.
+        tg(bot, 'sendMessage', params,
+          { source: 'autonomous-wakeup', botName: BOT_NAME }).catch((err) => {
+            console.error(`[${BOT_NAME}] autonomous wakeup send failed: ${err.message}`);
+          });
+        logEvent('autonomous-wakeup-message', {
+          chat_id: chatId,
+          session_key: sessionKey,
+          thread_id: threadIdRaw,
+          text_len: text.length,
+        });
+      } catch (err) {
+        console.error(`[${BOT_NAME}] autonomous wakeup handler: ${err.message}`);
+      }
+    },
     // rc.29 onThinking removed — replaced by simpler timer-based
     // approach in handleMessage (post-QUEUED setState). The
     // SDK-thinking-block detection added complexity (partial-message
@@ -3751,6 +3830,26 @@ async function main() {
   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(', ')}`);
 
+  // rc.48: validate per-topic config + isolateTopics relationship.
+  // Per-topic SdkOptions overrides only take effect when each topic
+  // gets its own SDK Query (isolateTopics: true). Without isolation
+  // the Query is fixed at first-spawn time; subsequent topic-scoped
+  // messages share that Query regardless of topic-level overrides.
+  for (const [chatId, chatCfg] of Object.entries(config.chats)) {
+    if (!chatCfg.topics || typeof chatCfg.topics !== 'object') continue;
+    const overrideTopics = Object.entries(chatCfg.topics)
+      .filter(([, t]) => t && typeof t === 'object'
+        && Object.keys(t).some((k) => k !== 'name'));
+    if (overrideTopics.length === 0) continue;
+    if (chatCfg.isolateTopics !== true) {
+      const ids = overrideTopics.map(([id]) => id).join(', ');
+      console.warn(`[${BOT_NAME}] WARN: chat ${chatId} (${chatCfg.name}) has topic overrides on topic_ids=${ids} but isolateTopics is not true — overrides will be IGNORED. Set isolateTopics: true to make per-topic config take effect.`);
+      logEvent('topic-override-without-isolation', {
+        chat_id: chatId, name: chatCfg.name, topic_ids: ids,
+      });
+    }
+  }
+
   bot = createBot(config.bot.token);
 
   // Graceful shutdown: stop accepting new inbound, drain in-flight pendings