switchroom 0.19.25 → 0.19.27

package/telegram-plugin/tests/card-lifecycle-render.test.ts

@@ -0,0 +1,362 @@
+/**
+ * END-TO-END card lifecycle — drives the REAL feed manager
+ * (`createWorkerActivityFeed`) with realistic worker cues and asserts the
+ * EXACT text that reaches Telegram at every stage of a worker's life:
+ *
+ *   dispatch → running → a second worker joins (coalesce) → spill/overflow
+ *   → one finishes (survivors keep ordinals) → failure recap → supersede.
+ *
+ * This is deliberately NOT `renderStatusCard(opts)` in isolation. The seam is
+ * the highest one drivable in-process: feed state in, `sendMessage` /
+ * `editMessageText` bodies out — the same bytes the user reads on their phone.
+ * The golden suite (`card-golden.test.ts`) pins each variant's shape; this
+ * suite proves the lifecycle actually PRODUCES those variants, in order.
+ *
+ * Every assertion here is one that fails if the shared card layout core
+ * (`card-layout.ts`) changes header composition, step-block drawing, the
+ * rolling window, the placeholder, the spill line or the budget backstop.
+ */
+import { describe, expect, it } from 'vitest'
+
+import {
+  createWorkerActivityFeed,
+  WORKER_CARD_SUPERSEDED_BODY,
+  type BotApiForWorkerFeed,
+  type WorkerActivityView,
+} from '../worker-activity-feed.js'
+import { WORKER_STEP_INDENT } from '../status-no-truncate.js'
+
+const CHAT = '4242'
+
+interface Painted {
+  kind: 'send' | 'edit'
+  messageId: number
+  text: string
+}
+
+function harness(opts: { maxRows?: number; groupMessageLifetimeCapMs?: number } = {}) {
+  let now = 1_000_000
+  const painted: Painted[] = []
+  let nextId = 500
+  const bot: BotApiForWorkerFeed = {
+    async sendMessage(_chatId, text) {
+      const message_id = ++nextId
+      painted.push({ kind: 'send', messageId: message_id, text })
+      return { message_id }
+    },
+    async editMessageText(_chatId, messageId, text) {
+      painted.push({ kind: 'edit', messageId, text })
+      return {}
+    },
+  }
+  const feed = createWorkerActivityFeed({
+    bot,
+    now: () => now,
+    // Zero the rate limiters so every cue paints — this suite is about the
+    // RENDERED BYTES, not the edit budget (that is worker-feed-coalesce's job).
+    minEditIntervalMs: 0,
+    elapsedRefreshMs: 0,
+    firstPaintMinMs: 0,
+    maxRows: opts.maxRows ?? 6,
+    groupMessageLifetimeCapMs: opts.groupMessageLifetimeCapMs,
+    // No real timers in the test process.
+    setInterval: () => null,
+    clearInterval: () => {},
+  })
+  return {
+    feed,
+    painted,
+    advance: (ms: number) => {
+      now += ms
+    },
+    nowMs: () => now,
+    /** The most recent body sent or edited — what the user is looking at. */
+    last: (): string => painted[painted.length - 1]?.text ?? '',
+    reset: () => {
+      painted.length = 0
+    },
+  }
+}
+
+const view = (over: Partial<WorkerActivityView> = {}): WorkerActivityView => ({
+  description: 'Audit every card render path',
+  state: 'running',
+  elapsedMs: 12_000,
+  toolCount: 3,
+  lastTool: null,
+  latestSummary: '',
+  narrativeLines: [],
+  model: 'claude-opus-4-8',
+  totalTokens: 10_000,
+  ...over,
+})
+
+/** Await the feed's internal promise chain. */
+const settle = async (): Promise<void> => {
+  for (let i = 0; i < 8; i++) await new Promise((r) => setImmediate(r))
+}
+
+describe('worker card lifecycle — the bytes the user actually sees', () => {
+  it('dispatch: the first paint is a real card with a starting… placeholder, not a bare header', async () => {
+    const h = harness()
+    await h.feed.update('w1', CHAT, view({ elapsedMs: 1_200, toolCount: 0, narrativeLines: [] }))
+    await settle()
+
+    expect(h.painted.length).toBeGreaterThan(0)
+    expect(h.painted[0].kind).toBe('send')
+    const card = h.painted[0].text
+    // Title line, metrics line, placeholder — three lines, all from the layout core.
+    expect(card).toContain('🛠 **WORKER**')
+    expect(card).toContain('Audit every card render path')
+    expect(card).toMatch(/_1s · 0 tools · 10\.0k tok · opus 4\.8_/)
+    expect(card).toContain('_starting…_')
+    // #3846: the placeholder is a SECTION of the card, so it carries the same
+    // collapse-safe line joining as every other line — a hand-appended tail did not.
+    const lines = card.split('\n')
+    expect(lines.length).toBe(3)
+    for (const l of lines.slice(0, -1)) expect(l.endsWith('  ')).toBe(true)
+    expect(card).not.toContain('starting…\n_starting…_')
+  })
+
+  it('running: narrative steps become a ✓/→ trail under one shared header', async () => {
+    const h = harness()
+    await h.feed.update('w1', CHAT, view({ latestSummary: 'Fetching origin' }))
+    await settle()
+    h.reset()
+    // The watcher emits ONE latest step per tick; the feed accumulates them.
+    await h.feed.update('w1', CHAT, view({ toolCount: 10, latestSummary: 'Reading the renderer' }))
+    await settle()
+    await h.feed.update(
+      'w1',
+      CHAT,
+      view({ elapsedMs: 143_000, toolCount: 31, totalTokens: 88_400, latestSummary: 'Mapping callers' }),
+    )
+    await settle()
+
+    const card = h.last()
+    expect(card).toContain('~~_✓ Fetching origin_~~')
+    expect(card).toContain('~~_✓ Reading the renderer_~~')
+    expect(card).toContain('**→ Mapping callers**')
+    expect(card).not.toContain('_starting…_')
+    // The metrics line is composed once, by metricsRun — running order is
+    // `{elapsed} · {tools} · {tok} · {model}`.
+    expect(card).toContain('_2m23s · 31 tools · 88.4k tok · opus 4.8_')
+    // Single-worker card carries NO indent (#3843 de-indent).
+    expect(card).not.toContain(WORKER_STEP_INDENT)
+  })
+
+  it('depth budget: a row deeper than its per-worker budget shows only its newest steps', async () => {
+    // The feed retains WORKER_HISTORY_MAX (6) steps; with 2 workers the shared
+    // layout gives each row a depth of 5, so the oldest step must drop out.
+    const h = harness()
+    for (let i = 1; i <= 6; i++) {
+      await h.feed.update('w1', CHAT, view({ toolCount: i, latestSummary: `s${i}` }))
+      await settle()
+    }
+    await h.feed.update('w2', CHAT, view({ description: 'Second worker', latestSummary: 'b1' }))
+    await settle()
+
+    const card = h.last()
+    expect(card).not.toContain('s1_')
+    expect(card).toContain(`${WORKER_STEP_INDENT}~~_✓ s2_~~`)
+    expect(card).toContain(`${WORKER_STEP_INDENT}**→ s6**`)
+    // Exactly depth-1 done steps plus the one live step.
+    expect(card.split('\n').filter((l) => /~~_✓ s\d_~~/.test(l)).length).toBe(4)
+    expect(card.split('\n').filter((l) => l.includes('**→ ')).length).toBe(2)
+  })
+
+  it('two workers coalesce into ONE message whose rows share the header composer', async () => {
+    const h = harness()
+    await h.feed.update('w1', CHAT, view({ latestSummary: 'audit 1' }))
+    await settle()
+    const firstId = h.painted[0].messageId
+    h.reset()
+    await h.feed.update(
+      'w2',
+      CHAT,
+      view({
+        description: 'Fix the hindsight recall floor',
+        elapsedMs: 60_000,
+        toolCount: 7,
+        totalTokens: 20_000,
+        latestSummary: 'recall 1',
+      }),
+    )
+    await settle()
+
+    // One message, edited — not a second send.
+    expect(h.painted.every((p) => p.messageId === firstId)).toBe(true)
+    expect(h.painted.some((p) => p.kind === 'send')).toBe(false)
+
+    const card = h.last()
+    expect(card).toContain('🛠 **WORKERS**')
+    expect(card).toContain('2 running')
+    expect(card).toContain('**1. Audit every card render path**')
+    expect(card).toContain('**2. Fix the hindsight recall floor**')
+    // Row headers use the SAME metricsRun as the single-worker card.
+    expect(card).toContain('_· 1m00s · 7 tools · 20.0k tok · opus 4.8_')
+    // Rows are indented with the braille blank so Telegram cannot left-trim.
+    expect(card).toContain(`${WORKER_STEP_INDENT}**→ recall 1**`)
+  })
+
+  it('a worker with no history yet renders the shared placeholder inside its row', async () => {
+    const h = harness()
+    await h.feed.update('w1', CHAT, view({ latestSummary: 'audit 1' }))
+    await settle()
+    h.reset()
+    await h.feed.update('w2', CHAT, view({ description: 'Freshly dispatched', latestSummary: '' }))
+    await settle()
+
+    const card = h.last()
+    expect(card).toContain('**2. Freshly dispatched**')
+    expect(card).toContain(`${WORKER_STEP_INDENT}→ _starting…_`)
+  })
+
+  it('spill: beyond maxRows the newest rows collapse into one +M more working… line', async () => {
+    const h = harness({ maxRows: 6 })
+    for (let i = 1; i <= 8; i++) {
+      await h.feed.update(`w${i}`, CHAT, view({ description: `Background task ${i}`, latestSummary: `t${i} a` }))
+      await settle()
+    }
+    const card = h.last()
+    expect(card).toContain('8 running')
+    expect(card).toContain('**6. Background task 6**')
+    expect(card).not.toContain('**7. Background task 7**')
+    expect(card).toContain('_+2 more working…_')
+    // The spill line is the LAST line of the card (a footer, not a stray row).
+    const lines = card.split('\n')
+    expect(lines[lines.length - 1]).toContain('+2 more working…')
+  })
+
+  it('spill honours the body-line budget: many deep rows still shrink to fit', async () => {
+    const h = harness({ maxRows: 6 })
+    for (let i = 1; i <= 6; i++) {
+      await h.feed.update(
+        `w${i}`,
+        CHAT,
+        view({
+          description: `Background task ${i}`,
+          latestSummary: `t${i} step`,
+        }),
+      )
+      await settle()
+      for (const step of ['b', 'c', 'd', 'e', 'f']) {
+        await h.feed.update(`w${i}`, CHAT, view({ description: `Background task ${i}`, latestSummary: `t${i} ${step}` }))
+        await settle()
+      }
+    }
+    const card = h.last()
+    // MAX_COMBINED_BODY_LINES = 6 rows × (1 header + 3 steps) = 24.
+    const body = card.split('\n').filter((l) => !l.includes('🛠 **WORKERS**') && !l.includes('more working…'))
+    expect(body.length).toBeLessThanOrEqual(24)
+    // Shrinking drops ROWS, never the glance chrome.
+    expect(card).toContain('🛠 **WORKERS**')
+    expect(card).toContain('6 running')
+  })
+
+  it('one worker finishing leaves the survivors numbered as they were dispatched', async () => {
+    const h = harness()
+    await h.feed.update('w1', CHAT, view({ latestSummary: 'audit 1' }))
+    await settle()
+    await h.feed.update('w2', CHAT, view({ description: 'Second worker', latestSummary: 'b1' }))
+    await settle()
+    await h.feed.update('w3', CHAT, view({ description: 'Third worker', latestSummary: 'c1' }))
+    await settle()
+    expect(h.last()).toContain('**1. Audit every card render path**')
+    h.reset()
+
+    await h.feed.finish('w1', view({ state: 'done', latestSummary: 'All done.' }))
+    await settle()
+
+    const card = h.last()
+    expect(card).toContain('2 running')
+    expect(card).toContain('**2. Second worker**')
+    expect(card).toContain('**3. Third worker**')
+    expect(card).not.toContain('**1. ')
+  })
+
+  it('completion: the last worker collapses to a struck feed plus the ✅ result recap', async () => {
+    const h = harness()
+    await h.feed.update('w1', CHAT, view({ latestSummary: 'Fetching origin' }))
+    await settle()
+    await h.feed.update('w1', CHAT, view({ toolCount: 20, latestSummary: 'Mapping callers' }))
+    await settle()
+    h.reset()
+    await h.feed.finish(
+      'w1',
+      view({
+        state: 'done',
+        elapsedMs: 902_000,
+        toolCount: 44,
+        latestSummary: 'Inventoried every card variant and unified the renderer. PR #0000.',
+      }),
+    )
+    await settle()
+
+    const card = h.last()
+    // Terminal metrics order flips: `{state} · {tools} · {tok} · {elapsed}`.
+    expect(card).toContain('_done · 44 tools · 10.0k tok · 15m02s · opus 4.8_')
+    // No live `→` marker survives on a finished card.
+    expect(card).not.toContain('**→ ')
+    expect(card).toContain('~~_✓ Mapping callers_~~')
+    // The result block: shared rule, then the ✅ recap paragraph.
+    expect(card).toContain('─────')
+    expect(card).toContain('✅ _Inventoried')
+    expect(card).toContain('Inventoried every card variant and unified the renderer.')
+  })
+
+  it('failure: the card reads failed and carries the error recap', async () => {
+    const h = harness()
+    await h.feed.update('w1', CHAT, view({ latestSummary: 'Running the scoped suite' }))
+    await settle()
+    h.reset()
+    await h.feed.finish(
+      'w1',
+      view({
+        state: 'failed',
+        elapsedMs: 61_000,
+        toolCount: 9,
+        latestSummary: 'Scoped test run failed: 3 assertions.',
+      }),
+    )
+    await settle()
+
+    const card = h.last()
+    expect(card).toContain('_failed · 9 tools · 10.0k tok · 1m01s · opus 4.8_')
+    expect(card).toContain('⚠️ _Scoped test run failed: 3 assertions._')
+    expect(card).not.toContain('**→ ')
+  })
+
+  it('supersede: the retired message is finalised to the shared-chrome notice, and a fresh card opens', async () => {
+    const h = harness({ groupMessageLifetimeCapMs: 60_000 })
+    await h.feed.update('w1', CHAT, view({ latestSummary: 'step one' }))
+    await settle()
+    const firstId = h.painted[0].messageId
+    h.reset()
+
+    // Push the group's shared message past its lifetime cap, then let the
+    // heartbeat (the real rotation trigger) run.
+    h.advance(120_000)
+    await h.feed.update('w1', CHAT, view({ elapsedMs: 132_000, toolCount: 9, latestSummary: 'step two' }))
+    await settle()
+    h.feed.heartbeatTick()
+    await settle()
+
+    const superseded = h.painted.find((p) => p.text === WORKER_CARD_SUPERSEDED_BODY)
+    expect(superseded, 'the retired message must be finalised to the superseded notice').toBeDefined()
+    expect(superseded?.kind).toBe('edit')
+    expect(superseded?.messageId).toBe(firstId)
+    // Shared chrome: same title composer as every live card.
+    expect(WORKER_CARD_SUPERSEDED_BODY.startsWith('🛠 **WORKER** · _continued_')).toBe(true)
+    // The retired notice carries no live-styled rows — it must not read as a
+    // stuck worker.
+    expect(WORKER_CARD_SUPERSEDED_BODY).not.toContain('**→ ')
+
+    // A fresh, live card was opened for the still-running worker.
+    const fresh = h.painted.filter((p) => p.kind === 'send')
+    expect(fresh.length).toBe(1)
+    expect(fresh[0].messageId).not.toBe(firstId)
+    expect(fresh[0].text).toContain('🛠 **WORKER**')
+    expect(fresh[0].text).toContain('step two')
+  })
+})

