polygram 0.10.0-rc.36 → 0.10.0-rc.38

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "polygram",
-  "version": "0.10.0-rc.36",
+  "version": "0.10.0-rc.38",
   "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 plus history (transcript queries) and polygram-send (out-of-turn IPC sends with file-upload validation) skills.",
   "keywords": [
     "telegram",

package/lib/sdk/callbacks.js

@@ -344,13 +344,27 @@ function createSdkCallbacks({
       }
     },
 
-    // 0.10.0 H1 (observer-only): tmux backend hook-based turn
-    // observability. TmuxProcess emits `hook-event` with normalized
-    // HookEvent records for every claude-CLI hook firing (PreToolUse,
+    // 0.10.0 H1 (observer-only) + H2 (reactor wiring): tmux backend
+    // hook-based turn observability + status.
+    //
+    // H1: TmuxProcess emits `hook-event` with normalized HookEvent
+    // records for every claude-CLI hook firing (PreToolUse,
     // PostToolUse, UserPromptSubmit, Stop, SubagentStop, Notification,
-    // plus `unknown` for any schema drift). Persisted compact so the
-    // soak can characterize the stream's reliability against real
-    // Music traffic before H2/H3/H4 consume it.
+    // plus `unknown` for any schema drift). Persisted compact for
+    // forensic soak analysis.
+    //
+    // H2: routes hook events to the head pending's reactor so the
+    // Telegram emoji reflects what claude is actually doing — incl.
+    // subagent-inner tool fires (PreToolUse with `agent_id`) that
+    // JSONL `tool-use` never surfaces. The win: long subagent turns
+    // stop tripping the 🥱→😨→🤯 escalation because each inner
+    // PostToolUse / SubagentStop / Notification heartbeats the
+    // reactor, proving the agent is alive.
+    //
+    // Augments — does NOT replace — the existing JSONL-driven
+    // `onToolUse` setState and stream-chunk heartbeats. Duplicate
+    // setState for the same state is a no-op in the reactor; the
+    // throttle/cascade timers are unchanged.
     //
     // Fields persisted are intentionally narrow: identity + tool/
     // subagent scoping + `duration_ms` (free per-tool latency from
@@ -359,8 +373,9 @@ function createSdkCallbacks({
     // (`tool_input`, full `tool_response`, `last_assistant_message`)
     // are NOT persisted to the events DB — they'd inflate row size
     // without informing the soak.
-    onHookEvent: (sessionKey, payload /* , entry */) => {
+    onHookEvent: (sessionKey, payload, entry) => {
       try {
+        // ── H1: DB persist ────────────────────────────────────────
         const detail = {
           chat_id: getChatIdFromKey(sessionKey),
           session_key: sessionKey,
@@ -387,6 +402,58 @@ function createSdkCallbacks({
           detail.parse_error = payload?.error ?? null;
         }
         logEvent('hook-event', detail);
+
+        // ── H2: route to reactor ──────────────────────────────────
+        //
+        // The reactor lives on the HEAD pending's per-turn context
+        // (same shape as `onToolUse` and `onStreamChunk`). Hook
+        // events from claude can land in three windows relative to
+        // a polygram turn:
+        //   1. Mid-turn (the normal case) — head exists, reactor
+        //      lives, route the event.
+        //   2. Between turns / before head is set — head is null,
+        //      skip silently. The next setState from polygram-side
+        //      turn lifecycle will recover.
+        //   3. UserPromptSubmit fires BEFORE polygram's
+        //      reactor.setState('THINKING') in some races; that's
+        //      fine because UserPromptSubmit is intentionally a
+        //      no-op here (the existing turn-start path owns it).
+        const head = entry?.pendingQueue?.[0];
+        const reactor = head?.context?.reactor;
+        if (!reactor) return;
+
+        switch (payload?.type) {
+          case 'PreToolUse':
+            // PreToolUse fires for main-agent AND subagent-inner
+            // tools (the latter scoped by `agent_id`). The reactor
+            // doesn't care WHO ran the tool, only WHAT — so
+            // classifyToolName drives the state regardless of
+            // agent context.
+            if (payload.toolName) {
+              reactor.setState(classifyToolName(payload.toolName));
+            }
+            break;
+
+          case 'PostToolUse':
+          case 'SubagentStop':
+          case 'Notification':
+            // Liveness signals — each one proves the agent is still
+            // making progress. Heartbeat resets the STALL (🥱) and
+            // TIMEOUT (😨) timers, killing the fear escalation on
+            // long healthy turns that was the motivating msg-884
+            // incident.
+            if (typeof reactor.heartbeat === 'function') {
+              reactor.heartbeat();
+            }
+            break;
+
+          // UserPromptSubmit, Stop, unknown, parse-error: no
+          // reactor routing. Turn lifecycle owns start/clear; the
+          // observer-only H1 DB persist above still records them
+          // for forensics.
+          default:
+            break;
+        }
       } catch (err) {
         logger.error?.(`[${botName}] hook-event handler: ${err.message}`);
       }

package/lib/telegram/display-hint.js

@@ -57,6 +57,17 @@ const POLYGRAM_DISPLAY_HINT = [
   '- Headers `#`, `##`, `###` render as plain text — use **bold** for emphasis.',
   '- Horizontal rules render as a thin divider line.',
   '- Long replies stream in chunks; prefer concise structure over walls of text.',
+  '',
+  '### NEVER emit shell-context canned strings — HARD RULE',
+  '',
+  'You are running as a Telegram chat bot, NOT as a script being piped into a shell. Certain phrases are CLI-context boilerplate from the underlying environment and MUST NEVER appear in a reply, because the user sees them as a literal message from you and they look like a system error:',
+  '',
+  '- `No response requested.`',
+  '- `No response needed.`',
+  '- `Continuing...` as a standalone reply',
+  '- Any other shell-prompt-style filler that acknowledges silence',
+  '',
+  'If a user message is short, ambiguous, or feels like a no-op acknowledgement (e.g. `okay`, `ok`, `yes`, `got it`, `thanks`), reply with a brief substantive line — acknowledge what you understood and what (if anything) you will do next. If you genuinely have nothing useful to say, ask ONE specific clarifying question. NEVER emit a placeholder or a shell-style canned string — the chat surface has no silent-no-op state. Every reply must be intentional content.',
 ].join('\n');
 
 /**

package/package.json

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