switchroom 0.19.26 → 0.19.28

package/telegram-plugin/tests/mcp-credential-failure.test.ts

@@ -0,0 +1,310 @@
+/**
+ * mcp-credential-failure.test.ts — outcome tests for "a paid MCP dependency's
+ * key is blocked → Ken gets ONE hard warning".
+ *
+ * THE GAP. Perplexity (and Eraser, Brevo, Postiz, Meta/Google Ads, Cloudflare)
+ * reach switchroom over the MCP TOOL surface, never through LiteLLM. So the
+ * operator-event path that PR A fixed for an OpenRouter 402 never sees them: an
+ * expired Perplexity key surfaced as an ordinary red step in the live feed and
+ * died there. Nobody was told the fleet had lost a paid capability.
+ *
+ * These assert the OBSERVABLE RESULT at the gateway seam, composing the SAME
+ * production functions in the SAME order `handleSessionEvent` →
+ * `noteMcpDependencyFailure` → `emitGatewayOperatorEvent` calls them:
+ * McpFailureWatcher.onToolUse/onToolResult → renderMcpFailureDetail →
+ * renderOperatorEvent → decideOperatorEventAudience →
+ * renderUserFacingFailureNotice.
+ *
+ * The three guarantees the brief names, each asserted end-to-end:
+ *   1. a credential-class MCP failure produces EXACTLY ONE operator alert with
+ *      the provider, the vault key NAME, the agents and the action;
+ *   2. a second agent failing the same way inside the window produces NO
+ *      second alert;
+ *   3. an ordinary tool error (bad query, 404, timeout, transient 429)
+ *      produces NONE.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  McpFailureWatcher,
+  McpFailureLedger,
+  classifyMcpFailure,
+  parseMcpServerFromToolName,
+  renderMcpFailureDetail,
+  RENOTIFY_MS,
+  type McpFailureAlert,
+} from '../mcp-credential-failure.js'
+import {
+  renderOperatorEvent,
+  decideOperatorEventAudience,
+  isOperatorActionableKind,
+  renderUserFacingFailureNotice,
+  type OperatorEvent,
+} from '../operator-events.js'
+
+// ── Verbatim vendor failure bodies ──────────────────────────────────────────
+
+/** Perplexity, key revoked / rejected. */
+const PPLX_401 =
+  '{"error":{"message":"Invalid API key provided.","type":"authentication_error","code":401}}'
+
+/** Perplexity, balance spent — 401 status, but the remedy is "top up". */
+const PPLX_NO_CREDIT =
+  'api.perplexity.ai responded with status 401: {"detail":"insufficient credits — please add funds to your account"}'
+
+/**
+ * Perplexity, hard monthly wall. Note the status is 429 — the SAME status as a
+ * transient throttle — so only the wording can tell the two apart, which is
+ * exactly why 429 is not in the quota rule's status list.
+ */
+const PPLX_QUOTA =
+  '{"error":{"message":"Monthly quota exceeded for your plan. Upgrade your plan to continue.","code":429}}'
+
+// ── Ordinary failures that must stay SILENT ─────────────────────────────────
+
+const ORDINARY_FAILURES: ReadonlyArray<[string, string]> = [
+  ['a bad query', 'Error: search query must not be empty'],
+  ['a 404', 'Request failed with status code 404: not found'],
+  ['a timeout', 'Error: ETIMEDOUT — request to api.perplexity.ai timed out after 30000ms'],
+  ['a transient throttle', '{"error":{"message":"Rate limit exceeded, retry after 2s","code":429}}'],
+  ['a transport reset', 'Error: socket hang up (ECONNRESET)'],
+  ['an upstream 5xx', 'Request failed with status code 503: service unavailable'],
+  ['no results', 'The search returned no results for that query.'],
+]
+
+const ALLOW = ['7000000001' /* operator */, '7000000002' /* end user */]
+const T0 = Date.UTC(2026, 6, 28, 10, 0, 0)
+
+/**
+ * One agent's gateway, driven exactly as `handleSessionEvent` drives it. The
+ * `alerts` array is what `emitGatewayOperatorEvent` would have been called with.
+ */
+function makeAgent(agent: string, watcher: McpFailureWatcher) {
+  const alerts: McpFailureAlert[] = []
+  let seq = 0
+  return {
+    alerts,
+    /** Drive one full MCP tool call that fails with `errorText`. */
+    fail(toolName: string, errorText: string, now: number): void {
+      const toolUseId = `toolu_${agent}_${seq++}`
+      watcher.onToolUse(toolUseId, toolName)
+      const alert = watcher.onToolResult({ toolUseId, isError: true, errorText, agent, now })
+      if (alert != null) alerts.push(alert)
+    },
+    /** A successful call — must never alert. */
+    succeed(toolName: string, now: number): void {
+      const toolUseId = `toolu_${agent}_${seq++}`
+      watcher.onToolUse(toolUseId, toolName)
+      const alert = watcher.onToolResult({ toolUseId, isError: false, agent, now })
+      if (alert != null) alerts.push(alert)
+    },
+  }
+}
+
+/** What the operator and a non-operator user actually receive for one alert. */
+function route(alert: McpFailureAlert): {
+  operatorText: string | null
+  operatorChats: string[]
+  userText: string | null
+  userChats: string[]
+  buttons: string[]
+} {
+  const ev: OperatorEvent = {
+    kind: 'mcp-dependency-blocked',
+    agent: alert.agents[0] ?? 'agent',
+    detail: renderMcpFailureDetail(alert),
+    suggestedActions: [],
+    firstSeenAt: new Date(T0),
+  }
+  const rendered = renderOperatorEvent(ev)
+  const { operatorChats, userNoticeChats } = decideOperatorEventAudience(ev.kind, ALLOW, ALLOW[0])
+  return {
+    operatorText: operatorChats.length > 0 ? rendered.text : null,
+    operatorChats,
+    userText: userNoticeChats.length > 0 ? renderUserFacingFailureNotice() : null,
+    userChats: userNoticeChats,
+    buttons: rendered.keyboard.inline_keyboard.flat().map(b => b.text),
+  }
+}
+
+describe('a blocked Perplexity key raises exactly one operator alert', () => {
+  it('produces ONE alert naming provider, vault key NAME, agent and action', () => {
+    const w = new McpFailureWatcher()
+    const klanker = makeAgent('klanker', w)
+
+    klanker.fail('mcp__perplexity__perplexity_search', PPLX_401, T0)
+
+    expect(klanker.alerts).toHaveLength(1)
+    const alert = klanker.alerts[0]
+    expect(alert.server).toBe('perplexity')
+    expect(alert.cls).toBe('credential')
+    expect(alert.agents).toEqual(['klanker'])
+    expect(alert.renotify).toBe(false)
+
+    const r = route(alert)
+
+    // Operator-only: the kind is actionable, so the user gets the brief notice.
+    expect(isOperatorActionableKind('mcp-dependency-blocked')).toBe(true)
+    expect(r.operatorChats).toEqual(['7000000001'])
+    expect(r.userChats).toEqual(['7000000002'])
+
+    // The card says what Ken can actually DO.
+    expect(r.operatorText).toContain('Perplexity')
+    expect(r.operatorText).toContain('perplexity/api-key') // vault key NAME
+    expect(r.operatorText).toContain('https://www.perplexity.ai/settings/api')
+    expect(r.operatorText).toContain('klanker')
+    expect(r.operatorText).toContain('Re-issue the key')
+    expect(r.buttons).toEqual(['❌ Dismiss'])
+
+    // NEVER a secret value, and never the raw provider error.
+    expect(r.operatorText).not.toContain('Invalid API key provided')
+    expect(r.operatorText).not.toMatch(/pplx-[A-Za-z0-9]/)
+
+    // The end user still sees only the diagnosis-free notice.
+    expect(r.userText).toBe(renderUserFacingFailureNotice())
+    for (const fragment of ['perplexity', '401', 'api key', 'authentication_error', 'vault']) {
+      expect(r.userText!.toLowerCase()).not.toContain(fragment)
+    }
+  })
+
+  it('routes a spent BALANCE to "top up", not to "re-issue the key"', () => {
+    const w = new McpFailureWatcher()
+    const a = makeAgent('klanker', w)
+    a.fail('mcp__perplexity__perplexity_ask', PPLX_NO_CREDIT, T0)
+    expect(a.alerts).toHaveLength(1)
+    // 401 status, but the credit wording must win — the key is fine, the
+    // account is empty, and re-issuing it would waste the operator's time.
+    expect(a.alerts[0].cls).toBe('credit')
+    expect(route(a.alerts[0]).operatorText).toContain('Top up the balance')
+  })
+
+  it('sees a hard wall wrapped in throttle language (429 + "rate limit")', () => {
+    // Providers routinely dress a monthly wall up as a rate limit. The wall is
+    // the real news; silencing it as a throttle would lose the capability
+    // quietly, which is the exact failure this whole feature exists to stop.
+    const w = new McpFailureWatcher()
+    const a = makeAgent('klanker', w)
+    a.fail(
+      'mcp__perplexity__perplexity_search',
+      'Rate limit exceeded — monthly quota exceeded for your plan (429)',
+      T0,
+    )
+    expect(a.alerts).toHaveLength(1)
+    expect(a.alerts[0].cls).toBe('quota')
+  })
+
+  it('routes a hard usage wall to the quota remedy', () => {
+    const w = new McpFailureWatcher()
+    const a = makeAgent('klanker', w)
+    a.fail('mcp__perplexity__perplexity_research', PPLX_QUOTA, T0)
+    expect(a.alerts).toHaveLength(1)
+    expect(a.alerts[0].cls).toBe('quota')
+    expect(route(a.alerts[0]).operatorText).toContain('Raise the plan limit')
+  })
+})
+
+describe('deduplication — a storm of failures is one alert, not a storm of alerts', () => {
+  it('a second agent failing the same way in the window produces NO second alert', () => {
+    // One shared watcher stands in for one gateway process seeing several
+    // agents/sub-agents; the cross-CONTAINER limit is documented in the module.
+    const w = new McpFailureWatcher()
+    const klanker = makeAgent('klanker', w)
+    const scribe = makeAgent('scribe', w)
+
+    klanker.fail('mcp__perplexity__perplexity_search', PPLX_401, T0)
+    scribe.fail('mcp__perplexity__perplexity_ask', PPLX_401, T0 + 1_000)
+    klanker.fail('mcp__perplexity__perplexity_search', PPLX_401, T0 + 30_000)
+
+    expect(klanker.alerts).toHaveLength(1)
+    expect(scribe.alerts).toHaveLength(0)
+  })
+
+  it('re-notifies after the 6h house cadence, and NAMES everyone seen since', () => {
+    const w = new McpFailureWatcher()
+    const klanker = makeAgent('klanker', w)
+    const scribe = makeAgent('scribe', w)
+
+    klanker.fail('mcp__perplexity__perplexity_search', PPLX_401, T0)
+    expect(klanker.alerts).toHaveLength(1)
+
+    // Silent for the whole window, however many failures land.
+    scribe.fail('mcp__perplexity__perplexity_ask', PPLX_401, T0 + RENOTIFY_MS - 1)
+    expect(scribe.alerts).toHaveLength(0)
+
+    // At the boundary it fires again, accumulating everyone seen meanwhile.
+    scribe.fail('mcp__perplexity__perplexity_ask', PPLX_401, T0 + RENOTIFY_MS)
+    expect(scribe.alerts).toHaveLength(1)
+    const repeat = scribe.alerts[0]
+    expect(repeat.renotify).toBe(true)
+    expect(repeat.agents).toEqual(['scribe'])
+    expect(repeat.occurrences).toBe(2)
+    expect(route(repeat).operatorText).toContain('still failing')
+  })
+
+  it('matches the house re-notify cadence used by the hindsight watcher', () => {
+    expect(RENOTIFY_MS).toBe(6 * 60 * 60 * 1000)
+  })
+
+  it('tracks credit and credential walls on the same server independently', () => {
+    const led = new McpFailureLedger()
+    expect(led.note({ server: 'perplexity', agent: 'a', cls: 'credential', now: T0 })).not.toBeNull()
+    // A different failure CLASS is a different problem with a different remedy,
+    // so it must not be silenced by the first one's window.
+    expect(led.note({ server: 'perplexity', agent: 'a', cls: 'credit', now: T0 })).not.toBeNull()
+  })
+})
+
+describe('ordinary tool failures never page the operator', () => {
+  for (const [label, body] of ORDINARY_FAILURES) {
+    it(`stays silent for ${label}`, () => {
+      const w = new McpFailureWatcher()
+      const a = makeAgent('klanker', w)
+      a.fail('mcp__perplexity__perplexity_search', body, T0)
+      expect(a.alerts).toEqual([])
+      expect(classifyMcpFailure(body)).toBe('ordinary')
+    })
+  }
+
+  it('stays silent for a SUCCESSFUL MCP call', () => {
+    const w = new McpFailureWatcher()
+    const a = makeAgent('klanker', w)
+    a.succeed('mcp__perplexity__perplexity_search', T0)
+    expect(a.alerts).toEqual([])
+  })
+
+  it('stays silent for a non-MCP tool that fails with auth-shaped text', () => {
+    // A Bash step printing "401 unauthorized" from some unrelated curl is NOT
+    // a fleet capability loss and must not page anyone.
+    const w = new McpFailureWatcher()
+    const a = makeAgent('klanker', w)
+    a.fail('Bash', 'curl: server returned status 401 unauthorized', T0)
+    expect(a.alerts).toEqual([])
+  })
+})
+
+describe('the rule is data, and it generalises past Perplexity', () => {
+  it('derives the server from any mcp__<server>__<tool> name', () => {
+    expect(parseMcpServerFromToolName('mcp__perplexity__perplexity_search')).toBe('perplexity')
+    expect(parseMcpServerFromToolName('mcp__meta-ads__list_campaigns')).toBe('meta-ads')
+    expect(parseMcpServerFromToolName('Read')).toBeNull()
+    expect(parseMcpServerFromToolName(undefined)).toBeNull()
+  })
+
+  it('covers other paid dependencies with no new code — Eraser, Brevo', () => {
+    const w = new McpFailureWatcher()
+    const a = makeAgent('klanker', w)
+    a.fail('mcp__eraser__create_diagram', '403 Forbidden: api key has been revoked', T0)
+    a.fail('mcp__brevo__send_email', '{"code":"unauthorized","message":"Key not found"}', T0)
+    expect(a.alerts.map(x => x.server)).toEqual(['eraser', 'brevo'])
+    expect(route(a.alerts[0]).operatorText).toContain('eraser/api-key')
+    expect(route(a.alerts[1]).operatorText).toContain('brevo/api-key')
+  })
+
+  it('an unregistered MCP server still alerts, with a conventional key name', () => {
+    const w = new McpFailureWatcher()
+    const a = makeAgent('klanker', w)
+    a.fail('mcp__somenewthing__do_it', '401 unauthorized: invalid api key', T0)
+    expect(a.alerts).toHaveLength(1)
+    expect(a.alerts[0].vaultKey).toBe('somenewthing/api-key')
+  })
+})

