polygram 0.10.0-rc.27 → 0.10.0-rc.28

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.27",
+  "version": "0.10.0-rc.28",
   "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/process/tmux-process.js

@@ -770,6 +770,12 @@ class TmuxProcess extends Process {
         // The interrupt signal still wins here too — Bug 3: an
         // interrupted tool turn writes no terminal JSONL `result`, so
         // without this racer it would hang to `turnTimeoutMs`.
+        //
+        // B10: an outstanding `Agent` subagent counts as "tool in
+        // flight" exactly like a foreground `Bash` — its `tool-use`
+        // already set `toolUsedThisTurn`, so this branch catches the
+        // common case. The race where capture wins BEFORE the `Agent`
+        // tool_use line is tailed is handled by the §6 re-check below.
         if (winner.kind === 'capture' && turn.toolUsedThisTurn) {
           winner = await Promise.race([
             turn.resultPromise.then((ev) => ({ kind: 'jsonl', ev })),
@@ -835,11 +841,41 @@ class TmuxProcess extends Process {
           text = turn.text;
         } else {
           const lateGraceMs = this.lateGraceMs ?? 1500;
-          const late = await Promise.race([
+          let late = await Promise.race([
             turn.resultPromise.then((ev) => ({ kind: 'jsonl-late', ev })),
             new Promise((r) => setTimeout(() => r({ kind: 'no-jsonl' }), lateGraceMs)),
           ]);
-          if (late.kind === 'jsonl-late') {
+          // B10 (shumorobot Music topic, 2026-05-20): the main agent
+          // delegated to an `Agent` subagent within ~7 s, then the main
+          // pane went quiescent for MINUTES while the subagent ran in
+          // its own sidechain. capture-pane read that quiescence as
+          // "done"; the main agent had emitted only the `Agent` call so
+          // no JSONL reply text existed yet, and the §6 fail-loud below
+          // fired ~grace-window in — closing a turn that was genuinely
+          // in flight. A subagent is still running iff its `Agent`
+          // tool_use has no matching `tool-result` yet. While one is
+          // outstanding, capture-pane quiescence of the MAIN pane is
+          // meaningless — the turn completes only when the subagent
+          // returns and the main agent emits its real terminal reply.
+          // Wait for that JSONL `result`, bounded by the absolute turn
+          // deadline so a genuinely wedged turn still fails loud.
+          if (late.kind === 'no-jsonl' && turn.outstandingSubagents.size > 0) {
+            this.emit('subagent-wait', {
+              outstanding: turn.outstandingSubagents.size,
+              turnId: turn.turnId,
+            });
+            late = await Promise.race([
+              turn.resultPromise.then((ev) => ({ kind: 'jsonl-late', ev })),
+              turnDeadlineP,
+              turn.interruptP.then(() => ({ kind: 'interrupt' })),
+            ]);
+          }
+          if (late.kind === 'interrupt') {
+            turn.interrupted = true;
+            text = turn.text || '';
+            resultSubtype = 'interrupted';
+            stopReason = 'interrupted';
+          } else if (late.kind === 'jsonl-late') {
             resolvedVia = 'jsonl-late';
             text = turn.text || late.ev.text || '';
             resultSubtype = late.ev.subtype || 'success';
@@ -968,6 +1004,13 @@ class TmuxProcess extends Process {
       text: '',
       toolUses: 0,
       toolUsedThisTurn: false,
+      // B10: outstanding `Agent` (subagent/Task) tool_use ids — a
+      // tool_use with no matching tool_result yet. A non-empty set
+      // means a subagent is running in its own sidechain context: the
+      // main pane goes quiescent for MINUTES while it works, and that
+      // quiescence must NOT be read as turn completion. Cleared when
+      // the matching `tool-result` arrives.
+      outstandingSubagents: new Set(),
       stopReason: null,
       resultEvent: null,
       via: null,                 // autosteer: 'fold' | 'new-turn'
@@ -1145,8 +1188,25 @@ class TmuxProcess extends Process {
         // the flag here so a transient capture-pane "ready" between
         // tool calls cannot resolve a still-working turn.
         t.toolUsedThisTurn = true;
+        // B10: an `Agent` (subagent/Task) tool_use spawns a subagent
+        // that runs for MINUTES in its own sidechain context while the
+        // main pane sits quiescent. Track its id as outstanding until
+        // the matching `tool-result` returns — `_runTurn` treats an
+        // outstanding subagent as "turn still in flight" so the main
+        // pane's quiescence cannot trip the §6 fail-loud.
+        if (ev.name === 'Agent' && typeof ev.id === 'string') {
+          t.outstandingSubagents.add(ev.id);
+        }
       }
       this.emit('tool-use', ev.name);
+    } else if (ev.type === 'tool-result') {
+      // B10: a subagent returned. Clear the outstanding `Agent` call
+      // it answers across every turn in the active group. A
+      // tool-result for a non-Agent tool (or an id we never tracked)
+      // is a harmless no-op — the set only ever held `Agent` ids.
+      for (const t of this._activeGroup.turns) {
+        t.outstandingSubagents.delete(ev.toolUseId);
+      }
     } else if (ev.type === 'usage') {
       // Token-usage snapshot from JSONL. Cache for getContextUsage().
       // Each assistant message carries the cumulative usage; latest

package/lib/tmux/session-log-parser.js

@@ -50,6 +50,7 @@
  *                               (ONCE per message.id, on finalize)
  * - last-prompt               → 'last-prompt' (fallback complete signal)
  * - user (top-level string)   → 'user-message' { text, parentUuid, promptId }
+ * - user tool_result block    → 'tool-result' { toolUseId, isError }
  * - queue-operation           → 'queue-operation' { operation, content }
  *
  * Robust against malformed lines: skips them.
@@ -128,6 +129,31 @@ function extractContentBlocks(content) {
   return { textParts, toolUses };
 }
 
+/**
+ * Pull `tool_result` blocks out of a user message's `content` array.
+ * A user message with array content carries API-shaped tool feedback
+ * (NOT a user prompt). Each `tool_result` block names the `tool_use`
+ * it answers via `tool_use_id` — the matcher polygram's turn ledger
+ * uses to clear an outstanding `Agent`/subagent call.
+ *
+ * @returns {object[]} `tool-result` events, possibly empty.
+ */
+function extractToolResults(content) {
+  const out = [];
+  if (!Array.isArray(content)) return out;
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    if (block.type === 'tool_result' && typeof block.tool_use_id === 'string') {
+      out.push({
+        type: 'tool-result',
+        toolUseId: block.tool_use_id,
+        isError: block.is_error === true,
+      });
+    }
+  }
+  return out;
+}
+
 /**
  * Join assistant text blocks the way the SDK backend's
  * `extractAssistantText` does (rc.8 cross-backend parity): blocks
@@ -204,12 +230,15 @@ function parseLine(line) {
   } else if (obj.type === 'last-prompt') {
     out.push({ type: 'last-prompt', text: obj.lastPrompt ?? '' });
   } else if (obj.type === 'user' && obj.message) {
-    // Top-level user message — only emit when content is a non-empty
-    // string. Array content carries tool_result blocks (API-shaped
-    // tool feedback), NOT a user prompt — skip those.
+    // Top-level user message. String content is a user prompt. Array
+    // content carries API-shaped `tool_result` blocks (tool feedback,
+    // NOT a prompt) — those surface as `tool-result` events so the
+    // turn ledger can clear an outstanding `Agent`/subagent call.
     const content = obj.message.content;
     if (typeof content === 'string' && content.length > 0) {
       out.push({ type: 'user-message', text: content });
+    } else {
+      out.push(...extractToolResults(content));
     }
   } else if (obj.type === 'attachment' && obj.attachment) {
     const a = obj.attachment;
@@ -321,6 +350,13 @@ class SessionEventAggregator {
           parentUuid: obj.parentUuid ?? null,
           promptId: obj.promptId ?? null,
         });
+      } else {
+        // Array content — API-shaped `tool_result` blocks. A subagent
+        // (`Agent` tool) returning to the main agent surfaces here;
+        // the turn ledger keys on `toolUseId` to clear the outstanding
+        // subagent call so capture-pane quiescence of the main pane is
+        // not mistaken for turn completion while the subagent runs.
+        out.push(...extractToolResults(content));
       }
     } else if (obj.type === 'last-prompt') {
       out.push({ type: 'last-prompt', text: obj.lastPrompt ?? '' });

package/package.json

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