switchroom 0.18.31 → 0.18.33

package/telegram-plugin/tests/voice-ondemand-callback-handler.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Outcome pins for the on-demand voice ('🔊 Listen') callback family
+ * (`voice:<token>`) extracted from the gateway's callback_query dispatcher
+ * (switchroom#2996 P6). Uses the REAL voice-ondemand token helpers and the
+ * REAL sendVoiceReusingFileId contract via injected send fns: asserts the
+ * fall-through for non-voice data, the auth gate, expiry toast, the
+ * file_id fast path (no upload), the upload path capturing the returned
+ * file_id, and the single-use keyboard strip on success only.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  handleVoiceOnDemandCallback,
+  type VoiceOnDemandCallbackDeps,
+} from '../gateway/voice-ondemand-callback-handler.js'
+
+const TOKEN = 'tok123'
+const DATA = `voice:${TOKEN}`
+
+function makeCtx(over: Record<string, unknown> = {}) {
+  return {
+    from: { id: 42 },
+    chat: { id: 42 },
+    callbackQuery: { message: { message_id: 77 } },
+    answerCallbackQuery: vi.fn(async () => {}),
+    ...over,
+  } as any
+}
+
+function makeDeps(over: Partial<VoiceOnDemandCallbackDeps> = {}) {
+  const setTelegramFileId = vi.fn()
+  const sendVoiceByFileId = vi.fn(async () => ({ voice: { file_id: 'same' } }))
+  const sendVoiceByUpload = vi.fn(async () => ({ voice: { file_id: 'fresh-id' } }))
+  const stripListenKeyboard = vi.fn(async () => {})
+  const log = vi.fn()
+  const deps: VoiceOnDemandCallbackDeps = {
+    loadAccess: () => ({ allowFrom: ['42'] }),
+    voiceOnDemandCache: {
+      get: () => null,
+      setTelegramFileId,
+    },
+    sendVoiceByFileId,
+    sendVoiceByUpload,
+    stripListenKeyboard,
+    log,
+    ...over,
+  }
+  return { deps, setTelegramFileId, sendVoiceByFileId, sendVoiceByUpload, stripListenKeyboard, log }
+}
+
+describe('handleVoiceOnDemandCallback — routing + gates', () => {
+  it('returns false for non-voice callback data', async () => {
+    const { deps } = makeDeps()
+    const ctx = makeCtx()
+    expect(await handleVoiceOnDemandCallback(ctx, 'agent:whatever', deps)).toBe(false)
+    expect(ctx.answerCallbackQuery).not.toHaveBeenCalled()
+  })
+
+  it('gates non-allowlisted senders', async () => {
+    const { deps, sendVoiceByFileId } = makeDeps()
+    const ctx = makeCtx({ from: { id: 666 } })
+    expect(await handleVoiceOnDemandCallback(ctx, DATA, deps)).toBe(true)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: 'Not authorized.' })
+    expect(sendVoiceByFileId).not.toHaveBeenCalled()
+  })
+
+  it('acks an expired token politely', async () => {
+    const { deps } = makeDeps() // cache.get → null
+    const ctx = makeCtx()
+    expect(await handleVoiceOnDemandCallback(ctx, DATA, deps)).toBe(true)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({
+      text: 'Voice expired — send again to hear it.',
+    })
+  })
+})
+
+describe('handleVoiceOnDemandCallback — send paths', () => {
+  it('file_id fast path: sends BY id, strips the keyboard, no upload', async () => {
+    const { deps, sendVoiceByFileId, sendVoiceByUpload, stripListenKeyboard } = makeDeps({
+      voiceOnDemandCache: {
+        get: () => ({ text: 'hello', speed: 1, telegramFileId: 'cached-id' }),
+        setTelegramFileId: vi.fn(),
+      },
+    })
+    const ctx = makeCtx()
+    expect(await handleVoiceOnDemandCallback(ctx, DATA, deps)).toBe(true)
+    expect(sendVoiceByFileId).toHaveBeenCalledWith(
+      '42',
+      'cached-id',
+      expect.objectContaining({ reply_parameters: { message_id: 77 } }),
+      undefined,
+    )
+    expect(sendVoiceByUpload).not.toHaveBeenCalled()
+    expect(stripListenKeyboard).toHaveBeenCalledWith('42', 77, undefined)
+    expect(ctx.answerCallbackQuery).toHaveBeenCalledWith({ text: '🔊' })
+  })
+
+  it('pre-synth file path: uploads the on-disk audio and captures the returned file_id', async () => {
+    const { mkdtempSync, writeFileSync } = await import('node:fs')
+    const { tmpdir } = await import('node:os')
+    const { join } = await import('node:path')
+    const dir = mkdtempSync(join(tmpdir(), 'voice-od-'))
+    const fp = join(dir, 'a.ogg')
+    writeFileSync(fp, Buffer.from([1, 2, 3]))
+    const setTelegramFileId = vi.fn()
+    const { deps, sendVoiceByUpload, stripListenKeyboard } = makeDeps({
+      voiceOnDemandCache: {
+        get: () => ({ text: 'hello', speed: 1, filePath: fp }),
+        setTelegramFileId,
+      },
+    })
+    const ctx = makeCtx()
+    await handleVoiceOnDemandCallback(ctx, DATA, deps)
+    expect(sendVoiceByUpload).toHaveBeenCalled()
+    // Returned message's file_id captured back into the cache for reuse.
+    expect(setTelegramFileId).toHaveBeenCalledWith(TOKEN, 'fresh-id')
+    expect(stripListenKeyboard).toHaveBeenCalled()
+  })
+
+  it('send failure: logs non-fatally and leaves the keyboard intact (retryable)', async () => {
+    const { deps, stripListenKeyboard, log } = makeDeps({
+      voiceOnDemandCache: {
+        get: () => ({ text: 'hello', speed: 1, telegramFileId: 'cached-id' }),
+        setTelegramFileId: vi.fn(),
+      },
+      sendVoiceByFileId: vi.fn(async () => {
+        throw new Error('boom')
+      }),
+      // Stale-id fallback then tries upload; make it fail too so the send
+      // resolves as send-failed overall. filePath absent → lazy synth path
+      // would need the sidecar; keep it simple: upload throws.
+      sendVoiceByUpload: vi.fn(async () => {
+        throw new Error('boom2')
+      }),
+    })
+    const ctx = makeCtx()
+    expect(await handleVoiceOnDemandCallback(ctx, DATA, deps)).toBe(true)
+    expect(stripListenKeyboard).not.toHaveBeenCalled()
+  })
+})

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

