polygram 0.10.0-rc.2 → 0.10.0-rc.21

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

@@ -10,25 +10,52 @@
  * actual conversation events live in the per-session JSONL claude
  * writes to disk for /resume to work.
  *
- * Each JSONL line is a JSON object with `type` discriminator:
+ * # Two parsers, one event surface
  *
- *   { type: 'user',           message: {...} }
- *   { type: 'assistant',      message: {... content: [...], stop_reason: 'end_turn'} }
- *   { type: 'attachment',     attachment: {...} }
- *   { type: 'last-prompt',    lastPrompt: '...' }
- *   { type: 'queue-operation', operation: 'enqueue', content: '...' }
+ * - `parseLine(line)` — STATELESS, one JSONL line → events. Kept for
+ *   single-line use and its test coverage. Cannot coalesce a logical
+ *   assistant message that spans multiple JSONL lines.
+ * - `SessionEventAggregator` — STATEFUL, the primary path used by
+ *   `pipeToParser`. It coalesces by `message.id` (0.10.0 Phase 1).
+ *
+ * ## Why the aggregator exists — the empty-turn bug
+ *
+ * Verified against real claude 2.1.142 JSONL: ONE logical assistant
+ * message is written across MULTIPLE JSONL lines that all share the
+ * same `message.id` and all repeat the message-level `stop_reason`.
+ * A terminal message commonly arrives as a `thinking` line then a
+ * `text` line — both `stop_reason: end_turn`, same id.
+ *
+ * The stateless parser fires a `result` for EVERY line carrying a
+ * stop_reason. The `thinking` line has `end_turn` but no text → it
+ * resolves the turn with text='' BEFORE the real-text line is read.
+ * That is the zero-concurrency empty-turn bug. The aggregator fixes
+ * it by buffering lines per `message.id` and firing `result` ONCE,
+ * when the message finalizes, with the full coalesced text.
+ *
+ * # JSONL line shapes (claude 2.1.142, verified)
+ *
+ *   { type: 'user',           message: {...}, parentUuid, promptId }
+ *   { type: 'assistant',      message: {id, content:[...], stop_reason} }
+ *   { type: 'last-prompt',    lastPrompt?: '...' }
+ *   { type: 'queue-operation', operation: 'enqueue'|'dequeue', content? }
+ *   { type: 'system' | 'attachment' | 'permission-mode' | ... }
  *
  * # Mapping to Process events
  *
- * - assistant with `content[].type === 'text'`   → emit 'assistant-chunk' { text }
- * - assistant with `content[].type === 'tool_use'` → emit 'tool-use' { name, input }
- * - assistant with `message.stop_reason`         → emit 'result' { subtype, text, ... }
- * - last-prompt                                  → emit 'last-prompt' (fallback complete signal)
+ * - assistant text block      → 'assistant-chunk' { text }     (eager, per-line)
+ * - assistant tool_use block  → 'tool-use' { name, input, id } (eager, per-line)
+ * - assistant usage block     → 'usage' {...}                  (eager, per-line)
+ * - assistant message end     → 'result' { subtype, text, stopReason }
+ *                               (ONCE per message.id, on finalize)
+ * - last-prompt               → 'last-prompt' (fallback complete signal)
+ * - user (top-level string)   → 'user-message' { text, parentUuid, promptId }
+ * - queue-operation           → 'queue-operation' { operation, content }
  *
- * Robust against malformed lines: returns null and skips.
+ * Robust against malformed lines: skips them.
  *
  * @see lib/tmux/log-tail.js — generic file tailer
- * @see docs/0.10.0-process-manager-abstraction-plan.md v9
+ * @see docs/0.10.0-tmux-concurrency-solution.md §3 (Phase 1)
  */
 
 'use strict';
@@ -72,20 +99,73 @@ function sessionLogPath(cwd, sessionId, homeDir = os.homedir()) {
   return path.join(homeDir, '.claude', 'projects', encodeCwd(cwd), `${sessionId}.jsonl`);
 }
 
