polygram 0.8.0-rc.45 → 0.8.0-rc.47

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.45",
+  "version": "0.8.0-rc.47",
   "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/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

@@ -28,4 +28,20 @@ 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;
+}
+
+module.exports = { getSessionKey, getChatIdFromKey, getThreadIdFromKey };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polygram",
-  "version": "0.8.0-rc.45",
+  "version": "0.8.0-rc.47",
   "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,7 +195,7 @@ function isWellFormedMessage(msg) {
 }
 
 // ─── Session key — moved to lib/session-key.js so tests can import it. ─
-const { getSessionKey, getChatIdFromKey } = require('./lib/session-key');
+const { getSessionKey, getChatIdFromKey, getThreadIdFromKey } = require('./lib/session-key');
 
 function getTopicName(chatConfig, threadId) {
   if (!threadId) return null;
@@ -1947,6 +1947,38 @@ async function handleMessage(sessionKey, chatId, msg, bot) {
     }
     return;
   }
+  // 0.8.0-rc.46: /reload — close + respawn the SDK Query while
+  // PRESERVING the persisted claude_session_id. The next user
+  // message resumes the conversation (model has prior context via
+  // SDK resume) but the spawn re-reads agent / skill / plugin files
+  // from disk, so any local edits to ~/.claude/agents/<name>.md or
+  // skill files take effect.
+  //
+  // Difference vs /new:
+  //   /new    → resetSession clears session_id → fresh conversation
+  //   /reload → kill closes Query, session_id preserved → same
+  //              conversation continues with fresh agent/skill code
+  //
+  // Mechanism: pm.kill drains the pending queue (with code 'KILLED')
+  // and closes the SDK Query. Crucially it does NOT call
+  // db.clearSessionId — the contract test
+  // 'pm.kill does NOT call db.clearSessionId' pins this invariant.
+  // The next user message hits getOrSpawn → no warm Query → spawn
+  // fresh with `resume: <session_id>` from sessions table → SDK
+  // restores conversation history → fresh files loaded.
+  if (botAllowsCommands && text === '/reload') {
+    if (pm.has(sessionKey)) {
+      try { await pm.kill(sessionKey); }
+      catch (err) { console.error(`[${label}] kill on /reload: ${err.message}`); }
+    }
+    logEvent('session-reload-command', {
+      chat_id: chatId, command: text,
+      user: cmdUser, user_id: cmdUserId,
+    });
+    await sendReply('🔄 Reloaded. Next message picks up the conversation with fresh skills/agents.');
+    return;
+  }
+
   if (botAllowsCommands && (text === '/new' || text === '/reset')) {
     let drained = 0;
     const target = pm.pickFor(sessionKey);
@@ -3633,6 +3665,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