switchroom 0.16.47 → 0.17.0

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -14,6 +14,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
 import {
   decideTurnFlush,
   isSilentFlushMarker,
@@ -21,6 +22,20 @@ import {
   endsWithSilentMarker,
   isTurnFlushSafetyEnabled,
 } from '../turn-flush-safety.js'
+// Rich-message send-path primitives (Bot API 10.1, #2669/#2692). The #2798
+// regression suite below reconstructs the exact gateway turn-flush render
+// pipeline from these so it pins end-to-end behaviour, not just the pure
+// decision function.
+import {
+  repairEscapedWhitespace,
+  normalizeParagraphBreaks,
+  normalizePunctuation,
+  stripExcessBold,
+  addParagraphSpacers,
+  splitMarkdownChunks,
+  PARAGRAPH_SPACER,
+  RICH_MESSAGE_MAX_CHARS,
+} from '../format.js'
 
 describe('isCompositeSilentNoise — Stop-hook re-prompt leak backstop', () => {
   it('suppresses the observed leak "Sent.\\nNO_REPLY\\nNO_REPLY"', () => {
@@ -109,6 +124,209 @@ describe('decideTurnFlush — prose+trailing-sentinel is suppressed, not leaked
   })
 })
 
+// ---------------------------------------------------------------------------
+// #2798 — turn-flush must render multiple WHOLE assistant text blocks with
+// paragraph separation, not a collapsed wall-of-text. This suite reconstructs
+// the real gateway turn-flush render pipeline (post-#2669 rich-markdown path):
+//   decideTurnFlush -> join('\n\n')
+//   -> repairEscapedWhitespace -> normalizeParagraphBreaks
+//   -> addParagraphSpacers -> splitMarkdownChunks -> sendRichMessage
+// so it pins the end-to-end fix, not just the pure decision. The corpus is a
+// REAL captured-transcript shape (three separate content[i].text blocks, one
+// stored UNTRIMMED with a trailing '\n' exactly as session-tail.ts pushes
+// them), NOT a hand-authored ['para A','para B'] that would pass by
+// construction regardless of the join separator.
+// ---------------------------------------------------------------------------
+describe('#2798 turn-flush block separation — real multi-block transcript shape', () => {
+  const realBlocks = [
+    "I've finished reviewing the three files you flagged.",
+    // Untrimmed: a real assistant text block keeps its trailing newline
+    // (session-tail.ts drops only empty/whitespace-only blocks). This is the
+    // "join('\\n\\n') on a block already ending in '\\n' stacks 3 newlines"
+    // case the design note calls out.
+    'The `auth` handler looks correct. The token-refresh path has a race, ' +
+      'though: two concurrent requests can both trigger a refresh and the ' +
+      'second clobbers the first.\n',
+    'Want me to open a PR with the mutex fix, or would you rather patch it ' +
+      'inline first?',
+  ]
+
+  // Mirror the gateway turn-flush send pipeline exactly.
+  function renderLikeTurnFlush(blocks: string[]): string {
+    const d = decideTurnFlush({ chatId: '12345', replyCalled: false, capturedText: blocks })
+    expect(d.kind).toBe('flush')
+    const joined = (d as { kind: 'flush'; text: string }).text
+    const normalized = normalizeParagraphBreaks(repairEscapedWhitespace(joined))
+    return addParagraphSpacers(normalized)
+  }
+
+  it('separates whole blocks with a visible paragraph gap, not a wall-of-text', () => {
+    const out = renderLikeTurnFlush(realBlocks)
+    // Every block's content survives.
+    expect(out).toContain("I've finished reviewing")
+    expect(out).toContain('The `auth` handler looks correct')
+    expect(out).toContain('Want me to open a PR')
+    // The wall-of-text failure mode glues two blocks one '\n' apart. Assert the
+    // boundary carries a real paragraph break with the injected visible spacer
+    // line (#2692 rich-path spacer), and NOT a single-newline join.
+    expect(out).toContain(`\n\n${PARAGRAPH_SPACER}\n\n`)
+    expect(out).not.toContain('flagged.\nThe `auth`')
+    // A spacer sits specifically between block 1 and block 2.
+    const b1 = out.indexOf('flagged.')
+    const b2 = out.indexOf('The `auth` handler')
+    expect(out.slice(b1, b2)).toContain(PARAGRAPH_SPACER)
+  })
+
+  it('collapses the untrimmed-trailing-newline stack — no 3+ newline run reaches the wire', () => {
+    const out = renderLikeTurnFlush(realBlocks)
+    // Block 2's trailing '\n' + the '\n\n' join = 3 newlines; normalize
+    // collapses 3+ runs to '\n\n' and addParagraphSpacers wedges exactly one
+    // spacer, so no doubled/stacked blank run survives.
+    expect(out).not.toMatch(/\n{3,}/)
+    // One spacer per block transition: 3 blocks → 2 gaps → 2 spacers.
+    const spacerCount = out.split(PARAGRAPH_SPACER).length - 1
+    expect(spacerCount).toBe(2)
+  })
+
+  it('the whole separated answer stays in one rich chunk here (well under 32768)', () => {
+    const out = renderLikeTurnFlush(realBlocks)
+    const chunks = splitMarkdownChunks(out, RICH_MESSAGE_MAX_CHARS)
+    expect(chunks.length).toBe(1)
+    expect(chunks[0]).toContain(PARAGRAPH_SPACER)
+  })
+
+  it('still SUPPRESSES a real transcript that deliberately terminates with a bare NO_REPLY (#2053 guard intact)', () => {
+    // Same real prose shape, but the model closed with NO_REPLY as its final
+    // block (intentional silence). The '\n\n' join must NOT defeat the
+    // trailing-marker guard.
+    const d = decideTurnFlush({
+      chatId: '12345',
+      replyCalled: false,
+      capturedText: [
+        'Reviewed the overnight digest. Nothing needs your attention: all ' +
+          'three checks are green and the backup completed at 04:12.',
+        'NO_REPLY',
+      ],
+    })
+    expect(d).toEqual({ kind: 'skip', reason: 'silent-marker' })
+  })
+
+  it('still SUPPRESSES the composite silent-noise blob under the new join', () => {
+    const d = decideTurnFlush({
+      chatId: '12345',
+      replyCalled: false,
+      capturedText: ['Sent.', 'NO_REPLY', 'NO_REPLY'],
+    })
+    expect(d).toEqual({ kind: 'skip', reason: 'silent-marker' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// #2798 reply-parity follow-up — the turn-flush normalization chain must apply
+// the SAME steps in the SAME order as executeReply, so a backstop-delivered
+// answer renders byte-for-byte like the identical text sent via `reply`. Reply
+// runs (gateway executeReply):
+//   repairEscapedWhitespace -> normalizeParagraphBreaks -> redactOutboundText
+//   -> stripExcessBold(normalizePunctuation) -> scrubVoice
+//   -> addParagraphSpacers (send side)
+// The original #2798 change gave turn-flush the paragraph steps + redact +
+// scrub + spacers but OMITTED `stripExcessBold(normalizePunctuation(...))`.
+// This suite reconstructs the deterministic format chain of BOTH paths (the
+// runtime-only redact + voice-scrub steps are literally the same calls on both
+// paths and are out of scope here) and pins that turn-flush now matches reply
+// on an input that exercises the two added steps: unicode bullets + a spaced
+// en-/em-dash (normalizePunctuation) and an over-bolded prose block
+// (stripExcessBold).
+// ---------------------------------------------------------------------------
+describe('#2798 turn-flush punctuation/bold parity with reply', () => {
+  // SOURCE-STRUCTURAL guard (house pattern: gateway-outbound-redact.test.ts
+  // reads gateway.ts source and asserts the relative position of calls).
+  //
+  // The reply-parity contract is that the turn_flush backstop applies the SAME
+  // `stripExcessBold(normalizePunctuation(...))` normalization the reply path
+  // applies, in the SAME slot — after redactOutboundText, before scrubVoice.
+  //
+  // A prior version of this suite "guarded" that contract by defining two
+  // BYTE-IDENTICAL local functions (replyFormatChain / turnFlushFormatChain)
+  // and asserting `toBe` between them. That was tautological: the two locals
+  // were equal by construction regardless of what gateway.ts did, so deleting
+  // the normalization line from the turn_flush branch reddened NO test. The
+  // assertions below instead read the gateway source and pin the actual call
+  // ordering, so removing the `stripExcessBold(normalizePunctuation(capturedText))`
+  // line from the turn_flush branch REDS this suite — which is the exact
+  // regression #2798/#2813 shipped to prevent.
+  const gatewaySrc = readFileSync(
+    new URL('../gateway/gateway.ts', import.meta.url),
+    'utf8',
+  )
+
+  it('reply path: normalizes AFTER redact and BEFORE the voice scrub', () => {
+    const start = gatewaySrc.indexOf('async function executeReply(')
+    const redactIdx = gatewaySrc.indexOf(`redactOutboundText(text, 'reply')`, start)
+    const normIdx = gatewaySrc.indexOf('stripExcessBold(normalizePunctuation(text))', start)
+    const scrubIdx = gatewaySrc.indexOf('scrubVoice(text)', start)
+    expect(start).toBeGreaterThan(0)
+    expect(redactIdx).toBeGreaterThan(start)
+    expect(normIdx).toBeGreaterThan(redactIdx) // normalize AFTER the reply redact
+    expect(scrubIdx).toBeGreaterThan(normIdx) // ...and BEFORE the voice scrub
+  })
+
+  it('turn-flush backstop: applies the SAME normalization in the SAME slot (REDS if the line is removed)', () => {
+    const redactIdx = gatewaySrc.indexOf(`redactOutboundText(capturedText, 'turn_flush')`)
+    // The normalization call the reply path uses, verbatim, on the turn_flush
+    // variable. This indexOf is what returns -1 (→ assertion fails) if the
+    // `stripExcessBold(normalizePunctuation(capturedText))` line is deleted
+    // from the turn_flush branch.
+    const normIdx = gatewaySrc.indexOf('stripExcessBold(normalizePunctuation(capturedText))', redactIdx)
+    const scrubIdx = gatewaySrc.indexOf('scrubVoice(capturedText)', redactIdx)
+    expect(redactIdx).toBeGreaterThan(0)
+    expect(normIdx).toBeGreaterThan(redactIdx) // normalize AFTER the turn_flush redact
+    expect(scrubIdx).toBeGreaterThan(normIdx) // ...and BEFORE the voice scrub — mirrors reply
+  })
+
+  it('both send sites share the identical `stripExcessBold(normalizePunctuation(` wrapper', () => {
+    // Parity, structurally: the exact normalization wrapper the reply path uses
+    // is the one the turn_flush branch uses — same call, not a lookalike.
+    expect(gatewaySrc).toContain('stripExcessBold(normalizePunctuation(text))')
+    expect(gatewaySrc).toContain('stripExcessBold(normalizePunctuation(capturedText))')
+  })
+
+  // Behavioural coverage (kept from the original suite): reconstruct the
+  // deterministic format chain both sites apply and assert the REAL
+  // strip/normalize behaviour the added step provides — the over-bold block is
+  // stripped, unicode bullets become GFM list items, dashes are normalized.
+  function formatChain(text: string): string {
+    let t = normalizeParagraphBreaks(repairEscapedWhitespace(text))
+    t = stripExcessBold(normalizePunctuation(t))
+    return addParagraphSpacers(t)
+  }
+
+  const input =
+    '**This whole paragraph is bolded and is deliberately long enough to ' +
+    'exceed the hundred non-code character floor so the over-bold tripwire ' +
+    'fires on it every time.**\n\n' +
+    '• first bullet\n• second bullet\n\n' +
+    'A range like 2019 – 2024 and a spaced em-dash a — b for good measure.'
+
+  it('strips the over-bold block and normalizes bullets/dashes exactly as reply does', () => {
+    const out = formatChain(input)
+    // stripExcessBold removed the ** markers from the over-bolded paragraph
+    // (the step turn-flush was missing) — the text survives, the markers do not.
+    expect(out).not.toContain('**This whole paragraph')
+    expect(out).toContain('This whole paragraph is bolded')
+    // normalizePunctuation turned unicode bullets into GFM '- ' list items.
+    expect(out).toContain('- first bullet')
+    expect(out).toContain('- second bullet')
+    expect(out).not.toContain('• first bullet')
+    // and normalized the dashes: spaced en-dash numeric range -> hyphen,
+    // spaced em-dash between words -> comma. Same treatment reply applies.
+    expect(out).toContain('2019-2024')
+    expect(out).toContain('a, b')
+    expect(out).not.toContain('2019 – 2024')
+    expect(out).not.toContain('a — b')
+  })
+})
+
 describe('decideTurnFlush', () => {
   it('(a) does NOT flush when the reply tool was called', () => {
     const decision = decideTurnFlush({
@@ -125,9 +343,12 @@ describe('decideTurnFlush', () => {
       replyCalled: false,
       capturedText: ['here is the answer', 'more detail'],
     })
+    // #2798 — whole authored text blocks are joined with a PARAGRAPH break
+    // ('\n\n'), not a lone '\n', so adjacent blocks don't collapse into a
+    // single run on the rich-markdown path.
     expect(decision).toEqual({
       kind: 'flush',
-      text: 'here is the answer\nmore detail',
+      text: 'here is the answer\n\nmore detail',
     })
   })
 

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

@@ -637,7 +637,7 @@ describe('rolling window — createWorkerActivityFeed narrative accumulation', (
 // ─── Worker heartbeat (option a — suffix-only, never opens a new message) ─────
 
 describe('createWorkerActivityFeed — heartbeat', () => {
-  it('(i) a tick fires a re-render with a climbing · Ns suffix on a stale worker', async () => {
+  it('(i) a tick fires a re-render with a climbing · Ns suffix showing the current step\'s OWN elapsed', async () => {
     const bot = makeFakeBot()
     let clock = 10_000
     const feed = createWorkerActivityFeed({
@@ -649,22 +649,50 @@ describe('createWorkerActivityFeed — heartbeat', () => {
       setInterval: () => 1,
       clearInterval: () => {},
     })
-    // First paint at elapsed 0 (firstPaintMin default 8000 — use 9000).
+    // First paint at elapsed 0 (firstPaintMin default 8000 — use 9000). The
+    // narrative line 'pulling data' lands here, so the current step starts now.
     clock = 19_000
     await feed.update('w1', 'chat', view({ elapsedMs: 9000, latestSummary: 'pulling data' }))
     expect(bot.sent).toHaveLength(1)
-    const dispatchAt = clock - 9000
+    const stepStart = clock // step began when the '→' line first appeared
 
-    // Advance past the staleness window so the heartbeat ticks.
-    clock = 26_000 // lastEditAt(19000) + 7000 ≥ heartbeatTickMs(6000) and ≥ minEditInterval
+    // Advance well past the per-step 10s gate so the heartbeat renders a suffix.
+    clock = 32_000 // step is now 13s old; lastEditAt(19000)+13000 ≥ heartbeatTickMs
     feed.heartbeatTick()
-    await feed.update('w1', 'chat', view({ elapsedMs: 16_000, latestSummary: 'pulling data' })).catch(() => {})
+    await feed.update('w1', 'chat', view({ elapsedMs: 22_000, latestSummary: 'pulling data' })).catch(() => {})
     // Drain the chain.
-    await feed.update('w1', 'chat', view({ elapsedMs: 16_000, latestSummary: 'pulling data' }))
+    await feed.update('w1', 'chat', view({ elapsedMs: 22_000, latestSummary: 'pulling data' }))
     const edit1 = bot.edits.find((e) => /· \d+s\*\*/.test(e.text))
     expect(edit1).toBeDefined()
-    // The suffix reflects the LIVE elapsed (now - dispatchAt), not the stale view.
-    expect(edit1!.text).toContain(`· ${Math.floor((26_000 - dispatchAt) / 1000)}s`)
+    // The step suffix reflects the STEP's OWN elapsed (now - stepStart), NOT
+    // the worker total — the header already carries the total.
+    expect(edit1!.text).toContain(`· ${Math.floor((32_000 - stepStart) / 1000)}s`)
+  })
+
+  it('(i-a) suppresses the step suffix while the current step is younger than the 10s gate', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({
+      bot,
+      now: () => clock,
+      minEditIntervalMs: 2500,
+      heartbeatTickMs: 6000,
+      setInterval: () => 1,
+      clearInterval: () => {},
+    })
+    // Step begins here.
+    clock = 19_000
+    await feed.update('w1', 'chat', view({ elapsedMs: 9000, latestSummary: 'pulling data' }))
+    expect(bot.sent).toHaveLength(1)
+
+    // Heartbeat only 7s into the step — under STEP_TIMER_MIN_MS (10s), so no
+    // `· Ns` suffix on the '→' line yet (the header total still climbs).
+    clock = 26_000
+    feed.heartbeatTick()
+    await feed.update('w1', 'chat', view({ elapsedMs: 16_000, latestSummary: 'pulling data' })).catch(() => {})
+    await feed.update('w1', 'chat', view({ elapsedMs: 16_000, latestSummary: 'pulling data' }))
+    const stepSuffixEdit = bot.edits.find((e) => /· \d+s\*\*/.test(e.text))
+    expect(stepSuffixEdit).toBeUndefined()
   })
 
   it('(i-b) heartbeat repaint keeps the header master elapsed >= the step timer (same clock anchor)', async () => {
@@ -801,6 +829,120 @@ describe('createWorkerActivityFeed — heartbeat', () => {
     await feed.update('w1', 'chat', view({ elapsedMs: 2000, latestSummary: 'go' })).catch(() => {})
     expect(bot.edits.length).toBe(editsBefore)
   })
+
+  // ─── Prose-silent worker: first paint driven by the heartbeat ──────────────
+  // The user-visible bug: a background worker that dives straight into quiet
+  // work (a long `Bash` / `npm test`) fires ONE `sub_agent_tool_use` tick when
+  // the command starts, then no more JSONL lines for the whole run. If that one
+  // tick lands before `firstPaintMin` the paint is held — and pre-fix the
+  // heartbeat skipped `messageId == null` handles, so nothing ever re-drove the
+  // paint and the worker showed NOTHING for its entire run. The heartbeat now
+  // performs the first paint once the held handle is past `firstPaintMin`.
+  it('(vi) paints a prose-silent worker whose only tick arrived before firstPaintMin, via a later heartbeat', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({
+      bot,
+      now: () => clock,
+      firstPaintMinMs: 8000,
+      heartbeatTickMs: 6000,
+      minEditIntervalMs: 2500,
+      setInterval: () => 1,
+      clearInterval: () => {},
+    })
+    const drain = () => new Promise((r) => setTimeout(r, 0))
+
+    // A single tool tick at 2s (the Bash invocation) — before firstPaintMin,
+    // so the paint is held. This is the ONLY update the worker ever sends.
+    clock = 2000
+    await feed.update('w1', 'chat', view({ elapsedMs: 2000, toolCount: 1, latestSummary: '' }))
+    expect(bot.sent).toHaveLength(0)
+    expect(feed.messageIdOf('w1')).toBeNull()
+
+    // A heartbeat still before firstPaintMin holds — trivial workers stay silent.
+    clock = 6000
+    feed.heartbeatTick()
+    await drain()
+    expect(bot.sent).toHaveLength(0)
+    expect(feed.messageIdOf('w1')).toBeNull()
+
+    // A heartbeat PAST firstPaintMin performs the first paint — the worker
+    // becomes visible even though it never emitted prose or a second tick.
+    clock = 12_000
+    feed.heartbeatTick()
+    await drain()
+    expect(bot.sent).toHaveLength(1)
+    expect(feed.messageIdOf('w1')).toBe(1000)
+    expect(bot.sent[0].text).toContain('🛠 **Worker**')
+
+    // And it keeps updating: a later heartbeat edits the message with a
+    // climbing `· Ns` suffix so the still-alive worker visibly advances.
+    clock = 20_000
+    feed.heartbeatTick()
+    await drain()
+    expect(bot.edits.length).toBeGreaterThanOrEqual(1)
+    // No narrative step (prose-silent) → the advance shows in the header's
+    // climbing master elapsed rather than a `· Ns` step suffix.
+    expect(bot.edits[bot.edits.length - 1].text).toMatch(/_\d+s · 1 tool_/)
+  })
+
+  it('(vii) still holds a trivial sub-firstPaintMin worker silent (heartbeat never force-paints early)', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({
+      bot,
+      now: () => clock,
+      firstPaintMinMs: 8000,
+      heartbeatTickMs: 6000,
+      setInterval: () => 1,
+      clearInterval: () => {},
+    })
+    const drain = () => new Promise((r) => setTimeout(r, 0))
+    // Worker ticks once at 1s then finishes at 3s (handback covers it). No
+    // heartbeat before firstPaintMin may paint it.
+    clock = 1000
+    await feed.update('w1', 'chat', view({ elapsedMs: 1000, toolCount: 1, latestSummary: '' }))
+    clock = 3000
+    feed.heartbeatTick()
+    await drain()
+    expect(bot.sent).toHaveLength(0)
+    await feed.finish('w1', view({ state: 'done', toolCount: 1 }))
+    // finish with no posted message → no recap edit (handback covers the result).
+    expect(bot.edits).toHaveLength(0)
+  })
+
+  it('(viii) a finished, still-unpainted worker is NOT orphan-painted by a later heartbeat', async () => {
+    // Regression guard: the heartbeat first-paint branch must never send a
+    // fresh `running` message on an already-finished handle. finish() deletes
+    // the handle; a subsequent heartbeat (even one past firstPaintMin) must
+    // skip it — otherwise a permanently orphaned card that never finalizes.
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({
+      bot,
+      now: () => clock,
+      firstPaintMinMs: 8000,
+      heartbeatTickMs: 6000,
+      setInterval: () => 1,
+      clearInterval: () => {},
+    })
+    const drain = () => new Promise((r) => setTimeout(r, 0))
+    // One held tick before firstPaintMin — no paint yet.
+    clock = 2000
+    await feed.update('w1', 'chat', view({ elapsedMs: 2000, toolCount: 1, latestSummary: '' }))
+    expect(bot.sent).toHaveLength(0)
+    expect(feed.messageIdOf('w1')).toBeNull()
+    // Worker finishes while still unpainted (finish drops the handle).
+    await feed.finish('w1', view({ state: 'done', toolCount: 1 }))
+    expect(feed.messageIdOf('w1')).toBeNull()
+    // A heartbeat well past firstPaintMin must NOT paint a new message.
+    clock = 20_000
+    feed.heartbeatTick()
+    await drain()
+    expect(bot.sent).toHaveLength(0)
+    expect(bot.edits).toHaveLength(0)
+    expect(feed.messageIdOf('w1')).toBeNull()
+  })
 })
 
 // ─── Extreme-edge: single oversized narrative line (no-truncate ON) ──────────
@@ -998,3 +1140,54 @@ describe('header row + rolling overflow survive in the unified worker render', (
     expect(isValidWorkerMarkdown(out)).toBe(true)
   })
 })
+
+// ─── Dedup — non-adjacent repeats within the rolling window (unified cards) ──
+
+describe('narrative dedup — non-adjacent repeats collapse (A,B,A)', () => {
+  it('a line already in the rolling window is not re-appended', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+
+    // The live-observed duplication: a preamble ("Look for nested subagents
+    // structure") surfaces, another step lands, then the same text re-fires
+    // (e.g. as the Task tool's describeToolUse label for the same step).
+    const seq = [
+      'Look for nested subagents structure',
+      'Inspect subagents dir files',
+      'Look for nested subagents structure', // non-adjacent repeat — must collapse
+      'Inspect subagents dir files',         // non-adjacent repeat — must collapse
+      'Tail the child jsonl',
+    ]
+    for (const line of seq) {
+      clock += 1000
+      await feed.update('w-dedup', 'chat', view({ latestSummary: line }))
+    }
+
+    const last = bot.edits.at(-1) ?? bot.sent.at(-1)!
+    const count = (needle: string): number => last.text.split(needle).length - 1
+    expect(count('Look for nested subagents structure')).toBe(1)
+    expect(count('Inspect subagents dir files')).toBe(1)
+    expect(last.text).toContain('Tail the child jsonl')
+    // Source order preserved: first occurrence wins its slot.
+    expect(last.text.indexOf('Look for nested subagents structure'))
+      .toBeLessThan(last.text.indexOf('Inspect subagents dir files'))
+  })
+
+  it('a legitimate revisit re-appears once the earlier copy scrolls out of the window', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+
+    await feed.update('w2', 'chat', view({ latestSummary: 'step-repeat' }))
+    // Push STATUS_ROLLING_LINES distinct lines so 'step-repeat' scrolls out.
+    for (let i = 0; i < STATUS_ROLLING_LINES; i++) {
+      clock += 1000
+      await feed.update('w2', 'chat', view({ latestSummary: `filler-${i}` }))
+    }
+    clock += 1000
+    await feed.update('w2', 'chat', view({ latestSummary: 'step-repeat' }))
+    const last = bot.edits.at(-1)!
+    expect(last.text).toContain('step-repeat')
+  })
+})

package/telegram-plugin/tests/worker-feed-dispatch.test.ts

@@ -16,6 +16,7 @@ function makeSub(over: Partial<Subagent>): Subagent {
     status: 'running',
     result_summary: null,
     jsonl_agent_id: 'a37ad7639ae61476c',
+    parent_agent_id: null,
     ...over,
   }
 }
@@ -138,3 +139,27 @@ describe('resolveWorkerFeedDispatch — randomized property sweep', () => {
     }
   })
 })
+
+describe('resolveWorkerFeedDispatch — nested/row-presence signals (unified progress cards)', () => {
+  it('hasRow=false for a missing registry row (never silently foreground-nest it)', () => {
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent')
+    expect(out.hasRow).toBe(false)
+    expect(out.isNested).toBe(false)
+  })
+
+  it('hasRow=true for any present row', () => {
+    expect(resolveWorkerFeedDispatch(makeSub({}), 'sub-agent').hasRow).toBe(true)
+  })
+
+  it('isNested=true when parent_agent_id is set (depth-2+ dispatch)', () => {
+    const sub = makeSub({ parent_agent_id: 'ac15e1e3528f421d6', background: false })
+    const out = resolveWorkerFeedDispatch(sub, 'sub-agent')
+    expect(out.isNested).toBe(true)
+    // Its own background flag stays honest — the caller ORs isNested in.
+    expect(out.isBackground).toBe(false)
+  })
+
+  it('isNested=false for a main-session dispatch (parent_agent_id null)', () => {
+    expect(resolveWorkerFeedDispatch(makeSub({ parent_agent_id: null }), 's').isNested).toBe(false)
+  })
+})