+// ─── shared content-block extraction ─────────────────────────────────
+
+/**
+ * Pull the text + tool_use blocks out of an assistant message's
+ * `content` array. Shared by `parseLine` and `SessionEventAggregator`
+ * so both surface byte-identical text/tool extraction.
+ *
+ * @returns {{textParts: string[], toolUses: object[]}}
+ */
+function extractContentBlocks(content) {
+  const textParts = [];
+  const toolUses = [];
+  if (!Array.isArray(content)) return { textParts, toolUses };
+  for (const block of content) {
+    if (!block || typeof block !== 'object') continue;
+    if (block.type === 'text' && typeof block.text === 'string' && block.text.length > 0) {
+      textParts.push(block.text);
+    } else if (block.type === 'tool_use' && block.name) {
+      toolUses.push({
+        type: 'tool-use',
+        name: block.name,
+        input: block.input ?? null,
+        id: block.id ?? null,
+      });
+    }
+  }
+  return { textParts, toolUses };
+}
+
+/**
+ * Join assistant text blocks the way the SDK backend's
+ * `extractAssistantText` does (rc.8 cross-backend parity): blocks
+ * joined with '\n\n', trimmed, with a trailing-colon → ellipsis
+ * transform ("Listing deps:" → "Listing deps…") so streamed-but-not-
+ * final text reads complete during a pause while a tool runs.
+ */
+function joinAssistantText(textParts) {
+  return textParts.join('\n\n').trim().replace(/([^:]):\s*$/, '$1…');
+}
+
+/**
+ * Extract the token-usage snapshot from an assistant line, or null.
+ * Every assistant message carries the cumulative usage; the latest
+ * such event wins downstream.
+ */
+function extractUsage(obj) {
+  const u = obj.message && obj.message.usage;
+  if (!u) return null;
+  return {
+    type: 'usage',
+    inputTokens: u.input_tokens ?? 0,
+    outputTokens: u.output_tokens ?? 0,
+    cacheReadTokens: u.cache_read_input_tokens ?? 0,
+    cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
+    model: obj.message.model ?? null,
+  };
+}
+
 /**
- * Parse one JSONL line into a Process-shaped event, OR null when the
- * line carries nothing observable. Malformed JSON → null.
+ * Parse one JSONL line into Process-shaped events, OR [] when the
+ * line carries nothing observable. Malformed JSON → [].
  *
- * Events returned (each with `type` field):
- *   - 'assistant-chunk' { text }
- *   - 'tool-use'        { name, input, id }
- *   - 'result'          { subtype, text, stopReason }
- *   - 'last-prompt'     { text }
+ * STATELESS — cannot coalesce a multi-line assistant message. For the
+ * live tail path use `SessionEventAggregator` (via `pipeToParser`).
  *
  * @param {string} line
- * @returns {object[]} array of events (a single line CAN produce
- *   multiple — e.g. an assistant message with both text and tool_use
- *   content blocks emits both 'assistant-chunk' and 'tool-use').
+ * @returns {object[]}
  */
 function parseLine(line) {
   if (!line || typeof line !== 'string') return [];
@@ -98,42 +178,18 @@ function parseLine(line) {
 
   if (obj.type === 'assistant' && obj.message) {
     const content = obj.message.content;
-    if (Array.isArray(content)) {
-      for (const block of content) {
-        if (!block || typeof block !== 'object') continue;
-        if (block.type === 'text' && typeof block.text === 'string' && block.text.length > 0) {
-          out.push({ type: 'assistant-chunk', text: block.text });
-        } else if (block.type === 'tool_use' && block.name) {
-          out.push({
-            type: 'tool-use',
-            name: block.name,
-            input: block.input ?? null,
-            id: block.id ?? null,
-          });
-        }
-      }
+    const { textParts, toolUses } = extractContentBlocks(content);
+    // Emit text FIRST then tool-uses — text-then-tool is the dominant
+    // real-world shape.
+    if (textParts.length > 0) {
+      const joined = joinAssistantText(textParts);
+      if (joined.length > 0) out.push({ type: 'assistant-chunk', text: joined });
     }
-    // Token-usage telemetry. Every assistant message carries the
-    // cumulative usage snapshot — input_tokens + cache_creation +
-    // cache_read = current context size. TmuxProcess uses the latest
-    // such event to implement getContextUsage().
-    if (obj.message.usage) {
-      const u = obj.message.usage;
-      out.push({
-        type: 'usage',
-        inputTokens: u.input_tokens ?? 0,
-        outputTokens: u.output_tokens ?? 0,
-        cacheReadTokens: u.cache_read_input_tokens ?? 0,
-        cacheCreationTokens: u.cache_creation_input_tokens ?? 0,
-        model: obj.message.model ?? null,
-      });
-    }
-    // stop_reason marks end of an assistant turn segment. 'end_turn'
-    // is the canonical complete; 'tool_use' / 'max_tokens' / etc. are
-    // partial-with-continuation. We forward all stop_reasons so the
-    // caller can decide.
+    for (const t of toolUses) out.push(t);
+    const usage = extractUsage(obj);
+    if (usage) out.push(usage);
+    // stop_reason marks end of an assistant turn segment.
     if (obj.message.stop_reason) {
-      // Collect all text from the message for the result.text field.
       const text = Array.isArray(content)
         ? content.filter((b) => b?.type === 'text').map((b) => b.text || '').join('')
         : '';
@@ -147,21 +203,205 @@ 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.
+    const content = obj.message.content;
+    if (typeof content === 'string' && content.length > 0) {
+      out.push({ type: 'user-message', text: content });
+    }
+  } else if (obj.type === 'attachment' && obj.attachment) {
+    const a = obj.attachment;
+    if (a.type === 'queued_command' && typeof a.prompt === 'string' && a.prompt.length > 0) {
+      out.push({ type: 'queue-folded', prompt: a.prompt });
+    }
   }
 
   return out;
 }
 
+// ─── stateful aggregator (0.10.0 Phase 1) ────────────────────────────
+
 /**
- * Wrap a LogTail (or any EventEmitter that emits 'line') and
- * forward parsed events via 'event'. Returns the emitter so callers
- * can chain `.on('event', ...)`.
+ * SessionEventAggregator — stateful JSONL → event translator that
+ * coalesces a logical assistant message spanning multiple JSONL lines
+ * (all sharing one `message.id`).
+ *
+ * Contract:
+ *   - `assistant-chunk` / `tool-use` / `usage` are emitted EAGERLY,
+ *     per JSONL line — live streaming granularity is preserved.
+ *   - `result` is emitted ONCE per `message.id`, when that message
+ *     FINALIZES. A message finalizes when (a) a line with a different
+ *     message.id arrives, (b) any non-assistant line arrives, or
+ *     (c) `flush()` is called (turn-complete / tail-close safety net).
+ *   - An assistant line WITHOUT a `message.id` is treated as its own
+ *     standalone message and parsed per-line via `parseLine` — real
+ *     claude always writes `message.id`; absent id only occurs in
+ *     synthetic test fixtures, which keep their legacy behaviour.
+ *
+ * This is what fixes the zero-concurrency empty-turn bug: a `thinking`
+ * line no longer resolves the turn before its sibling `text` line.
+ */
+class SessionEventAggregator {
+  constructor() {
+    // Buffered in-flight assistant message, or null.
+    //   { id, sessionId, parentUuid, textParts: string[], stopReason }
+    this._asm = null;
+  }
+
+  /**
+   * Feed one raw JSONL line. Returns the events it produced (which may
+   * include the finalize of a PREVIOUSLY buffered message).
+   * @param {string} line
+   * @returns {object[]}
+   */
+  push(line) {
+    if (!line || typeof line !== 'string') return [];
+    let obj;
+    try { obj = JSON.parse(line); }
+    catch { return []; }
+    if (!obj || typeof obj !== 'object') return [];
+
+    const out = [];
+
+    if (obj.type === 'assistant' && obj.message) {
+      const msg = obj.message;
+      const id = (typeof msg.id === 'string' && msg.id.length > 0) ? msg.id : null;
+
+      // No message.id — synthetic/legacy line. Finalize any open
+      // buffer, then emit this line's events per-line exactly as the
+      // stateless parser would (no coalescing without an id to key on).
+      if (id === null) {
+        if (this._asm) out.push(...this._finalize());
+        out.push(...parseLine(line));
+        return out;
+      }
+
+      // A different message id means the previously buffered message
+      // is now complete.
+      if (this._asm && this._asm.id !== id) out.push(...this._finalize());
+      if (!this._asm) {
+        this._asm = {
+          id,
+          sessionId: obj.sessionId ?? null,
+          parentUuid: obj.parentUuid ?? null,
+          textParts: [],
+          stopReason: null,
+        };
+      }
+
+      // Eager per-line events. `result` is the ONLY deferred event.
+      const { textParts, toolUses } = extractContentBlocks(msg.content);
+      if (textParts.length > 0) {
+        const joined = joinAssistantText(textParts);
+        if (joined.length > 0) {
+          this._asm.textParts.push(joined);
+          out.push({ type: 'assistant-chunk', text: joined });
+        }
+      }
+      for (const t of toolUses) out.push(t);
+      const usage = extractUsage(obj);
+      if (usage) out.push(usage);
+      // Every line of a message repeats the message-level stop_reason;
+      // the last non-null one wins.
+      if (msg.stop_reason) this._asm.stopReason = msg.stop_reason;
+      return out;
+    }
+
+    // Any non-assistant line ends the current assistant message.
+    if (this._asm) out.push(...this._finalize());
+
+    if (obj.type === 'user' && obj.message) {
+      const content = obj.message.content;
+      if (typeof content === 'string' && content.length > 0) {
+        out.push({
+          type: 'user-message',
+          text: content,
+          parentUuid: obj.parentUuid ?? null,
+          promptId: obj.promptId ?? null,
+        });
+      }
+    } else if (obj.type === 'last-prompt') {
+      out.push({ type: 'last-prompt', text: obj.lastPrompt ?? '' });
+    } else if (obj.type === 'queue-operation') {
+      // The live queue-activity signal (0.10.0 §3). `enqueue` carries
+      // the pasted `content`; `dequeue` is bare. Phase 2's turn ledger
+      // consumes this to correlate folds vs new-turns by token.
+      out.push({
+        type: 'queue-operation',
+        operation: typeof obj.operation === 'string' ? obj.operation : null,
+        content: typeof obj.content === 'string' ? obj.content : null,
+      });
+    } else if (obj.type === 'attachment' && obj.attachment
+      && obj.attachment.type === 'queued_command'
+      && typeof obj.attachment.prompt === 'string'
+      && obj.attachment.prompt.length > 0) {
+      // Retained for parity with `parseLine`. Confirmed ABSENT from
+      // real claude 2.1.142 JSONL — the live fold signal is
+      // `queue-operation`. Harmless dead branch; Phase 2 retires it.
+      out.push({ type: 'queue-folded', prompt: obj.attachment.prompt });
+    }
+    return out;
+  }
+
+  /**
+   * Finalize any buffered assistant message. Called on turn-complete
+   * and on tail close so the genuinely-last message of a session
+   * (which has no trailing line to trigger finalize) still surfaces
+   * its `result`. Idempotent.
+   * @returns {object[]}
+   */
+  flush() {
+    return this._asm ? this._finalize() : [];
+  }
+
+  /** @returns {object[]} the buffered message's `result`, or []. */
+  _finalize() {
+    const asm = this._asm;
+    this._asm = null;
+    // A message that never carried a stop_reason produced no turn end
+    // — its text already streamed via eager `assistant-chunk`. No
+    // `result`. (The `last-prompt` fallback in TmuxProcess covers a
+    // genuinely missing end_turn.)
+    if (!asm || !asm.stopReason) return [];
+    return [{
+      type: 'result',
+      subtype: asm.stopReason === 'end_turn' ? 'success' : asm.stopReason,
+      text: asm.textParts.join('\n\n'),
+      stopReason: asm.stopReason,
+      sessionId: asm.sessionId,
+      parentUuid: asm.parentUuid,
+    }];
+  }
+}
+
+/**
+ * Wrap a LogTail (or any EventEmitter that emits 'line') with a
+ * `SessionEventAggregator` and forward parsed events via 'event'.
+ *
+ * The aggregator is flushed on the tail's 'close' so a session whose
+ * last assistant message has no trailing line still emits its
+ * `result`. The tail is also given a `flushParser()` method so the
+ * consumer (TmuxProcess) can force a flush at turn-complete.
+ *
+ * @returns the same emitter (chainable).
  */
 function pipeToParser(tail) {
+  const aggregator = new SessionEventAggregator();
   tail.on('line', (line) => {
-    const events = parseLine(line);
-    for (const ev of events) tail.emit('event', ev);
+    for (const ev of aggregator.push(line)) tail.emit('event', ev);
+  });
+  tail.on('close', () => {
+    for (const ev of aggregator.flush()) tail.emit('event', ev);
   });
+  // Exposed so TmuxProcess can finalize the buffered message the
+  // instant a turn is judged complete (e.g. capture-pane quiescence
+  // won the race) instead of waiting for the next JSONL line.
+  tail.flushParser = () => {
+    for (const ev of aggregator.flush()) tail.emit('event', ev);
+  };
+  tail._aggregator = aggregator;
   return tail;
 }
 
@@ -169,5 +409,6 @@ module.exports = {
   encodeCwd,
   sessionLogPath,
   parseLine,
+  SessionEventAggregator,
   pipeToParser,
 };

package/lib/tmux/tmux-runner.js

@@ -32,6 +32,7 @@ const childProcess = require('child_process');
 const crypto = require('crypto');
 const fs = require('fs');
 const path = require('path');
+const { createAsyncLock } = require('../async-lock');
 
 // ─── Constants ───────────────────────────────────────────────────────
 
@@ -173,13 +174,16 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
         stderr: err.stderr,
       });
     }