package/telegram-plugin/tests/outbox-sweep-flood-breaker.test.ts

@@ -0,0 +1,221 @@
+/**
+ * The outbox sweep must not hammer a flood ban it can already see (#3853).
+ *
+ * ── The bug these tests guard ────────────────────────────────────────────
+ * `startOutboxSweep` built its retry policy as `createRetryApiCall({ log })` —
+ * the ONE wiring in the tree with neither `floodWaitRemainingMs` (read the
+ * persisted breaker) nor `onFloodWait` (write to it). Combined with a fixed
+ * 5s tick and a catch that released the claim with no backoff, the sweep
+ * re-issued a single undeliverable `sendMessage` every 5 seconds for the whole
+ * of overlord's 15908s (4.4h) ban on 2026-07-27: 228 requests into a window
+ * the breaker had recorded and could have answered in one read.
+ *
+ * The gateway log is the proof and the shape of the outcome assertion:
+ *   grep -c 'flood window still open' gateway-supervisor.log  → 0
+ *   grep -c 'flood ban of'            gateway-supervisor.log  → 230
+ *   grep -c 'outbox-sweep: send failed'                       → 228
+ *
+ * Every test below asserts an OUTCOME — whether the wire was touched and
+ * whether the record survived — not that a code path executed.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  writeOutboxRecordAtomic,
+  listPendingRecords,
+  sha256Hex,
+  type OutboxRecord,
+} from '../outbox.js'
+import {
+  sweepOutbox,
+  createSweepBackoff,
+  OUTBOX_SWEEP_INTERVAL_MS,
+  OUTBOX_SWEEP_BACKOFF_MAX_MS,
+} from '../gateway/outbox-sweep.js'
+
+function rec(over: Partial<OutboxRecord> = {}): OutboxRecord {
+  const text = over.text ?? 'the answer the operator is waiting for'
+  return {
+    turnNonce: over.turnNonce ?? 'nonce-1',
+    chatId: over.chatId ?? '111',
+    threadId: over.threadId ?? null,
+    text,
+    textSha256: sha256Hex(text),
+    createdAt: over.createdAt ?? 0,
+    source: over.source ?? 'channel',
+  }
+}
+
+describe('outbox sweep vs an open flood window', () => {
+  let dir: string
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'outbox-flood-'))
+  })
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it('does not hit the wire while a flood window is open, and keeps the record', async () => {
+    writeOutboxRecordAtomic(rec(), dir)
+    const send = vi.fn(async () => 1)
+    const log = vi.fn()
+
+    const summary = await sweepOutbox({
+      stateDir: dir,
+      log,
+      send,
+      textAlreadyDelivered: () => false,
+      // 12247s remaining — the exact shape of the window the 2026-07-27 sweep
+      // ignored 228 times.
+      floodWaitRemainingMs: () => 12_247_000,
+      now: () => 10 * 60_000,
+    })
+
+    // THE outcome: nothing reached Telegram.
+    expect(send).not.toHaveBeenCalled()
+    expect(summary.floodDeferred).toBe(true)
+    expect(summary.floodRemainingMs).toBe(12_247_000)
+    expect(summary.delivered).toBe(0)
+    // And nothing was lost — the record is still pending for the next sweep.
+    expect(listPendingRecords(dir)).toHaveLength(1)
+    // The deferral is NOT logged per-tick — a 4.4h ban is ~3181 ticks, and one
+    // line each would relocate the flood from the wire to the disk. The tick
+    // loop reports it at most once per OUTBOX_SWEEP_DEFER_LOG_INTERVAL_MS.
+    expect(log).not.toHaveBeenCalled()
+  })
+
+  it('delivers the SAME record once the window closes', async () => {
+    writeOutboxRecordAtomic(rec(), dir)
+    const send = vi.fn(async () => 42)
+    let remaining = 12_247_000
+
+    const deferred = await sweepOutbox({
+      stateDir: dir,
+      send,
+      textAlreadyDelivered: () => false,
+      floodWaitRemainingMs: () => remaining,
+      now: () => 10 * 60_000,
+    })
+    expect(deferred.floodDeferred).toBe(true)
+    expect(send).not.toHaveBeenCalled()
+
+    remaining = 0
+    const after = await sweepOutbox({
+      stateDir: dir,
+      send,
+      textAlreadyDelivered: () => false,
+      floodWaitRemainingMs: () => remaining,
+      now: () => 20 * 60_000,
+    })
+
+    expect(send).toHaveBeenCalledTimes(1)
+    expect(send.mock.calls[0]?.[2]).toContain('the answer the operator is waiting for')
+    expect(after.delivered).toBe(1)
+    expect(listPendingRecords(dir)).toHaveLength(0)
+  })
+
+  it('sweeps normally when no window is open', async () => {
+    writeOutboxRecordAtomic(rec(), dir)
+    const send = vi.fn(async () => 7)
+    const summary = await sweepOutbox({
+      stateDir: dir,
+      send,
+      textAlreadyDelivered: () => false,
+      floodWaitRemainingMs: () => 0,
+      now: () => 10 * 60_000,
+    })
+    expect(send).toHaveBeenCalledTimes(1)
+    expect(summary.delivered).toBe(1)
+    expect(summary.floodDeferred).toBeUndefined()
+  })
+
+  it('FAILS OPEN: a throwing probe must never strand the outbox', async () => {
+    writeOutboxRecordAtomic(rec(), dir)
+    const send = vi.fn(async () => 7)
+    const summary = await sweepOutbox({
+      stateDir: dir,
+      send,
+      textAlreadyDelivered: () => false,
+      floodWaitRemainingMs: () => {
+        throw new Error('EACCES: flood-wait.json owned by another uid')
+      },
+      now: () => 10 * 60_000,
+    })
+    expect(send).toHaveBeenCalledTimes(1)
+    expect(summary.delivered).toBe(1)
+  })
+
+  it('reports send failures so the tick can back off', async () => {
+    writeOutboxRecordAtomic(rec(), dir)
+    const send = vi.fn(async () => {
+      throw new Error('FLOOD_WAIT_ACTIVE')
+    })
+    const summary = await sweepOutbox({
+      stateDir: dir,
+      send,
+      textAlreadyDelivered: () => false,
+      floodWaitRemainingMs: () => 0,
+      now: () => 10 * 60_000,
+    })
+    expect(summary.sendFailures).toBe(1)
+    expect(summary.delivered).toBe(0)
+    // Claim released — the record is still pending, never lost.
+    expect(listPendingRecords(dir)).toHaveLength(1)
+  })
+})
+
+describe('createSweepBackoff — the fixed-5s-forever regression', () => {
+  it('rides the normal tick on the FIRST failure, then doubles', () => {
+    const b = createSweepBackoff()
+    expect(b.ready(0)).toBe(true)
+
+    expect(b.noteFailure(0)).toBe(OUTBOX_SWEEP_INTERVAL_MS) // 5s
+    expect(b.ready(4_999)).toBe(false)
+    expect(b.ready(5_000)).toBe(true)
+
+    expect(b.noteFailure(5_000)).toBe(10_000)
+    expect(b.noteFailure(15_000)).toBe(20_000)
+    expect(b.noteFailure(35_000)).toBe(40_000)
+  })
+
+  it('caps the delay so the sweep never stops entirely', () => {
+    const b = createSweepBackoff()
+    let last = 0
+    for (let i = 0; i < 40; i++) last = b.noteFailure(i * 1_000_000)
+    expect(last).toBe(OUTBOX_SWEEP_BACKOFF_MAX_MS)
+  })
+
+  it('the 4.4h-ban scenario: ≤ 60 sweeps, not 228', () => {
+    // Replay the incident's shape — a persistently failing send across a
+    // 15908s window — and count how many sweeps the pacer would permit.
+    const b = createSweepBackoff()
+    const banMs = 15_908_000
+    let now = 0
+    let sweeps = 0
+    while (now < banMs) {
+      if (b.ready(now)) {
+        sweeps++
+        b.noteFailure(now)
+      }
+      now += OUTBOX_SWEEP_INTERVAL_MS
+    }
+    // Fixed 5s ticking would be 3181 attempts; the real sweep issued 228
+    // before the operator intervened. Exponential + cap keeps it under 60.
+    expect(sweeps).toBeLessThan(60)
+    expect(sweeps).toBeGreaterThan(0)
+  })
+
+  it('a successful sweep clears the backoff', () => {
+    const b = createSweepBackoff()
+    b.noteFailure(0)
+    b.noteFailure(5_000)
+    expect(b.ready(6_000)).toBe(false)
+    b.noteSuccess()
+    expect(b.ready(6_000)).toBe(true)
+    expect(b.failures()).toBe(0)
+  })
+})

package/telegram-plugin/tests/pinned-card-collapse.test.ts

@@ -33,7 +33,6 @@ import {
   STATUS_CARD_CHAR_BUDGET,
   STATUS_LINE_MAX,
   WORKER_STEP_INDENT,
-  SUBORDINATE_LINE_INDENT,
 } from '../status-no-truncate.js'
 
 /**
@@ -135,31 +134,28 @@ describe('combined worker card survives the pinned-bar collapse (#3666)', () =>
 
   it('kills the exact artifacts from the report', () => {
     const collapsed = collapsePreview(body)
-    // 1. the count/ordinal collision — glance line into row 1's ordinal.
-    //    Since #3820 a worker header also carries the card-level
-    //    SUBORDINATE_LINE_INDENT (the whole worker card nests under the 🤖
-    //    agent card), so this seam is separator + card indent.
+    // 1. the count/ordinal collision — glance line into row 1's ordinal. Since
+    //    #3842 the row header is FLUSH (the #3820 card-level indent is gone),
+    //    so the separator is the ONLY thing holding this seam apart.
     //    (The reported spelling was `3 running1.`; with the packed glance line
     //    the same seam now reads `… 512.3k tok` -> `1. Fix issue`, so assert on
     //    the CURRENT last token of line 1 — an assertion on the old spelling
     //    alone would be vacuously green.)
     expect(collapsed).not.toContain('running1.')
     expect(collapsed).not.toContain('tok1.')
-    expect(collapsed).toContain(`tok${NB}${SUBORDINATE_LINE_INDENT}1. Fix issue`)
-    // 2. the mid-word ✓ (model tag running into the step trail). Here the
-    //    separator and WORKER_STEP_INDENT (three U+2800 leading a step line)
-    //    stack, so the seam is separator + indent, asserted against both
-    //    constants rather than a hardcoded run of spaces.
+    expect(collapsed).toContain(`tok${NB}1. Fix issue`)
+    // 2. the mid-word ✓ (model tag running into the step trail). A step line
+    //    still leads with WORKER_STEP_INDENT (three U+2800), so this seam is
+    //    separator + step indent — asserted against the constant rather than a
+    //    hardcoded run.
     expect(collapsed).not.toContain('opus 5✓')
-    expect(collapsed).toContain(`opus 5${NB}${SUBORDINATE_LINE_INDENT}${WORKER_STEP_INDENT}✓`)
+    expect(collapsed).toContain(`opus 5${NB}${WORKER_STEP_INDENT}✓`)
     // 3. the step trail running into the next step, and into the next row's
-    //    header (post-#3820 that last seam is separator + card indent).
+    //    header (post-#3842 that last seam is the separator alone).
     expect(collapsed).not.toContain('gateway.ts→')
-    expect(collapsed).toContain(
-      `gateway.ts${NB}${SUBORDINATE_LINE_INDENT}${WORKER_STEP_INDENT}→`,
-    )
+    expect(collapsed).toContain(`gateway.ts${NB}${WORKER_STEP_INDENT}→`)
     expect(collapsed).not.toContain('search2.')
-    expect(collapsed).toContain(`search${NB}${SUBORDINATE_LINE_INDENT}2.`)
+    expect(collapsed).toContain(`search${NB}2.`)
   })
 
   it('leads with a self-contained glance that ends in a unit word, not a bare number', () => {
@@ -178,13 +174,10 @@ describe('combined worker card survives the pinned-bar collapse (#3666)', () =>
     // show the collapsed preview mashes again. Without this, the assertions
     // above could all be passing for reasons unrelated to the fix.
     //
-    // The control runs on the 🤖 AGENT card, not the worker card: since #3820
-    // every line of a worker card after line 1 carries a leading
-    // SUBORDINATE_LINE_INDENT, which separates its seams independently of the
-    // collapse separator — so a worker-card control would no longer isolate the
-    // separator's contribution. The agent card is the surface where the
-    // separator is still the ONLY thing holding the seams apart, which is
-    // exactly what this control must measure.
+    // The control runs on the 🤖 AGENT card. Post-#3842 the single-worker card
+    // is flush too, so either would isolate the separator's contribution; the
+    // agent card is kept because it has no step indent on ANY line, so no
+    // future indent change can quietly make this control vacuous.
     const agent = renderActivityFeed([
       'Reading gateway.ts',
       'Searching memory',
@@ -228,7 +221,9 @@ describe('single-worker / agent status card survives the collapse too (#3666)',
     expectNoMashedSeams(body)
     const collapsed = collapsePreview(body)
     expect(collapsed).not.toContain('toolsstarting')
-    expect(collapsed).toContain(`0 tools${NB}${SUBORDINATE_LINE_INDENT}starting`)
+    // #3842: the single-worker card is flush, so the separator alone holds the
+    // hand-rolled `starting…` seam apart — nothing else masks a regression.
+    expect(collapsed).toContain(`0 tools${NB}starting`)
   })
 
   it('the nested child block stays separated even though its indent is ASCII (#3668)', () => {