switchroom 0.19.18 → 0.19.22

package/telegram-plugin/tool-activity-summary.ts

@@ -89,6 +89,7 @@ import {
   WORKER_HISTORY_MAX,
   STATUS_LINE_MAX,
   NESTED_PREFIX,
+  WORKER_STEP_INDENT,
 } from './status-no-truncate.js'
 import { escapeMarkdown, stripMarkdown, truncate, stackCardLines } from './card-format.js'
 import { isTelegramSurfaceTool } from './tool-names.js'
@@ -297,6 +298,11 @@ function escapeStepLine(raw: string): string {
  * `allDone`    — when true ALL steps render done (✓ struck italic); when false the
  *                newest renders in-progress (→ bold)
  * `liveSuffix` — appended INSIDE the newest in-progress line (heartbeat tick)
+ * `indent`     — literal prefix put on EVERY emitted line (incl. the
+ *                `+N earlier…` header), OUTSIDE the markdown spans so it never
+ *                lands inside an emphasis run. Default `''` — byte-identical
+ *                output for callers that don't indent. The combined worker card
+ *                passes `WORKER_STEP_INDENT` to nest steps under their worker.
  */
 export function renderStepFeed(
   out: string[],
@@ -304,14 +310,19 @@ export function renderStepFeed(
   allDone: boolean,
   liveSuffix = '',
   window: number = STATUS_ROLLING_LINES,
+  indent = '',
 ): void {
   if (steps.length === 0) return
   const shown = steps.slice(-Math.max(1, window))
   const hidden = steps.length - shown.length
-  if (hidden > 0) out.push(`_✓ +${hidden} earlier…_`)
+  if (hidden > 0) out.push(`${indent}_✓ +${hidden} earlier…_`)
   const lastIdx = shown.length - 1
   shown.forEach((s, i) => {
-    out.push(!allDone && i === lastIdx ? `**→ ${s}${liveSuffix}**` : `~~_✓ ${s}_~~`)
+    out.push(
+      !allDone && i === lastIdx
+        ? `${indent}**→ ${s}${liveSuffix}**`
+        : `${indent}~~_✓ ${s}_~~`,
+    )
   })
 }
 
@@ -439,7 +450,10 @@ export function renderStatusCard(opts: StatusCardOpts): string | null {
   // Stack lines with GFM hard breaks (`  \n`) so the card's styled prose lines
   // don't collapse onto one visual line in the rich-message renderer — see
   // stackCardLines. This is what makes a card render identically to a reply.
-  const joined = stackCardLines(out)
+  // collapseSafe (#3666): the agent status card and the single-worker card are
+  // both PINNED, and Telegram's pinned bar shows them collapsed to one line
+  // with the newlines dropped — the separator keeps that preview legible.
+  const joined = stackCardLines(out, { collapseSafe: true })
   if (joined.length <= STATUS_CARD_CHAR_BUDGET) return joined
   return fitCardToBudget(opts, headerLines)
 }
@@ -492,7 +506,8 @@ function fitCardToBudget(opts: StatusCardOpts, headerLines: string[]): string {
     const lastIdx = shown.length - 1
     shown.forEach((esc, i) => lines.push(buildBullet(esc, i === lastIdx)))
     lines.push(...footerLines)
-    const candidate = stackCardLines(lines)
+    // collapseSafe: same pinned surface as renderStatusCard (#3666).
+    const candidate = stackCardLines(lines, { collapseSafe: true })
     if (candidate.length <= STATUS_CARD_CHAR_BUDGET) return candidate
   }
 
@@ -518,7 +533,7 @@ function fitCardToBudget(opts: StatusCardOpts, headerLines: string[]): string {
   if (parentMarker != null) lines.push(parentMarker)
   lines.push(newestLine)
   lines.push(...footerLines)
-  return stackCardLines(lines)
+  return stackCardLines(lines, { collapseSafe: true })
 }
 
 /**
@@ -729,18 +744,54 @@ export function combinedHistoryDepth(w: number): number {
 /** Alias for readability at the single-worker call site — same curve. */
 export const workerHistoryDepth = combinedHistoryDepth
 
+/**
+ * The combined card's first line: a SELF-CONTAINED glance at the whole swarm
+ * (#3666) — `🛠 Workers · 3 running · oldest 38m16s · 196 tools · 1.2M tok`.
+ *
+ * Two jobs, both load-bearing:
+ *
+ *   1. In the feed it answers "what is my fleet doing" without reading the
+ *      rows — the aggregate the per-row lines never showed.
+ *   2. In Telegram's pinned bar, where the card collapses to ONE line, it is
+ *      the part most likely to survive truncation, so the preview leads with
+ *      real information instead of a four-word chrome stub that ran into
+ *      row 1's ordinal (`… 3 running1. Fix issue …`).
+ *
+ * It always ends in a UNIT WORD (`running` / `oldest <elapsed>` / `tools` /
+ * `tok`), never a bare number, so the first collapse seam reads as
+ * `… · 196 tools 1. Fix issue …` — a list starting after a unit — rather than
+ * two numbers colliding. Aggregates cover ALL rows (including any spilled to
+ * `+M more working…`), matching the `N running` count beside them.
+ */
+function glanceLine(rows: CombinedWorkerRow[]): string {
+  const oldestMs = rows.reduce((m, r) => Math.max(m, r.elapsedMs), 0)
+  const tools = rows.reduce((n, r) => n + r.toolCount, 0)
+  const tok = rows.reduce((n, r) => n + (r.totalTokens ?? 0), 0)
+  const toolWord = tools === 1 ? 'tool' : 'tools'
+  return (
+    `🛠 **Workers** · _${rows.length} running · oldest ${formatFeedElapsed(oldestMs)}` +
+    ` · ${tools} ${toolWord}${tokenSegment(tok)}_`
+  )
+}
+
 /**
  * Render N≥1 live workers into ONE combined feed body (ready Telegram
  * markdown; callers send verbatim — do NOT re-escape). Layout:
  *
- *   🛠 **Workers** · _N running_
+ *   🛠 **Workers** · _N running · oldest {elapsed} · {n} tools · {t} tok_
  *   **1. {desc1}** _· {elapsed} · {n} tools_
- *   ~~_✓ {earlier step}_~~
- *   **→ {newest step}**
+ *      ~~_✓ {earlier step}_~~
+ *      **→ {newest step}**
  *   **2. {desc2}** _· {elapsed} · {n} tools_
- *   **→ {newest step}**
+ *      **→ {newest step}**
  *   _+M more working…_
  *
+ * INDENT: every step line carries a leading `WORKER_STEP_INDENT` (a U+2800 run
+ * — neither ASCII spaces nor U+00A0; Telegram left-trims BOTH, see the
+ * constant's doc comment) so the steps nest under their worker header and the
+ * per-worker blocks are scannable. Header and chrome lines stay at the left
+ * margin.
+ *
  * NUMBERING (#3298): when the card tracks 2+ rows AND a row carries `ordinal`,
  * its header gets a stable `{ordinal}. ` prefix. Ordinals are assigned by the
  * caller at dispatch and kept for the card's life — after an earlier worker
@@ -755,6 +806,15 @@ export const workerHistoryDepth = combinedHistoryDepth
  * card staying bounded regardless of fan-out. When a worker has no history yet
  * it falls back to a single `→ starting…`/currentStep line.
  *
+ * PINNED-BAR READABILITY (#3666): line 1 is a self-contained glance
+ * (`glanceLine`) and the stack is joined with `collapseSafe`, because this card
+ * is pinned and Telegram's pinned bar renders it collapsed onto ONE line with
+ * the newlines dropped and NOTHING substituted. Both halves are needed: the
+ * glance so the preview leads with information, the per-line separator so every
+ * later seam (`opus 5` → `✓ …` → `→ …`) degrades to a word gap instead of a
+ * mashed glyph. There is no Bot API for a separate pin-bar preview — the client
+ * derives it from the message text — so the text is the only lever.
+ *
  * Pure. Rows are rendered in the order supplied (the manager passes them
  * dispatch-order, oldest first). `maxRows` caps the visible rows; the hidden
  * remainder collapses to a single `+M more working…` line. A total-budget
@@ -802,13 +862,13 @@ export function renderCombinedWorkerFeed(
     // Per-worker depth follows Ken's deterministic curve max(3, 7−w) (#3349):
     // the curve drives DEPTH; the total-line budget below drives ROW COUNT.
     const depth = combinedHistoryDepth(shown.length)
-    const chrome: string[] = [`🛠 **Workers** · _${rows.length} running_`]
+    const chrome: string[] = [glanceLine(rows)]
     const bodyOut: string[] = []
     for (const r of shown) {
       bodyOut.push(rowHeader(r))
       const hist = rowHistory(r)
       if (hist.length === 0) {
-        bodyOut.push('→ _starting…_')
+        bodyOut.push(`${WORKER_STEP_INDENT}→ _starting…_`)
         continue
       }
       // Paint the last-K history lines with the SAME `✓`/`→` idiom as the
@@ -816,12 +876,24 @@ export function renderCombinedWorkerFeed(
       // pipeline (escapeStepLine), then renderStepFeed strikes the prior steps
       // and bolds the newest in-progress step. The window equals the depth so a
       // per-worker `+N earlier…` marker never appears inside the combined feed.
+      //
+      // WORKER_STEP_INDENT nests every step line one level under its worker
+      // header, so the boundary between two workers is visible at a glance on a
+      // phone (the header lines stay at the left margin, their steps sit in).
+      // It is a U+2800 run. NOT ASCII spaces and NOT U+00A0: Telegram's
+      // server-side parser left-trims a leading Unicode-whitespace run, so both
+      // render flat (#3662 shipped U+00A0 and was inert). U+2800 is category So,
+      // not Zs. See the constant's doc comment for the live evidence.
       const esc = hist.slice(-depth).map(escapeStepLine)
-      renderStepFeed(bodyOut, esc, false, '', depth)
+      renderStepFeed(bodyOut, esc, false, '', depth, WORKER_STEP_INDENT)
     }
     const out = [...chrome, ...bodyOut]
     if (hidden > 0) out.push(`_+${hidden} more working…_`)
-    return { body: stackCardLines(out), bodyLines: bodyOut.length }
+    // collapseSafe (#3666): this card is PINNED, and Telegram's pinned bar
+    // renders it collapsed to one line with the newlines dropped and nothing
+    // substituted. Without the separator the glance line runs straight into
+    // row 1's ordinal and every step glyph mashes into the previous line.
+    return { body: stackCardLines(out, { collapseSafe: true }), bodyLines: bodyOut.length }
   }
 
   // Cap to maxRows first, then shrink the visible set while EITHER the total

package/telegram-plugin/worker-activity-feed.ts

@@ -53,6 +53,7 @@ import {
   cleanWorkerResultParagraph,
   stripMarkdown,
   truncate,
+  COLLAPSE_SAFE_SEPARATOR,
 } from './card-format.js'
 import { WORKER_HISTORY_MAX } from './status-no-truncate.js'
 import {
@@ -142,6 +143,25 @@ export interface BotApiForWorkerFeed {
 /** Dispatch-time task description cap for the worker header. */
 const DESC_MAX = 80
 
+/**
+ * Repeat marker appended to a narrative step that fired more than once in a
+ * row (`Running a command ·×3`). Rendered inline on the step line so a worker
+ * whose every step carries the SAME label still visibly advances instead of
+ * freezing the card. `·` is already the card's separator glyph.
+ */
+const REPEAT_SUFFIX_RE = / ·×(\d+)$/
+
+/** The step text without its `·×N` marker (identity for dedup comparisons). */
+export function stripRepeatSuffix(line: string): string {
+  return line.replace(REPEAT_SUFFIX_RE, '')
+}
+
+/** How many times a step line has fired: 1 when it carries no marker. */
+export function repeatCountOf(line: string): number {
+  const m = REPEAT_SUFFIX_RE.exec(line)
+  return m == null ? 1 : Number(m[1])
+}
+
 /**
  * Thin adapter over the unified `renderStatusCard` primitive (emoji 🛠, label
  * 'Worker'): builds the header, passes raw narrative steps (the primitive runs
@@ -226,7 +246,10 @@ export function renderWorkerActivity(v: WorkerActivityView, liveSuffix = ''): st
     // Header-only running render → append the starting placeholder with a GFM
     // hard break (`  \n`) so it stacks under the header instead of collapsing
     // onto the header line in the rich-message renderer (matches stackCardLines).
-    return `${card}  \n_starting…_`
+    // The collapse separator is carried here too (#3666) — this card is pinned,
+    // and a hand-rolled seam would be the one boundary that still mashed in
+    // Telegram's pinned bar.
+    return `${card}${COLLAPSE_SAFE_SEPARATOR}  \n_starting…_`
   }
   return card
 }
@@ -428,6 +451,13 @@ interface WorkerRow {
    * live render so the feed reads like the main agent's answer.
    */
   narrative: string[]
+  /**
+   * `view.toolCount` observed when the newest narrative step was last recorded
+   * or counted. The repeat counter (`·×N`) increments only when toolCount has
+   * MOVED — the watcher re-emits an unchanged view every tick, so counting
+   * label-equality alone would inflate the number with no work behind it.
+   */
+  lastNarrativeToolCount: number | null
   /** Last view for this worker (drives the heartbeat re-render + combined row). */
   lastView: WorkerActivityView | null
   /** Latest state observed for this worker; excluded from the running set once
@@ -794,10 +824,33 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
   function accumulateNarrative(row: WorkerRow, view: WorkerActivityView): void {
     const line = view.latestSummary.trim()
     if (line.length === 0) return
+
+    // A REPEAT of the current step is counted, not dropped. A worker whose
+    // steps all render the same label (e.g. Bash calls with no description →
+    // "Running a command") used to hit the dedup below on every tool call and
+    // the card held ONE frozen line for the whole job — indistinguishable from
+    // a wedged worker. `·×N` makes the repetition visible and, because a new
+    // count resets stepStartedAtMs, the climbing `· Ns` step timer restarts
+    // with each real call.
+    //
+    // Gated on `view.toolCount`, NOT on the label: the watcher re-emits an
+    // UNCHANGED view on every tick, so counting label-equality alone would
+    // inflate the number with no work behind it. One increment per observed
+    // tool call, deterministically.
+    const last = row.narrative.length > 0 ? row.narrative[row.narrative.length - 1] : null
+    if (last != null && stripRepeatSuffix(last) === line) {
+      if (view.toolCount === row.lastNarrativeToolCount) return
+      row.lastNarrativeToolCount = view.toolCount
+      row.narrative[row.narrative.length - 1] = `${line} ·×${repeatCountOf(last) + 1}`
+      row.stepStartedAtMs = nowFn()
+      return
+    }
+
     // Dedup within the whole rolling window (the watcher re-emits the same
     // narrative across ticks, and a preamble + its tool label can repeat
     // non-adjacently — the A,B,A duplication observed on live cards).
-    if (row.narrative.includes(line)) return
+    if (row.narrative.some((l) => stripRepeatSuffix(l) === line)) return
+    row.lastNarrativeToolCount = view.toolCount
     row.narrative.push(line)
     // The `→` current-step line just CHANGED — reset the per-step timer.
     row.stepStartedAtMs = nowFn()
@@ -1545,6 +1598,7 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
           agentId,
           ordinal: ++g.workerOrdinalCounter,
           narrative: [],
+          lastNarrativeToolCount: null,
           lastView: null,
           state: 'running',
           finished: false,