package/telegram-plugin/tests/card-type-distinguishability.test.ts

@@ -0,0 +1,291 @@
+/**
+ * #3842 — every status card is FLUSH at the left margin, and the only
+ * indentation any card carries is the step indent that separates one worker's
+ * steps from the next worker's on the combined (2+ worker) card.
+ *
+ * #3820/#3821 had made the worker card structurally subordinate to the 🤖 agent
+ * card: line 1 prefixed with `└─ ` and every later line indented by a U+2800
+ * run. Ken rejected that shape — it burns a level of horizontal space on a
+ * phone, and the worker card does not always sit below the agent card, so a
+ * card-LEVEL subordination marker asserts a relationship that is not always
+ * true. Net effect of this file's expectations: everything shifted left by one
+ * level; worker-vs-worker separation is carried by the surviving step indent
+ * plus the numbered row headers.
+ *
+ * These tests assert the RENDERED OUTPUT of the real renderers, and they fail
+ * on the pre-#3842 shape (which put `└─ ` on line 1 and U+2800 on every other
+ * line of both worker surfaces).
+ *
+ * What is NOT asserted here any more, deliberately: that no rendered line is
+ * shared between the agent card and the worker card. With whole-card nesting
+ * gone and identical step text, the two cards' BODY lines coincide byte for
+ * byte — see the explicit characterization test at the end. Line 1 (🤖 `Agent`
+ * vs 🛠 `WORKER`) is now the only type cue, which is the accepted trade.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  renderActivityFeed,
+  renderStatusCard,
+  renderCombinedWorkerFeed,
+} from '../tool-activity-summary.js'
+import { renderWorkerActivity, type WorkerActivityView } from '../worker-activity-feed.js'
+import { WORKER_STEP_INDENT, STATUS_CARD_CHAR_BUDGET } from '../status-no-truncate.js'
+import { richMessage } from '../rich-send.js'
+
+/** Split a rendered card into display lines, dropping the hard-break padding. */
+function lines(card: string): string[] {
+  return card.split('\n').map((l) => l.replace(/[  \t\r]+$/, ''))
+}
+
+/** The exact scenario from #3820: parent narrating the task it delegated. */
+const STEPS = ['PR 2502 details', 'Commits since v0.8.5']
+
+/** The card-level chrome #3842 removed. Asserted absent, never re-emitted. */
+const REMOVED_HEADER_PREFIX = '└─ '
+
+function agentCard(): string {
+  const out = renderActivityFeed(STEPS, false, '', undefined, {
+    label: 'Agent',
+    elapsedMs: 108_000,
+    toolCount: 15,
+    state: 'running',
+    model: 'claude-opus-5',
+    totalTokens: 16_400,
+  })
+  expect(out).not.toBeNull()
+  return out as string
+}
+
+function workerView(over: Partial<WorkerActivityView> = {}): WorkerActivityView {
+  return {
+    description: 'Check upstream hindsight changes',
+    elapsedMs: 108_000,
+    toolCount: 15,
+    latestSummary: '',
+    narrativeLines: STEPS,
+    state: 'running',
+    model: 'claude-opus-5',
+    totalTokens: 16_400,
+    ...over,
+  } as WorkerActivityView
+}
+
+function combinedCard(): string {
+  const card = renderCombinedWorkerFeed(
+    [
+      {
+        description: 'Check upstream hindsight changes',
+        elapsedMs: 55_000,
+        toolCount: 9,
+        currentStep: 'Commits since v0.8.5',
+        historyLines: STEPS,
+        ordinal: 1,
+      },
+      {
+        description: 'Fix the card renderer',
+        elapsedMs: 30_000,
+        toolCount: 4,
+        currentStep: 'Reading render.ts',
+        historyLines: ['Reading render.ts'],
+        ordinal: 2,
+      },
+    ],
+    { maxRows: 4 },
+  )
+  expect(card).not.toBeNull()
+  return card as string
+}
+
+/** Every worker surface, in each of its render states, as rendered strings. */
+function everyWorkerSurface(): Array<{ name: string; card: string }> {
+  return [
+    { name: 'running', card: renderWorkerActivity(workerView()) },
+    {
+      name: 'just dispatched',
+      card: renderWorkerActivity(workerView({ narrativeLines: [], latestSummary: '' })),
+    },
+    {
+      name: 'done + result block',
+      card: renderWorkerActivity(
+        workerView({ state: 'done', latestSummary: 'Rebased and opened the PR.' }),
+      ),
+    },
+    {
+      name: 'failed + result block',
+      card: renderWorkerActivity(
+        workerView({ state: 'failed', latestSummary: 'Scoped tests went red.' }),
+      ),
+    },
+    {
+      name: 'incomplete',
+      card: renderWorkerActivity(workerView({ state: 'incomplete', latestSummary: '' })),
+    },
+    { name: 'combined (2 workers)', card: combinedCard() },
+  ]
+}
+
+describe('#3842 every card is flush at the left margin', () => {
+  it('emits no `└─ ` header prefix on any surface', () => {
+    for (const { name, card } of [{ name: 'agent', card: agentCard() }, ...everyWorkerSurface()]) {
+      expect(card.includes(REMOVED_HEADER_PREFIX), `${name} card carries └─`).toBe(false)
+    }
+  })
+
+  it('leaves every line of the SINGLE-worker card unindented', () => {
+    // Pre-#3842 line 1 started `└─ ` and lines 2..n started with a U+2800 run.
+    const surfaces = everyWorkerSurface()
+    for (const name of [
+      'running',
+      'just dispatched',
+      'done + result block',
+      'failed + result block',
+      'incomplete',
+    ]) {
+      const card = surfaces.find((s) => s.name === name)?.card as string
+      const l = lines(card)
+      expect(l.length).toBeGreaterThan(1)
+      for (const line of l) {
+        expect(line.startsWith(WORKER_STEP_INDENT), `${name}: "${line}"`).toBe(false)
+      }
+    }
+  })
+
+  it('keeps the just-dispatched `starting…` tail flush too', () => {
+    // The one render state a user always sees first takes a hand-rolled append
+    // path outside renderStatusCard — the place a shape change silently misses.
+    const l = lines(renderWorkerActivity(workerView({ narrativeLines: [], latestSummary: '' })))
+    expect(l[0].startsWith('🛠 **WORKER**')).toBe(true)
+    expect(l[l.length - 1]).toBe('_starting…_')
+  })
+
+  it('keeps the terminal result block flush', () => {
+    const l = lines(
+      renderWorkerActivity(
+        workerView({ state: 'done', latestSummary: 'Rebased and opened the PR.' }),
+      ),
+    )
+    expect(l.some((x) => x.startsWith('✅ '))).toBe(true)
+    expect(l.some((x) => x.startsWith(`${WORKER_STEP_INDENT}✅ `))).toBe(false)
+  })
+})
+
+describe('#3842 the combined card keeps exactly ONE level of indent', () => {
+  it('puts the glance line and row headers flush', () => {
+    const l = lines(combinedCard())
+    expect(l[0]).toBe('🛠 **WORKERS** · _2 running · oldest 55s · 13 tools_')
+    const rowHeaders = l.filter((x) => x.includes('**1. ') || x.includes('**2. '))
+    expect(rowHeaders.length).toBe(2)
+    for (const h of rowHeaders) expect(h.startsWith(WORKER_STEP_INDENT)).toBe(false)
+  })
+
+  it('indents step lines exactly one level — never two', () => {
+    const l = lines(combinedCard())
+    const stepLines = l.filter((x) => x.includes('→ ') || x.includes('✓ '))
+    expect(stepLines.length).toBeGreaterThan(0)
+    for (const s of stepLines) {
+      expect(s.startsWith(WORKER_STEP_INDENT)).toBe(true)
+      // The pre-#3842 double indent (SUBORDINATE_LINE_INDENT + WORKER_STEP_INDENT).
+      expect(s.startsWith(WORKER_STEP_INDENT + WORKER_STEP_INDENT)).toBe(false)
+    }
+  })
+
+  it('puts the `+M more working…` spill line flush', () => {
+    const rows = Array.from({ length: 5 }, (_, i) => ({
+      description: `task ${i + 1}`,
+      elapsedMs: 10_000,
+      toolCount: 1,
+      currentStep: 'working',
+      historyLines: ['working'],
+      ordinal: i + 1,
+    }))
+    const card = renderCombinedWorkerFeed(rows, { maxRows: 2 }) as string
+    const spill = lines(card).find((x) => x.includes('more working…'))
+    expect(spill).toBe('_+3 more working…_')
+  })
+})
+
+describe('#3842 char-budget accounting matches the flush shape', () => {
+  it('keeps an oversized worker card under the wire budget', () => {
+    // fitCardToBudget has its own line assembly + arithmetic. With the per-line
+    // nest cost removed it must still land under the cap, and must not emit any
+    // chrome the card no longer carries.
+    const huge = Array.from({ length: 500 }, (_, i) => `${i} `.repeat(100))
+    const card = renderStatusCard({
+      header: {
+        emoji: '🛠',
+        label: 'WORKER',
+        description: 'big',
+        elapsedMs: 1000,
+        toolCount: 1,
+        state: 'running',
+      },
+      steps: huge,
+      historyWindow: 6,
+    })
+    expect(card).not.toBeNull()
+    const s = card as string
+    expect(s.length).toBeLessThanOrEqual(STATUS_CARD_CHAR_BUDGET)
+    expect(s.includes(REMOVED_HEADER_PREFIX)).toBe(false)
+    for (const l of lines(s)) expect(l.startsWith(WORKER_STEP_INDENT)).toBe(false)
+  })
+
+  it('keeps an oversized combined card under the wire budget', () => {
+    const rows = Array.from({ length: 6 }, (_, i) => ({
+      description: 'D'.repeat(72),
+      elapsedMs: 10_000,
+      toolCount: 3,
+      currentStep: 'x',
+      historyLines: Array.from({ length: 6 }, (_, k) => `${'s'.repeat(180)}-${i}-${k}`),
+      ordinal: i + 1,
+    }))
+    const card = renderCombinedWorkerFeed(rows, { maxRows: 6 }) as string
+    expect(card.length).toBeLessThanOrEqual(STATUS_CARD_CHAR_BUDGET)
+  })
+})
+
+describe('#3842 the surviving type cues', () => {
+  it('uses a high-contrast caps type label on the worker card only', () => {
+    const agent = agentCard()
+    const worker = renderWorkerActivity(workerView())
+    expect(worker).toContain('🛠 **WORKER**')
+    expect(agent).toContain('🤖 **Agent**')
+    expect(agent).not.toContain('WORKER')
+  })
+
+  it('distinguishes the two cards on LINE 1 — the only remaining cue', () => {
+    // Characterization, not aspiration: with whole-card nesting gone and
+    // identical step text + stats, the two cards' BODY lines coincide byte for
+    // byte. Line 1 is doing all of the work, so it must never converge.
+    const agent = lines(agentCard())
+    const worker = lines(renderWorkerActivity(workerView()))
+    expect(agent[0]).not.toBe(worker[0])
+    expect(agent[0].startsWith('🤖 ')).toBe(true)
+    expect(worker[0].startsWith('🛠 ')).toBe(true)
+    // The documented cost of #3842, pinned so a future change to it is visible:
+    // every line BELOW line 1 is now shared between the two cards.
+    const overlap = agent.filter((a) => worker.includes(a))
+    expect(overlap).toEqual(agent.slice(1))
+  })
+})
+
+describe('#3842 the surviving step indent survives Telegram reality', () => {
+  it('passes every card through the real outbound markdown guard byte-identical', () => {
+    // richMessage() is the ONE adapter every `{ markdown }` wire send funnels
+    // through (rich-send.ts) — it runs the line-start / heading / dollar-math
+    // guards. Chrome that got escaped there would render as literal markup.
+    for (const { card } of [{ card: agentCard() }, ...everyWorkerSurface()]) {
+      expect(richMessage(card).markdown).toBe(card)
+    }
+  })
+
+  it('uses an indent that no whitespace-trimming rule can eat (#3662 lesson)', () => {
+    // U+00A0 shipped in #3662 and was INERT: Telegram left-trims a leading
+    // Unicode-whitespace run, and U+00A0 is category Zs. Assert the PROPERTY,
+    // not the bytes — a byte-only assertion is what let #3662 ship green.
+    for (const ch of Array.from(WORKER_STEP_INDENT)) {
+      expect(/\s/.test(ch)).toBe(false)
+      expect(/\p{White_Space}/u.test(ch)).toBe(false)
+      expect(/\p{Zs}/u.test(ch)).toBe(false)
+    }
+  })
+})