@@ -6,7 +6,7 @@ import {
   type WorkerActivityView,
   type BotApiForWorkerFeed,
 } from '../worker-activity-feed.js'
-import { STATUS_ROLLING_LINES, STATUS_LINE_MAX } from '../status-no-truncate.js'
+import { STATUS_ROLLING_LINES, WORKER_HISTORY_MAX, STATUS_LINE_MAX } from '../status-no-truncate.js'
 import { SEND_GATE_SHED } from '../send-gate.js'
 
 describe('isWorkerActivityFeedEnabled (default ON)', () => {
@@ -188,17 +188,31 @@ describe('renderWorkerActivity', () => {
     expect(stepCount(out)).toBe(2)
   })
 
-  it('shows a "+N earlier…" header when the feed exceeds STATUS_ROLLING_LINES (worker surface)', () => {
-    const total = STATUS_ROLLING_LINES + 3
+  it('shows a "+N earlier…" header when the feed exceeds WORKER_HISTORY_MAX (worker surface, #3349)', () => {
+    const total = WORKER_HISTORY_MAX + 3
     const lines = Array.from({ length: total }, (_, i) => `step ${i + 1}`)
     const out = renderWorkerActivity(view({ narrativeLines: lines }))
-    expect(out).toContain(`_✓ +${total - STATUS_ROLLING_LINES} earlier…_`)
+    expect(out).toContain(`_✓ +${total - WORKER_HISTORY_MAX} earlier…_`)
     expect(out).not.toContain('step 1<')
-    const firstVisible = total - STATUS_ROLLING_LINES + 1
+    const firstVisible = total - WORKER_HISTORY_MAX + 1
     expect(out).toContain(`~~_✓ step ${firstVisible}_~~`)
     expect(out).toContain(`**→ step ${total}**`)
-    // STATUS_ROLLING_LINES visible step lines (the overflow header isn't a step).
-    expect(out.match(/step \d/g) ?? []).toHaveLength(STATUS_ROLLING_LINES)
+    // WORKER_HISTORY_MAX visible step lines (the overflow header isn't a step).
+    expect(out.match(/step \d/g) ?? []).toHaveLength(WORKER_HISTORY_MAX)
+  })
+
+  it('the lone-worker card shows the full 6-step trail — the raised ceiling (#3349)', () => {
+    // Ken's curve at w=1 is 6; the single-worker surface must reach it (the old
+    // STATUS_ROLLING_LINES=5 cap could never show the 6th step).
+    expect(WORKER_HISTORY_MAX).toBe(6)
+    const lines = Array.from({ length: 8 }, (_, n) => `ln-${n + 1}`)
+    const out = renderWorkerActivity(view({ narrativeLines: lines }))
+    // Last 6 render (ln-3 … ln-8); the two oldest collapse into a "+2 earlier…".
+    for (let n = 3; n <= 8; n++) expect(out).toContain(`ln-${n}`)
+    expect(out).toContain('_✓ +2 earlier…_')
+    expect(out).toContain('**→ ln-8**') // newest last, bold in-progress
+    // Exactly 6 rendered step bullets (the +N header is not a bullet).
+    expect((out.match(/ln-\d/g) ?? []).length).toBe(6)
   })
 
   it('strips the CONTENT Markdown markup (the card keeps its own ** / _ wrappers, #2669)', () => {
@@ -457,7 +471,7 @@ describe('createWorkerActivityFeed', () => {
     expect(last.text.match(/[✓→]/g) ?? []).toHaveLength(1)
   })
 
-  it('rolls the narrative block to the last STATUS_ROLLING_LINES lines', async () => {
+  it('rolls the narrative block to the last WORKER_HISTORY_MAX lines (#3349)', async () => {
     const bot = makeFakeBot()
     let clock = 10_000
     const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
@@ -469,12 +483,34 @@ describe('createWorkerActivityFeed', () => {
     }
 
     const last = bot.edits.at(-1)!
-    expect(last.text.match(/[✓→]/g) ?? []).toHaveLength(STATUS_ROLLING_LINES)
-    const firstVisible = total - STATUS_ROLLING_LINES + 1
+    expect(last.text.match(/[✓→]/g) ?? []).toHaveLength(WORKER_HISTORY_MAX)
+    const firstVisible = total - WORKER_HISTORY_MAX + 1
     for (let i = 1; i < firstVisible; i++) expect(last.text).not.toContain(`ln-${String(i).padStart(3, '0')}`)
     for (let i = firstVisible; i <= total; i++) expect(last.text).toContain(`ln-${String(i).padStart(3, '0')}`)
   })
 
+  it('the deeper 6-step trail does NOT add edits — one landed render per substantive step (#3349, no #3270 flood)', async () => {
+    // Render-only change: edit frequency is a function of SUBSTANTIVE changes
+    // (new narrative step), never of how many trail lines a render carries. Push
+    // 8 distinct steps to a lone worker; with the edit floor at 0 exactly one
+    // render lands per step: 1 send + 7 edits = 8 landed renders, regardless of
+    // the 6-line trail depth. A widened window that re-fired edits would break
+    // this (that is the #3270 flood we must not reintroduce).
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+    for (let i = 1; i <= 8; i++) {
+      clock += 1000
+      await feed.update('w1', 'chat', view({ toolCount: i, latestSummary: `edit-step-${i}` }))
+    }
+    expect(bot.sent).toHaveLength(1)
+    expect(bot.edits).toHaveLength(7)
+    // Re-pushing the SAME newest step (no substance change) fires NO extra edit.
+    clock += 1000
+    await feed.update('w1', 'chat', view({ toolCount: 8, latestSummary: 'edit-step-8' }))
+    expect(bot.edits).toHaveLength(7)
+  })
+
   it('grows the narrative even while throttled (line surfaces on next edit)', async () => {
     const bot = makeFakeBot()
     let clock = 10_000
@@ -576,10 +612,10 @@ describe('createWorkerActivityFeed — log sink', () => {
 // char-budget backstop is the only wire-limit ceiling.
 
 describe('rolling window + STATUS_LINE_MAX — renderWorkerActivity', () => {
-  it('with 12 narrative lines, exactly the last STATUS_ROLLING_LINES render + a +N earlier header', () => {
+  it('with 12 narrative lines, exactly the last WORKER_HISTORY_MAX render + a +N earlier header (#3349)', () => {
     const narrativeLines = Array.from({ length: 12 }, (_, i) => `stp-${String(i + 1).padStart(3, '0')}`)
     const out = renderWorkerActivity(view({ narrativeLines }))
-    const firstVisible = 12 - STATUS_ROLLING_LINES + 1
+    const firstVisible = 12 - WORKER_HISTORY_MAX + 1
     for (let i = firstVisible; i <= 12; i++) {
       expect(out).toContain(`stp-${String(i).padStart(3, '0')}`)
     }
@@ -587,7 +623,7 @@ describe('rolling window + STATUS_LINE_MAX — renderWorkerActivity', () => {
       expect(out).not.toContain(`stp-${String(i).padStart(3, '0')}`)
     }
     // Overflow header now appears on the worker surface too.
-    expect(out).toContain(`_✓ +${12 - STATUS_ROLLING_LINES} earlier…_`)
+    expect(out).toContain(`_✓ +${12 - WORKER_HISTORY_MAX} earlier…_`)
     expect(out).toContain('**→ stp-012**')
   })
 
@@ -623,7 +659,7 @@ describe('rolling window + STATUS_LINE_MAX — renderWorkerActivity', () => {
 })
 
 describe('rolling window — createWorkerActivityFeed narrative accumulation', () => {
-  it('with 12 pushes, only the last STATUS_ROLLING_LINES appear in the render', async () => {
+  it('with 12 pushes, only the last WORKER_HISTORY_MAX appear in the render (#3349)', async () => {
     const bot = makeFakeBot()
     let clock = 10_000
     const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
@@ -634,16 +670,16 @@ describe('rolling window — createWorkerActivityFeed narrative accumulation', (
     }
 
     const last = bot.edits.at(-1)!
-    const firstVisible = 12 - STATUS_ROLLING_LINES + 1
+    const firstVisible = 12 - WORKER_HISTORY_MAX + 1
     for (let i = firstVisible; i <= 12; i++) {
       expect(last.text).toContain(`ln-${String(i).padStart(3, '0')}`)
     }
     for (let i = 1; i < firstVisible; i++) {
       expect(last.text).not.toContain(`ln-${String(i).padStart(3, '0')}`)
     }
-    // The manager caps the in-memory narrative at STATUS_ROLLING_LINES, so the
+    // The manager caps the in-memory narrative at WORKER_HISTORY_MAX, so the
     // render never sees overflow — no "+N earlier…" marker on the manager path
-    // (it surfaces only on direct renderWorkerActivity calls with >5 lines).
+    // (it surfaces only on direct renderWorkerActivity calls with >6 lines).
     expect(last.text).not.toContain('earlier…')
     expect(last.text).toContain('**→ ln-012**')
   })
@@ -1027,6 +1063,37 @@ describe('createWorkerActivityFeed — resurrection guard + deferred finalize',
     expect(bot.sent[1].text).toContain('back to work')
   })
 
+  it('#3373: a GENUINE terminal then a SendMessage resume re-surfaces a live card (resurrect+update), while an un-resumed terminal stays dead', async () => {
+    const bot = makeFakeBot()
+    let clock = 10_000
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+
+    // Worker runs, then GENUINELY completes (a real turn_end handback) — the
+    // row is dropped and the agentId latched into the terminal `finalized` gate.
+    await feed.update('w1', 'chat', view({ toolCount: 1, latestSummary: 'step one' }))
+    await feed.finish('w1', view({ state: 'done', toolCount: 1, latestSummary: 'real result' }))
+    expect(feed.has('w1')).toBe(false)
+
+    // Anti-zombie: with NO resume signal, later cues stay swallowed forever — a
+    // genuinely-finished worker must never zombie-resurface on a stray tick.
+    clock = 12_000
+    await feed.update('w1', 'chat', view({ toolCount: 2, latestSummary: 'stray tick' }))
+    expect(bot.sent).toHaveLength(1)
+    expect(feed.has('w1')).toBe(false)
+
+    // Now the worker is RESUMED via SendMessage: the watcher observes jsonl
+    // growth past the terminal boundary (#3315) and fires onResume, which the
+    // gateway wires to feed.resurrect — clearing the finalized latch.
+    feed.resurrect('w1')
+
+    // The resumed worker's next progress cue re-surfaces a fresh live card.
+    clock = 13_000
+    await feed.update('w1', 'chat', view({ toolCount: 3, latestSummary: 'resumed work' }))
+    expect(bot.sent).toHaveLength(2)
+    expect(feed.has('w1')).toBe(true)
+    expect(bot.sent[1].text).toContain('resumed work')
+  })
+
   it('#3023: resurrect() on a never-finalized worker is a harmless no-op', () => {
     const bot = makeFakeBot()
     const feed = createWorkerActivityFeed({ bot, now: () => 10_000 })
@@ -1337,8 +1404,8 @@ describe('narrative dedup — non-adjacent repeats collapse (A,B,A)', () => {
     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++) {
+    // Push WORKER_HISTORY_MAX distinct lines so 'step-repeat' scrolls out (#3349).
+    for (let i = 0; i < WORKER_HISTORY_MAX; i++) {
       clock += 1000
       await feed.update('w2', 'chat', view({ latestSummary: `filler-${i}` }))
     }

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

@@ -186,12 +186,20 @@ describe('coalesced worker feed — one message per chat under load', () => {
     // would shed ~ (N-1)/N of every second's cosmetic edits.
     expect(gate.stats().global.shed).toBeLessThanOrEqual(3)
 
-    // Liveness: the LAST landed edit carries EVERY worker's latest step — all
-    // rows refreshed together in the one message within one edit cycle.
+    // Liveness + bounded card (#3349): under Ken's curve every SHOWN worker
+    // keeps depth 3, so a 15-way storm cannot render every row — the 24-line
+    // body ceiling collapses the newest rows into a `+N more working…` spill.
+    // The last landed edit still carries the VISIBLE workers' latest steps
+    // (refreshed together in the one message) and a spill marker for the rest.
     const lastBody = edits[edits.length - 1].text
-    for (const id of ids) {
-      expect(lastBody).toContain(latest[id])
+    // 6 rows fit the 24-line budget (6·(1 header + 3 depth) = 24); the oldest
+    // rows (w0…w5) stay visible, the 9 newest spill.
+    for (let i = 0; i < 6; i++) {
+      expect(lastBody).toContain(latest[`w${i}`])
     }
+    expect(lastBody).toContain('more working')
+    // Still exactly ONE message — the spill is a render detail, not a new send.
+    expect(sends.length).toBe(1)
   })
 
   it('admits a critical reply mid-storm (never shed or starved by the cosmetic feed)', async () => {
@@ -722,21 +730,23 @@ describe('renderCombinedWorkerFeed (pure)', () => {
     expect(body).toContain('b first')
   })
 
-  it('degrades to ONE history line per worker at a large fan-out and stays within the body budget', () => {
+  it('holds the MIN_WORKER_DEPTH (3) floor per shown worker at a large fan-out and stays within the body budget (#3349)', () => {
+    // 6 workers each with a deep (5-line) history. Ken's curve pins depth=3 at
+    // 4+ workers, so every SHOWN worker paints its last 3 steps. 6·(1 header +
+    // 3 history) = 24 lines = MAX_COMBINED_BODY_LINES, so all 6 stay visible.
     const rows = Array.from({ length: 6 }, (_, i) =>
-      rowH(i, [`w${i} oldest`, `w${i} middle`, `w${i} newest`]),
+      rowH(i, [`w${i} s1`, `w${i} s2`, `w${i} s3`, `w${i} s4`, `w${i} s5`]),
     )
     const body = renderCombinedWorkerFeed(rows, { maxRows: 8 })!
-    // Only the newest step of each worker survives — the earlier lines are
-    // dropped by the per-worker depth clamp (floor((13-6)/6)=1).
     for (let i = 0; i < 6; i++) {
-      expect(body).toContain(current(`w${i} newest`))
-      expect(body).not.toContain(`w${i} oldest`)
-      expect(body).not.toContain(`w${i} middle`)
+      // Last 3 steps shown; the two oldest dropped by the depth-3 window.
+      expect(body).toContain(current(`w${i} s5`))
+      expect(body).toContain(struck(`w${i} s4`))
+      expect(body).toContain(struck(`w${i} s3`))
+      expect(body).not.toContain(`w${i} s1`)
+      expect(body).not.toContain(`w${i} s2`)
     }
-    // Total body lines (worker headers + history) stay within the budget: 6
-    // header lines + 6 history lines = 12 ≤ MAX_COMBINED_BODY_LINES (13). Count
-    // only the per-worker body lines (exclude the top count line + any spill).
+    // Body lines (worker headers + history) stay within the re-derived budget.
     const bodyLines = body
       .split('\n')
       .map((l) => l.trim())
@@ -744,15 +754,137 @@ describe('renderCombinedWorkerFeed (pure)', () => {
     const headerAndHistory = bodyLines.filter(
       (l) => !l.startsWith('🛠') && !l.includes('more working'),
     )
-    expect(headerAndHistory.length).toBeLessThanOrEqual(13)
+    expect(headerAndHistory.length).toBeLessThanOrEqual(24)
   })
 
-  it('exposes the deterministic depth formula (2→5, 3→3, 4→2, 6→1)', () => {
+  it('drops NEWEST (trailing) rows into the spill when the fan-out overflows the 24-line body budget, keeping per-worker depth at 3 (#3349)', () => {
+    // 8 workers × (1 header + 3 depth) = 32 > 24 → the backstop collapses the 2
+    // newest (trailing) visible rows into `+M more working…`, so 6 rows render at full
+    // depth-3 (24 lines) rather than every worker losing a step.
+    const rows = Array.from({ length: 8 }, (_, i) =>
+      rowH(i, [`w${i} s1`, `w${i} s2`, `w${i} s3`]),
+    )
+    const body = renderCombinedWorkerFeed(rows, { maxRows: 8 })!
+    expect(body).toContain('more working')
+    const bodyLines = body
+      .split('\n')
+      .map((l) => l.trim())
+      .filter((l) => l.length > 0)
+    const headerAndHistory = bodyLines.filter(
+      (l) => !l.startsWith('🛠') && !l.includes('more working'),
+    )
+    expect(headerAndHistory.length).toBeLessThanOrEqual(24)
+    expect(body).toContain('+2 more working')
+    // The 6 kept rows render at full depth-3 (last row kept shows all 3 steps).
+    expect(body).toContain(current('w5 s3'))
+    expect(body).toContain(struck('w5 s2'))
+    expect(body).toContain(struck('w5 s1'))
+    // The 2 trailing rows spilled — none of worker 7's lines render.
+    expect(body).not.toContain('w7 s3')
+  })
+
+  it("exposes Ken's deterministic depth curve max(3, 7−w): 1→6, 2→5, 3→4, 4→3, 5+→3 (#3349)", () => {
+    expect(combinedHistoryDepth(1)).toBe(6)
     expect(combinedHistoryDepth(2)).toBe(5)
-    expect(combinedHistoryDepth(3)).toBe(3)
-    expect(combinedHistoryDepth(4)).toBe(2)
-    expect(combinedHistoryDepth(6)).toBe(1)
-    expect(combinedHistoryDepth(8)).toBe(1)
+    expect(combinedHistoryDepth(3)).toBe(4)
+    expect(combinedHistoryDepth(4)).toBe(3)
+    expect(combinedHistoryDepth(5)).toBe(3)
+    expect(combinedHistoryDepth(6)).toBe(3)
+    expect(combinedHistoryDepth(8)).toBe(3)
+  })
+
+  // ── Worker numbering (#3298): stable ordinal prefix at 2+ workers ──────────
+  const rowN = (i: number, ordinal: number) => ({ ...row(i, `step ${i}`), ordinal })
+
+  it('numbers the workers with a literal "N. " prefix inside the bold header when 2+ run', () => {
+    const body = renderCombinedWorkerFeed([rowN(1, 1), rowN(2, 2)], { maxRows: 8 })!
+    // The literal `1. ` must survive markdown rendering, inside the bold span
+    // before the escaped description.
+    expect(body).toContain('**1. task number 1**')
+    expect(body).toContain('**2. task number 2**')
+  })
+
+  it('renders non-contiguous ordinals as-is (survivors keep their numbers after a finish)', () => {
+    // Worker 1 finished upstream — the surviving rows arrive with their
+    // ORIGINAL ordinals. Positional numbering would render 1./2. here; the
+    // stable scheme must render 2./3. and never a `1. `.
+    const body = renderCombinedWorkerFeed([rowN(2, 2), rowN(3, 3)], { maxRows: 8 })!
+    expect(body).toContain('**2. task number 2**')
+    expect(body).toContain('**3. task number 3**')
+    expect(body).not.toContain('**1. ')
+  })
+
+  it('a single row is never numbered, even when it carries an ordinal', () => {
+    const body = renderCombinedWorkerFeed([rowN(1, 1)], { maxRows: 8 })!
+    expect(body).toContain('**task number 1**')
+    expect(body).not.toContain('**1. ')
+  })
+
+  it('rows without ordinals render unnumbered (back-compat for direct callers)', () => {
+    const body = renderCombinedWorkerFeed([row(1, 'alpha'), row(2, 'beta')], { maxRows: 8 })!
+    expect(body).toContain('**task number 1**')
+    expect(body).toContain('**task number 2**')
+    expect(body).not.toContain('1. task')
+  })
+
+  it('spilled rows take their ordinals with them; visible ordinals do not shift', () => {
+    const rows = Array.from({ length: 10 }, (_, i) => rowN(i + 1, i + 1))
+    const body = renderCombinedWorkerFeed(rows, { maxRows: 4 })!
+    expect(body).toContain('+6 more working')
+    for (let n = 1; n <= 4; n++) expect(body).toContain(`**${n}. task number ${n}**`)
+    expect(body).not.toContain('**5. ')
+  })
+})
+
+// ── #3349: Ken's per-worker depth curve 6/5/4/3, exact rendered depth ─────────
+describe("Ken's per-worker step-trail depth curve (#3349)", () => {
+  // A worker with a DEEP history (8 lines) so the depth curve — not the buffer —
+  // is always the binding limit. Each history line is uniquely tokenised
+  // (`w{i}-s{n}`) so we can count exactly how many of a worker's steps rendered.
+  const deepRow = (i: number) => ({
+    description: `task w${i}`,
+    elapsedMs: 12_000 + i * 1000,
+    toolCount: 3,
+    ordinal: i + 1,
+    currentStep: `w${i}-s8`,
+    historyLines: Array.from({ length: 8 }, (_, n) => `w${i}-s${n + 1}`),
+  })
+  // Count how many of worker `i`'s step tokens appear in the rendered body.
+  const shownSteps = (body: string, i: number): number =>
+    (body.match(new RegExp(`w${i}-s\\d`, 'g')) ?? []).length
+
+  it.each([
+    [1, 6],
+    [2, 5],
+    [3, 4],
+    [4, 3],
+    [5, 3],
+  ])('%i worker(s) → exactly %i steps rendered per worker', (workers, expectedDepth) => {
+    const rows = Array.from({ length: workers }, (_, i) => deepRow(i))
+    const body = renderCombinedWorkerFeed(rows, { maxRows: 8 })!
+    expect(combinedHistoryDepth(workers)).toBe(expectedDepth)
+    for (let i = 0; i < workers; i++) {
+      expect(shownSteps(body, i)).toBe(expectedDepth)
+    }
+    // Newest step last (bottom-anchored → bold), oldest rendered step struck.
+    const worker0 = `**→ w0-s8**`
+    expect(body).toContain(worker0)
+  })
+
+  it('a worker with FEWER steps than the depth shows all it has, no padding', () => {
+    // 3 workers → depth 4, but this worker only has 2 steps: render both, no more.
+    const rows = [
+      { description: 'shallow', elapsedMs: 12_000, toolCount: 1, ordinal: 1,
+        currentStep: 'only-b', historyLines: ['only-a', 'only-b'] },
+      deepRow(1),
+      deepRow(2),
+    ]
+    const body = renderCombinedWorkerFeed(rows, { maxRows: 8 })!
+    expect(combinedHistoryDepth(3)).toBe(4)
+    expect(body).toContain('~~_✓ only-a_~~')
+    expect(body).toContain('**→ only-b**')
+    // Deep workers still get their full 4.
+    expect(shownSteps(body, 1)).toBe(4)
   })
 })
 
@@ -1019,3 +1151,87 @@ describe('worker-feed ghost-leak — deterministic terminal removal + backstop',
     expect(edits.length).toBe(afterPaint)
   })
 })
+
+describe('worker numbering — stable per-card ordinals end to end (#3298)', () => {
+  const doneView = (desc: string, elapsedMs: number): WorkerActivityView => ({
+    description: desc,
+    lastTool: null,
+    toolCount: 3,
+    latestSummary: `${desc} result`,
+    elapsedMs,
+    state: 'done',
+  })
+  const lastBody = (h: { sends: { text: string }[]; edits: { messageId: number; text: string }[] }): string => {
+    if (h.edits.length > 0) return h.edits[h.edits.length - 1].text
+    return h.sends[h.sends.length - 1].text
+  }
+
+  it('assigns 1./2./3. at dispatch and survivors KEEP their numbers when an earlier worker finishes', async () => {
+    let clock = 1000
+    const h = ghostHarness({ now: () => clock })
+    await h.feed.update('a', 'chat', view('task alpha', 'a-doing', 0))
+    await h.feed.update('b', 'chat', view('task beta', 'b-doing', 0))
+    await h.feed.update('c', 'chat', view('task gamma', 'c-doing', 0))
+    await drain()
+
+    let body = lastBody(h)
+    expect(body).toContain('**1. task alpha**')
+    expect(body).toContain('**2. task beta**')
+    expect(body).toContain('**3. task gamma**')
+
+    // Worker 1 finishes: the survivors must STILL be 2. and 3. — positional
+    // numbering would renumber them 1./2. and this assertion would fail.
+    clock = 2000
+    await h.feed.finish('a', doneView('task alpha', 1000))
+    await drain()
+    body = lastBody(h)
+    expect(body).toContain('2 running')
+    expect(body).toContain('**2. task beta**')
+    expect(body).toContain('**3. task gamma**')
+    expect(body).not.toContain('**1. ')
+  })
+
+  it('a single running worker is never numbered (single-worker layout)', async () => {
+    const h = ghostHarness({ now: () => 1000 })
+    await h.feed.update('solo', 'chat', view('task solo', 'working', 0))
+    await drain()
+    const body = lastBody(h)
+    expect(body).toContain('task solo')
+    expect(body).not.toContain('1. task solo')
+  })
+
+  it('a fresh card after ALL workers finish numbers from 1 again', async () => {
+    let clock = 1000
+    const h = ghostHarness({ now: () => clock })
+    await h.feed.update('a', 'chat', view('task alpha', 'a-doing', 0))
+    await h.feed.update('b', 'chat', view('task beta', 'b-doing', 0))
+    await drain()
+    clock = 2000
+    await h.feed.finish('a', doneView('task alpha', 1000))
+    await h.feed.finish('b', doneView('task beta', 1000))
+    await drain()
+    expect(h.feed.size).toBe(0)
+
+    // New fan-out in the same chat → a NEW card that starts at 1., not 3.
+    clock = 3000
+    await h.feed.update('c', 'chat', view('task gamma', 'c-doing', 0))
+    await h.feed.update('d', 'chat', view('task delta', 'd-doing', 0))
+    await drain()
+    const body = lastBody(h)
+    expect(body).toContain('**1. task gamma**')
+    expect(body).toContain('**2. task delta**')
+  })
+
+  it('introducing ordinals causes no dedup churn (same substance → edit still skipped)', async () => {
+    const h = ghostHarness({ now: () => 1000 })
+    await h.feed.update('a', 'chat', view('task alpha', 'same step', 0))
+    await h.feed.update('b', 'chat', view('task beta', 'same step', 0))
+    await drain()
+    const landed = h.edits.length
+    // Byte-identical substance re-update: the dedup/no-op skip must still fire
+    // (a stable ordinal never varies the substance between identical renders).
+    await h.feed.update('a', 'chat', view('task alpha', 'same step', 0))
+    await drain()
+    expect(h.edits.length).toBe(landed)
+  })
+})