-    // Set a wide pane to reduce capture-pane wrap artifacts.
-    // Best-effort — if the set-option fails, capture-pane -J fallback
-    // in captureWide() handles the wrap case.
+    // Try to widen the detached pane so claude TUI has room to render
+    // long lines. `resize-window` is the supported way; older
+    // attempts used a non-existent `pane-width` option that always
+    // errored (tmux 3.x: pane-width is a format variable, not a
+    // settable option). capture-pane -J in captureWide() handles
+    // any remaining wrap artifacts.
     try {
-      await runFn('tmux', ['set-option', '-t', name, '-w', 'pane-width', String(paneWidth)]);
+      await runFn('tmux', ['resize-window', '-t', name, '-x', String(paneWidth)]);
     } catch (err) {
-      logger.warn?.(`[tmux-runner] set-option pane-width failed for ${name}: ${err.message}`);
+      logger.debug?.(`[tmux-runner] resize-window failed for ${name}: ${err.message} (capture-pane -J handles wrap)`);
     }
     return name;
   }
@@ -193,6 +197,41 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
     await runFn('tmux', ['send-keys', '-t', name, key]);
   }
 
+  // rc.13.1: paste+Enter must be ATOMIC per session. Pre-rc.13.1 two
+  // concurrent pasteText+sendControl pairs could interleave in the
+  // TUI's bracketed-paste buffer — Ivan caught this on shumorobot
+  // 2026-05-15 (the 2233-char user JSONL entry contained one
+  // truncated polygram channel + a full nested polygram prompt for
+  // a different msg_id). Symptom: msg 696's paste was at byte
+  // `chat_id="-1003` when msg 698's autosteer paste cut in,
+  // concatenating two pastes into one TUI user message → the agent
+  // saw a malformed input → the reply attribution went sideways
+  // (msg 697 got msg 698's answer, msg 696 got served last).
+  //
+  // The async-lock is keyed by tmux session name, so different
+  // sessions don't block each other. Within one session, pasteText
+  // + sendControl(Enter) hold the lock atomically.
+  const inputLock = createAsyncLock();
+  async function pasteAndEnter(name, text) {
+    const release = await inputLock.acquire(name);
+    try {
+      const res = await pasteText(name, text);
+      await sendControl(name, 'Enter');
+      // L3 fix: small post-Enter drain so back-to-back
+      // pasteAndEnter calls don't race in the claude TUI's input
+      // handler. Pre-fix, when two injectUserMessage calls fired in
+      // quick succession (spike multi-2-rapid, ~2/5 failure rate),
+      // the TUI sometimes only enqueued ONE of the two pastes —
+      // the second's bracketed-paste-start collided with the first
+      // Enter's processing. 50ms is enough on the TUI we tested
+      // against (claude v2.1.142); see AGENTS.md pinned version.
+      await new Promise((r) => setTimeout(r, 50));
+      return res;
+    } finally {
+      release();
+    }
+  }
+
   /**
    * Push a multi-line text prompt into the pane.
    *
@@ -200,10 +239,19 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
    *   2. \n → MULTILINE_SEPARATOR  (F-spike-3)
    *   3. set-buffer + paste-buffer  (atomic; bracketed-paste-aware
    *      in modern claude TUI versions)
+   *   4. brief drain delay so a subsequent send-keys (e.g. Enter) is
+   *      processed as a key event by the TUI, NOT consumed as part of
+   *      the paste's bracketed-paste content.
+   *
+   * INCIDENT (0.10.0-rc.2): without the drain delay, send-keys Enter
+   * fired immediately after paste-buffer was being swallowed by
+   * claude TUI's bracketed-paste handler — the paste sat in the input
+   * area unsubmitted. Manual `tmux send-keys ... Enter` unstuck it.
+   * 80ms is enough on macOS tmux 3.6a for the close-bracket ESC[201~
+   * to land before any subsequent key arrives.
    *
-   * NO Enter is sent. Caller follows up with `sendControl(name, 'Enter')`
-   * when they want to submit. (Splitting paste + Enter lets callers
-   * verify the text landed via capture-pane before submitting.)
+   * NO Enter is sent here. Caller follows up with
+   * `sendControl(name, 'Enter')` when they want to submit.
    */
   async function pasteText(name, text) {
     const sanitized = sanitize(text);
@@ -218,6 +266,8 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
       await runFn('tmux', ['delete-buffer', '-b', bufName]).catch(() => {});
       throw err;
     }
+    // Drain delay — see incident note above.
+    await new Promise((r) => setTimeout(r, 80));
     return { sanitized, oneLine, stripped: text.length - sanitized.length };
   }
 
@@ -279,6 +329,7 @@ function createTmuxRunner({ logger = console, runFn = run } = {}) {
     spawn,
     sendControl,
     pasteText,
+    pasteAndEnter,
     capturePane,
     captureWide,
     sessionExists,

package/package.json

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