polygram 0.8.0-rc.47 → 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.47",
+  "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/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}`;
@@ -44,4 +61,55 @@ function getThreadIdFromKey(sessionKey) {
   return thread || null;
 }
 
-module.exports = { getSessionKey, getChatIdFromKey, getThreadIdFromKey };
+/**
+ * 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.47",
+  "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

@@ -195,12 +195,13 @@ function isWellFormedMessage(msg) {
 }
 
 // ─── Session key — moved to lib/session-key.js so tests can import it. ─
-const { getSessionKey, getChatIdFromKey, getThreadIdFromKey } = 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,
@@ -3795,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