@link-assistant/hive-mind 1.77.1 → 1.78.0

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @link-assistant/hive-mind
 
+## 1.78.0
+
+### Minor Changes
+
+- 9506f03: fix(telegram): de-duplicate `/queue` display and split long messages without breaking markdown (#1891)
+
+  The `/queue` (alias `/solve_queue`) detailed display repeated the same words on every
+  line — every executing row said `(processing, …)`, every waiting row said
+  `(waiting, …)`, and the (almost always identical) per-item waiting reason was printed
+  once per item. Empty queues were also still printed. This wasted vertical space and
+  pushed real data off screen.
+
+  Display changes (`formatDetailedStatus` + queue helpers):
+  - Executing rows now render compactly as `• owner/repo#number (▶️ <dur>)` and pending
+    rows as `• owner/repo#number (⏳ <dur>)` — the status word is replaced by the emoji
+    marker inside the duration parenthesis.
+  - Processing, pending, completed, and failed entries are split into distinct
+    compact lists per tool, with counts only on those list labels instead of a
+    duplicated `(pending: n, processing: n)` tool-header summary.
+  - The shared waiting reason is shown **once per tool** (only when all pending items
+    agree on it) instead of once per item.
+  - Empty queues are skipped entirely.
+  - All queued items are listed (no per-queue truncation on the active lists).
+
+  Message-splitting changes (`splitTelegramMessageText` in `telegram-safe-reply.lib.mjs`,
+  the single universal splitter every Telegram send path funnels through):
+  - Splitting now happens only on line boundaries, so inline Markdown entities
+    (bold/italic/links) are never cut in half.
+  - Fenced code blocks stay balanced per chunk: a split inside a code block closes the
+    fence at the end of one chunk and reopens it — repeating the language — at the start
+    of the next. The original fence marker (```vs`~~~`) and indentation are preserved.
+  - Pathologically long single lines are hard-split as a fallback.
+
+  Both behaviours are covered by extensive new tests
+  (`tests/test-telegram-message-split-1891.mjs`, `tests/test-queue-compact-display-1891.mjs`).
+
 ## 1.77.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.77.1",
+  "version": "1.78.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/telegram-safe-reply.lib.mjs

@@ -61,27 +61,129 @@ function findTelegramSplitIndex(text, limit) {
   return limit;
 }
 
+// A Markdown fenced code block opens/closes with ``` or ~~~ (optionally indented
+// and, on the opening fence, followed by a language/info string). We track these
+// so a split that lands inside a code block can close the fence on the current
+// chunk and reopen it — repeating the language — on the next one (issue #1891).
+const CODE_FENCE_RE = /^(\s*)(```+|~~~+)(.*)$/;
+
+/**
+ * Parse a single line as a Markdown code-fence delimiter.
+ *
+ * @param {string} line
+ * @returns {{indent: string, marker: string, info: string}|null}
+ *   The fence parts, or `null` when the line is not a fence.
+ */
+export function parseCodeFence(line) {
+  const match = CODE_FENCE_RE.exec(line);
+  if (!match) return null;
+  return { indent: match[1], marker: match[2], info: match[3].trim() };
+}
+
+/**
+ * Hard-split a single physical line that is itself longer than `limit` into
+ * pieces that each fit, preferring a break at a natural separator near the end
+ * and falling back to a hard character cut. Used only for pathologically long
+ * lines (normal queue/help lines are short).
+ *
+ * @param {string} line
+ * @param {number} limit
+ * @returns {string[]}
+ */
+function splitLongLine(line, limit) {
+  const pieces = [];
+  let remaining = line;
+  while (remaining.length > limit) {
+    let splitAt = findTelegramSplitIndex(remaining, limit);
+    if (splitAt <= 0 || splitAt > limit) splitAt = limit;
+    let piece = remaining.slice(0, splitAt);
+    if (!piece.trim()) {
+      splitAt = limit;
+      piece = remaining.slice(0, splitAt);
+    }
+    pieces.push(piece);
+    remaining = remaining.slice(splitAt);
+  }
+  if (remaining) pieces.push(remaining);
+  return pieces;
+}
+
+/**
+ * Split a (possibly oversized) Telegram message into chunks that each stay
+ * within `limit` characters.
+ *
+ * Splitting happens on line boundaries so inline Markdown entities (bold,
+ * italic, links — none of which may span a newline in Telegram's legacy
+ * Markdown) are never cut in half. Fenced code blocks, which *do* span lines,
+ * are kept valid across the split: when a break lands inside a code block the
+ * current chunk gets a closing fence appended and the next chunk re-opens the
+ * fence with the same marker and language (issue #1891).
+ *
+ * @param {string} text
+ * @param {number} [limit=TELEGRAM_TEXT_LIMIT]
+ * @returns {string[]} One or more chunks; always at least one element.
+ */
 export function splitTelegramMessageText(text, limit = TELEGRAM_TEXT_LIMIT) {
   const source = String(text ?? '');
   if (source.length <= limit) return [source];
 
+  // Reserve headroom on each physical line for a possible fence reopen/close
+  // pair so re-wrapping a code block never pushes a chunk past the limit.
+  const FENCE_HEADROOM = 16;
+  const lineLimit = Math.max(1, limit - FENCE_HEADROOM);
+
+  // Expand into physical lines, pre-splitting any line that alone exceeds the
+  // budget so the chunker below only ever deals with lines that fit.
+  const lines = [];
+  for (const raw of source.split('\n')) {
+    if (raw.length <= lineLimit) lines.push(raw);
+    else lines.push(...splitLongLine(raw, lineLimit));
+  }
+
   const chunks = [];
-  let remaining = source;
+  let current = '';
+  let openFence = null; // { indent, marker, info } while inside a code block
 
-  while (remaining.length > limit) {
-    let splitAt = findTelegramSplitIndex(remaining, limit);
-    let chunk = remaining.slice(0, splitAt).trimEnd();
+  const closeFenceLine = () => `${openFence.indent}${openFence.marker}`;
+  const reopenFenceLine = () => `${openFence.indent}${openFence.marker}${openFence.info}`;
 
-    if (!chunk) {
-      splitAt = limit;
-      chunk = remaining.slice(0, splitAt);
+  const flush = () => {
+    let chunk = current;
+    if (openFence) {
+      // Close the still-open code block at the end of this chunk.
+      chunk = chunk.length ? `${chunk}\n${closeFenceLine()}` : closeFenceLine();
     }
-
     chunks.push(chunk);
-    remaining = remaining.slice(splitAt).trimStart();
+    // Re-open the fence at the start of the next chunk so the code block (and
+    // its language) continues seamlessly.
+    current = openFence ? reopenFenceLine() : '';
+  };
+
+  for (const line of lines) {
+    const separatorLength = current.length ? 1 : 0;
+    const closeReserve = openFence ? closeFenceLine().length + 1 : 0;
+    const projected = current.length + separatorLength + line.length + closeReserve;
+
+    if (current.length > 0 && projected > limit) {
+      flush();
+    }
+
+    current = current.length ? `${current}\n${line}` : line;
+
+    const fence = parseCodeFence(line);
+    if (fence) {
+      // A fence line toggles code-block state: open when outside, close when
+      // already inside.
+      openFence = openFence ? null : fence;
+    }
+  }
+
+  // Defensive: close any fence left open by unbalanced input.
+  if (openFence && current.length) {
+    current = `${current}\n${closeFenceLine()}`;
   }
+  if (current.length || chunks.length === 0) chunks.push(current);
 
-  if (remaining) chunks.push(remaining);
   return chunks;
 }
 

package/src/telegram-solve-queue.helpers.lib.mjs

@@ -50,18 +50,18 @@ export function formatQueueItemLink(url) {
  * @param {boolean} [opts.withError] - Append `— error` when the item failed.
  * @returns {string} The formatted section (empty string when no items).
  */
-export function formatQueueHistorySection({ items, emoji, label, max, locale, withError = false }) {
+export function formatQueueHistorySection({ items, emoji, label, max, locale, withError = false, indent = '' }) {
   if (!items || items.length === 0) return '';
-  let section = `*${label}* (${items.length}):\n`;
+  let section = `${indent}*${label}* (${items.length}):\n`;
   for (const item of [...items].reverse().slice(0, max)) {
-    section += `  ${emoji} ${formatQueueItemLink(item.url)}`;
+    section += `${indent}  ${emoji} ${formatQueueItemLink(item.url)}`;
     if (withError && item.error) section += ` — ${item.error}`;
     section += '\n';
   }
   if (items.length > max) {
-    section += `    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+    section += `${indent}    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
   }
-  return `${section}\n`;
+  return section;
 }
 
 /**
@@ -128,25 +128,128 @@ export function collectExecutingItems({ processingItems = [], sessionItems = [],
 }
 
 /**
- * Render the per-tool "executing" lines (`▶️ link (status, elapsed)`) for the
- * detailed queue status, capped at `max` items with a localized "... and N more"
- * line (issue #1837).
+ * Render the per-tool "executing" lines for the detailed queue status as a
+ * compact, de-duplicated list (issue #1891):
+ *
+ *   `• owner/repo#number (▶️ 2h 14m 16s)`
+ *
+ * The ▶️ emoji replaces the repeated literal "processing" status word that
+ * appeared on every line in the old format. Items are listed in full by
+ * default; pass a finite `max` to cap them with a localized "... and N more"
+ * line.
  *
  * @param {object} opts
  * @param {Array} opts.items - Output of {@link collectExecutingItems}.
- * @param {number} opts.max - Maximum items to list before collapsing.
+ * @param {number} [opts.max=Infinity] - Maximum items before collapsing.
+ * @param {string|null} opts.locale - Locale for labels/durations.
+ * @param {string} [opts.label] - Optional sub-list heading (e.g. "Processing").
+ *   When set, a `  *Label* (count):` header is rendered above the items so each
+ *   status gets its own clearly-labeled list (issue #1891 follow-up).
+ * @returns {string} The formatted lines (empty string when no items).
+ */
+export function formatQueueExecutingItems({ items, max = Infinity, locale, label }) {
+  if (!items || items.length === 0) return '';
+  // Items nest one level under their section label when labeled (issue #1891).
+  const itemIndent = label ? '    ' : '  ';
+  let out = label ? `  *${label}* (${items.length}):\n` : '';
+  for (const item of items.slice(0, max)) {
+    out += `${itemIndent}• ${formatQueueItemLink(item.url)} (▶️ ${formatDuration(item.waitMs, { locale })})\n`;
+  }
+  if (items.length > max) {
+    out += `${itemIndent}  ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+  }
+  return out;
+}
+
+/**
+ * Backwards-compatible alias for {@link formatQueueExecutingItems}.
+ * @deprecated Use {@link formatQueueExecutingItems}.
+ */
+export const formatQueueProcessingItems = formatQueueExecutingItems;
+
+/**
+ * Group queue history items (completed/failed) by their `tool` key so each tool
+ * queue can render its own Completed/Failed list (issue #1891 follow-up).
+ *
+ * @param {Array<{tool?: string}>} items
+ * @returns {Object<string, Array>} Map of tool key → items.
+ */
+export function groupQueueItemsByTool(items) {
+  const byTool = {};
+  for (const item of items || []) {
+    const tool = item.tool || 'claude';
+    (byTool[tool] ||= []).push(item);
+  }
+  return byTool;
+}
+
+/**
+ * Render one tool queue's block for the detailed status as a set of *separate,
+ * individually-labeled lists* — Processing, Pending, Completed, Failed — instead
+ * of one merged bullet list (issue #1891 follow-up). Empty lists are omitted.
+ *
+ * @param {object} opts
+ * @param {string} opts.tool - Tool key (header label).
+ * @param {Array} opts.executing - Output of {@link collectExecutingItems}.
+ * @param {Array} opts.pendingItems - `{url, waitMs, waitingReason}` per pending item.
+ * @param {Array} opts.completed - Completed history items for this tool.
+ * @param {Array} opts.failed - Failed history items for this tool.
+ * @param {object} opts.labels - Localized labels (`pendingLower`, `processingLower`,
+ *   `pending`, `processing`, `completed`, `failed`).
+ * @param {number} opts.max - Max history items before the "… and N more" collapse.
+ * @param {string|null} opts.locale - Locale for labels/durations.
+ * @returns {string} The formatted block (with a trailing blank line).
+ */
+export function formatQueueToolSection({ tool, executing, pendingItems, completed, failed, labels, max, locale }) {
+  let block = `*${tool}*\n`;
+
+  // Processing list.
+  block += formatQueueExecutingItems({ items: executing, locale, label: labels.processing });
+
+  // Pending list + the shared waiting reason once (when all items agree on it).
+  block += formatQueuePendingItems({ items: pendingItems, locale, label: labels.pending });
+  const distinctReasons = [...new Set(pendingItems.map(item => item.waitingReason).filter(Boolean))];
+  if (distinctReasons.length === 1) {
+    block += `    ⏳ ${distinctReasons[0].replace(/\n+/g, '; ')}\n`;
+  }
+
+  // Completed / Failed lists for this tool (most-recent-first, capped), indented
+  // so the label sits under the tool header and items under it.
+  block += formatQueueHistorySection({ items: completed, emoji: '✅', label: labels.completed, max, locale, indent: '  ' });
+  block += formatQueueHistorySection({ items: failed, emoji: '❌', label: labels.failed, max, locale, withError: true, indent: '  ' });
+
+  return `${block}\n`;
+}
+
+/**
+ * Render the per-tool "pending/waiting" lines for the detailed queue status as a
+ * compact list (issue #1891):
+ *
+ *   `• owner/repo#number (⏳ 5m 2s)`
+ *
+ * The per-item waiting *reason* is deliberately omitted here — it is almost
+ * always identical across pending items, so the caller shows it once for the
+ * whole tool instead of repeating it on every line.
+ *
+ * @param {object} opts
+ * @param {Array<{url: string, waitMs: number}>} opts.items - Pending items.
+ * @param {number} [opts.max=Infinity] - Maximum items before collapsing.
  * @param {string|null} opts.locale - Locale for labels/durations.
+ * @param {string} [opts.label] - Optional sub-list heading (e.g. "Pending").
+ *   When set, a `  *Label* (count):` header is rendered above the items so each
+ *   status gets its own clearly-labeled list (issue #1891 follow-up).
  * @returns {string} The formatted lines (empty string when no items).
  */
-export function formatQueueProcessingItems({ items, max, locale }) {
+export function formatQueuePendingItems({ items, max = Infinity, locale, label }) {
   if (!items || items.length === 0) return '';
-  let out = '';
+  // Items nest one level under their section label when labeled (issue #1891).
+  const itemIndent = label ? '    ' : '  ';
+  let out = label ? `  *${label}* (${items.length}):\n` : '';
   for (const item of items.slice(0, max)) {
-    const label = item.queueStatus ? lt(`queue_status_${item.queueStatus}`, {}, { locale }) : lt('queue_processing', {}, { locale });
-    out += `  ▶️ ${formatQueueItemLink(item.url)} (${label}, ${formatDuration(item.waitMs, { locale })})\n`;
+    out += `${itemIndent}• ${formatQueueItemLink(item.url)} (⏳ ${formatDuration(item.waitMs, { locale })})\n`;
   }
   if (items.length > max) {
-    out += `    ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
+    out += `${itemIndent}  ... ${lt('queue_and_more', { count: items.length - max }, { locale })}\n`;
   }
   return out;
 }

package/src/telegram-solve-queue.lib.mjs

@@ -17,7 +17,7 @@
 
 import { getCachedClaudeLimits, getCachedCodexLimits, getCachedGitHubLimits, getCachedMemoryInfo, getCachedCpuInfo, getCachedDiskInfo, getLimitCache } from './limits.lib.mjs';
 export { formatDuration, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses } from './telegram-solve-queue.helpers.lib.mjs';
-import { collectExecutingItems, formatDuration, formatQueueHistorySection, formatQueueItemLink, formatQueueProcessingItems, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses, getRunningSessionItems } from './telegram-solve-queue.helpers.lib.mjs';
+import { collectExecutingItems, formatDuration, formatQueueToolSection, formatWaitingReason, getRunningAgentProcesses, getRunningClaudeProcesses, getRunningCodexProcesses, getRunningGeminiProcesses, getRunningProcesses, getRunningQwenProcesses, getRunningSessionItems, groupQueueItemsByTool } from './telegram-solve-queue.helpers.lib.mjs';
 export { QUEUE_CONFIG, THRESHOLD_STRATEGIES } from './queue-config.lib.mjs';
 import { QUEUE_CONFIG } from './queue-config.lib.mjs';
 import { formatExecutingWorkSessionMessage, formatStartingWorkSessionMessage } from './work-session-formatting.lib.mjs';
@@ -46,10 +46,6 @@ function appendRemainingDuration(reason, ms, locale) {
   return `${reason} (${lt('remaining', { duration: formatDuration(ms, { locale }) }, { locale })})`;
 }
 
-function queueStatusLabel(status, locale) {
-  return lt(`queue_status_${status}`, {}, { locale });
-}
-
 /**
  * Queue item representing a /solve command request
  */
@@ -1324,65 +1320,63 @@ export class SolveQueue {
 
   /**
    * Format detailed queue status for Telegram message.
-   * Groups output by tool queue (clickable links per item), then lists the
-   * Completed and Failed history as clickable links, capped per section.
    *
-   * Processing count = max(actual AI CLI processes via pgrep, tracked
-   * `$ --status` executing screen-isolated sessions), not queue state.
+   * Each tool queue renders as a set of *separate, individually-labeled lists* —
+   * Processing, Pending, Completed, Failed — instead of one merged bullet list
+   * (issue #1891). Empty lists (and fully-empty tool queues) are skipped, items
+   * render as compact `• link (emoji dur)` rows, and the shared waiting reason
+   * is shown once per tool.
    *
    * @returns {Promise<string>}
-   * @see https://github.com/link-assistant/hive-mind/issues/1159
    * @see https://github.com/link-assistant/hive-mind/issues/1267
    * @see https://github.com/link-assistant/hive-mind/issues/1837
+   * @see https://github.com/link-assistant/hive-mind/issues/1891
    */
   async formatDetailedStatus(options = {}) {
     const locale = getLocale(options);
     const stats = this.getStats();
-    const externalProcessing = await this.getExternalProcessingSnapshot(Object.keys(this.queues));
     // Currently-executing detached sessions (with issue/PR URLs). These are the
     // real running tasks; the queue's own `processing` Map is emptied once a task
     // is dispatched, so without this the executing items are never listed (#1837).
     const runningSessionItems = await this.getRunningSessionItemsFn(this.verbose);
 
-    // Get actual processing counts for each tool queue.
-    // This combines pgrep with tracked isolation status so users see detached
-    // screen-isolated work even when the direct AI CLI process count is lower.
+    // Section labels: each per-tool sub-list uses a capitalized heading.
+    const cap = s => (s ? s.charAt(0).toUpperCase() + s.slice(1) : s);
+    const labels = {
+      pending: cap(lt('queue_pending', {}, { locale })),
+      processing: cap(lt('queue_processing', {}, { locale })),
+      completed: cap(lt('queue_completed', {}, { locale })),
+      failed: cap(lt('queue_failed', {}, { locale })),
+    };
+
+    // Group the (globally-capped) completed/failed history by tool so each tool
+    // queue shows its own Completed/Failed list (issue #1891 follow-up).
+    const completedByTool = groupQueueItemsByTool(this.completed);
+    const failedByTool = groupQueueItemsByTool(this.failed);
+
     let message = `📋 *${lt('solve_queue_status', {}, { locale })}*\n\n`;
+    const max = QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE;
 
-    // Show per-tool queue breakdown with items grouped by queue
-    for (const [tool, toolQueue] of Object.entries(this.queues)) {
-      const pending = toolQueue.length;
-      const processing = externalProcessing.byTool[tool] || 0;
-      message += `*${tool}* (${lt('queue_pending', {}, { locale })}: ${pending}, ${lt('queue_processing', {}, { locale })}: ${processing})\n`;
+    // Every tool with *any* activity (queued, processing, or in history) so
+    // per-tool history shows even after a tool's live queue has drained.
+    const tools = [...new Set([...Object.keys(this.queues), ...Object.keys(completedByTool), ...Object.keys(failedByTool)])];
 
-      // List the tasks this tool is actively executing as clickable links. We
-      // merge the queue's in-memory processing Map with the externally-tracked
-      // running sessions (detached screen/isolation work), deduped by URL, so
-      // executing tasks are listed even after dispatch (issue #1837).
+    for (const tool of tools) {
+      const toolQueue = this.queues[tool] || [];
+      const pending = toolQueue.length;
+      // Executing tasks: merge the in-memory processing Map with tracked
+      // detached sessions, deduped by URL, so they list even after dispatch
+      // (issue #1837).
       const executing = collectExecutingItems({ processingItems: this.processing.values(), sessionItems: runningSessionItems, tool });
-      message += formatQueueProcessingItems({ items: executing, max: QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE, locale });
-
-      // Show first queued items for this tool with clickable links
-      const displayItems = toolQueue.slice(0, QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE);
-      for (const item of displayItems) {
-        const waitTime = formatDuration(item.getWaitTime(), { locale });
-        message += `  • ${formatQueueItemLink(item.url)} (${queueStatusLabel(item.status, locale)}, ${waitTime})\n`;
-        if (item.waitingReason) {
-          message += `    └ ${item.waitingReason}\n`;
-        }
-      }
-      if (toolQueue.length > QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE) {
-        message += `    ... ${lt('queue_and_more', { count: toolQueue.length - QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE }, { locale })}\n`;
-      }
+      const completed = completedByTool[tool] || [];
+      const failed = failedByTool[tool] || [];
 
-      message += '\n';
-    }
+      // Skip tools with nothing to show in any list.
+      if (pending === 0 && executing.length === 0 && completed.length === 0 && failed.length === 0) continue;
 
-    // Completed / Failed lists - clickable links to the executed issues/PRs,
-    // most-recent-first so the newest results are easy to find (issue #1837).
-    const max = QUEUE_CONFIG.MAX_DISPLAY_ITEMS_PER_QUEUE;
-    message += formatQueueHistorySection({ items: this.completed, emoji: '✅', label: lt('queue_completed', {}, { locale }), max, locale });
-    message += formatQueueHistorySection({ items: this.failed, emoji: '❌', label: lt('queue_failed', {}, { locale }), max, locale, withError: true });
+      const pendingItems = toolQueue.map(item => ({ url: item.url, waitMs: item.getWaitTime(), waitingReason: item.waitingReason }));
+      message += formatQueueToolSection({ tool, executing, pendingItems, completed, failed, labels, max, locale });
+    }
 
     // Summary stats
     message += `${lt('queue_completed', {}, { locale })}: ${stats.completed}, ${lt('queue_failed', {}, { locale })}: ${stats.failed}\n`;