switchroom 0.16.28 → 0.16.38

package/telegram-plugin/tests/voice-transcribe-sidecar.test.ts

@@ -0,0 +1,332 @@
+/**
+ * Unit tests for the LOCAL STT sidecar transcription path (voice PR-B2):
+ *   - transcribeViaSidecar (HTTP POST to /stt, mocked fetch)
+ *   - materializeSidecarToken (vault resolution, mocked broker)
+ *
+ * Mirrors the cloud twin's test (voice-transcribe.test.ts): every error
+ * reason is pinned so a refactor can't silently change the contract the
+ * gateway depends on (any non-ok → null → "(voice message)" fallback).
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  transcribeViaSidecar,
+  SIDECAR_MAX_BYTES,
+  DEFAULT_SIDECAR_BASE_URL,
+} from '../voice-transcribe-sidecar.js'
+import {
+  materializeSidecarToken,
+  DEFAULT_VOICE_SIDECAR_TOKEN_REF,
+  VOICE_SIDECAR_TOKEN_KEY,
+} from '../../src/telegram/materialize-sidecar-token.js'
+import type { resolveVaultReferencesViaBroker } from '../../src/vault/resolver.js'
+import type { SwitchroomConfig } from '../../src/config/schema.js'
+
+const SMALL_AUDIO = new Uint8Array([0x4f, 0x67, 0x67, 0x53]) // OggS magic
+
+function makeFetch(status: number, body: unknown): typeof fetch {
+  return (async () => ({
+    ok: status >= 200 && status < 300,
+    status,
+    json: async () => body,
+    text: async () => (typeof body === 'string' ? body : JSON.stringify(body)),
+    headers: new Headers(),
+  })) as unknown as typeof fetch
+}
+
+describe('transcribeViaSidecar — pre-flight checks', () => {
+  it('returns no-token when token is empty', async () => {
+    const r = await transcribeViaSidecar({
+      token: '',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      fetchImpl: makeFetch(200, { ok: true, text: 'x' }),
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'no-token' })
+  })
+
+  it('returns audio-too-short on empty audio', async () => {
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: new Uint8Array(0),
+      filename: 'voice.ogg',
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'audio-too-short' })
+  })
+
+  it('returns audio-too-large above the cap', async () => {
+    const tooBig = new Uint8Array(SIDECAR_MAX_BYTES + 1)
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: tooBig,
+      filename: 'voice.ogg',
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'audio-too-large' })
+  })
+})
+
+describe('transcribeViaSidecar — happy path', () => {
+  it('returns transcript on 200 + valid JSON', async () => {
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      fetchImpl: makeFetch(200, {
+        ok: true,
+        text: 'Hello world',
+        language: 'en',
+        durationMs: 1234,
+        audioSeconds: 3.2,
+      }),
+    })
+    expect(r.ok).toBe(true)
+    if (r.ok) {
+      expect(r.text).toBe('Hello world')
+      expect(r.language).toBe('en')
+      expect(r.durationMs).toBe(1234)
+      expect(r.audioSeconds).toBe(3.2)
+    }
+  })
+
+  it('sends the X-Voice-Token header, audio + language fields, to <base>/stt', async () => {
+    let receivedUrl = ''
+    let receivedToken: string | null = null
+    let receivedForm: FormData | null = null
+    const fakeFetch: typeof fetch = (async (url: string, init?: RequestInit) => {
+      receivedUrl = url
+      receivedToken = (init?.headers as Record<string, string>)['X-Voice-Token']
+      receivedForm = init?.body as FormData
+      return {
+        ok: true,
+        status: 200,
+        json: async () => ({ ok: true, text: 'bonjour' }),
+        text: async () => '',
+        headers: new Headers(),
+      }
+    }) as unknown as typeof fetch
+
+    const r = await transcribeViaSidecar({
+      token: 'secret-token',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      language: 'fr',
+      fetchImpl: fakeFetch,
+    })
+    expect(r.ok).toBe(true)
+    expect(receivedUrl).toBe(`${DEFAULT_SIDECAR_BASE_URL}/stt`)
+    expect(receivedToken).toBe('secret-token')
+    expect(receivedForm).not.toBeNull()
+    expect(receivedForm!.get('language')).toBe('fr')
+    expect(receivedForm!.get('audio')).not.toBeNull()
+  })
+
+  it('falls back to wall-clock durationMs when the sidecar omits it', async () => {
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      fetchImpl: makeFetch(200, { ok: true, text: 'hi' }),
+    })
+    expect(r.ok).toBe(true)
+    if (r.ok) {
+      expect(r.durationMs).toBeGreaterThanOrEqual(0)
+      expect(r.audioSeconds).toBeNull()
+    }
+  })
+})
+
+describe('transcribeViaSidecar — error paths', () => {
+  it('returns http-401 on a wrong/missing token (sidecar rejects)', async () => {
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      fetchImpl: makeFetch(401, { ok: false, reason: 'unauthorized' }),
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'http-401' })
+  })
+
+  it('surfaces the sidecar reason on a 2xx { ok: false } body', async () => {
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      fetchImpl: makeFetch(200, { ok: false, reason: 'gpu-timeout', detail: 'busy' }),
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'gpu-timeout' })
+  })
+
+  it('returns malformed-response when 200 body has no text field', async () => {
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      fetchImpl: makeFetch(200, { ok: true, unexpected: 'shape' }),
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'malformed-response' })
+  })
+
+  it('returns fetch-failed on a thrown network error', async () => {
+    const fakeFetch: typeof fetch = (async () => {
+      throw new Error('ECONNREFUSED')
+    }) as unknown as typeof fetch
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      fetchImpl: fakeFetch,
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'fetch-failed' })
+    expect(r.detail).toContain('ECONNREFUSED')
+  })
+
+  it('returns timeout when fetch is aborted', async () => {
+    const fakeFetch: typeof fetch = (async () => {
+      throw new Error('The operation was aborted')
+    }) as unknown as typeof fetch
+    const r = await transcribeViaSidecar({
+      token: 't',
+      audio: SMALL_AUDIO,
+      filename: 'voice.ogg',
+      timeoutMs: 5,
+      fetchImpl: fakeFetch,
+    })
+    expect(r).toMatchObject({ ok: false, reason: 'timeout' })
+  })
+})
+
+// ── materializeSidecarToken — vault resolution (mirrors the key helper) ──
+
+const EMPTY_CONFIG = {} as unknown as SwitchroomConfig
+
+function makeBrokerResolver(
+  resolvedRefs: Record<string, string>,
+): typeof resolveVaultReferencesViaBroker {
+  return (async (config: SwitchroomConfig) => {
+    const ref = config.telegram?.bot_token
+    if (ref && resolvedRefs[ref] !== undefined) {
+      return {
+        ok: true,
+        config: {
+          ...config,
+          telegram: { ...config.telegram, bot_token: resolvedRefs[ref] },
+        },
+      }
+    }
+    return { ok: false, reason: 'not_found' as const }
+  }) as unknown as typeof resolveVaultReferencesViaBroker
+}
+
+describe('materializeSidecarToken — vault resolution', () => {
+  it('defaults to vault:voice/sidecar-token', () => {
+    expect(VOICE_SIDECAR_TOKEN_KEY).toBe('voice/sidecar-token')
+    expect(DEFAULT_VOICE_SIDECAR_TOKEN_REF).toBe('vault:voice/sidecar-token')
+  })
+
+  it('resolves the configured vault ref via the broker', async () => {
+    const tok = await materializeSidecarToken({
+      config: EMPTY_CONFIG,
+      env: {},
+      resolveViaBroker: makeBrokerResolver({
+        'vault:voice/sidecar-token': 'deadbeef' + 'cafe',
+      }),
+    })
+    expect(tok).toBe('deadbeef' + 'cafe')
+  })
+
+  it('returns a literal (non-vault) token directly without the broker', async () => {
+    let brokerCalled = false
+    const tok = await materializeSidecarToken({
+      tokenRef: 'raw' + 'token',
+      config: EMPTY_CONFIG,
+      env: {},
+      resolveViaBroker: (async () => {
+        brokerCalled = true
+        return { ok: false, reason: 'not_found' as const }
+      }) as unknown as typeof resolveVaultReferencesViaBroker,
+    })
+    expect(tok).toBe('raw' + 'token')
+    expect(brokerCalled).toBe(false)
+  })
+
+  it('returns null (graceful fallback, no throw) when unresolvable', async () => {
+    const tok = await materializeSidecarToken(
+      {
+        config: EMPTY_CONFIG,
+        env: {},
+        resolveViaBroker: makeBrokerResolver({}),
+      },
+      () => {},
+    )
+    expect(tok).toBeNull()
+  })
+
+  // ── Regression: single-key isolation (voice token bug) ──
+  //
+  // resolveVaultReferencesViaBroker fails the WHOLE batch unless EVERY vault:
+  // ref resolves. Admin-only refs (litellm/master-key,
+  // google/client-secret) are correctly DENIED to a normal agent — so if the
+  // materializer passes the full config, those denials sink the resolution
+  // even though voice/sidecar-token itself is granted. The fix passes a
+  // MINIMAL config carrying only the one ref. These tests fail against the
+  // old `...config` spread.
+
+  function collectRefs(v: unknown, out: Set<string>): void {
+    if (typeof v === 'string' && v.startsWith('vault:')) out.add(v.slice('vault:'.length).split('#')[0])
+    else if (Array.isArray(v)) for (const i of v) collectRefs(i, out)
+    else if (v !== null && typeof v === 'object') for (const val of Object.values(v as Record<string, unknown>)) collectRefs(val, out)
+  }
+
+  /** Resolver stub with the real batch semantics: denies unless every collected ref is granted. */
+  function makeBatchResolver(
+    granted: Record<string, string>,
+    onCall?: (refs: Set<string>) => void,
+  ): typeof resolveVaultReferencesViaBroker {
+    return (async (config: SwitchroomConfig) => {
+      const refs = new Set<string>()
+      collectRefs(config, refs)
+      onCall?.(refs)
+      for (const r of refs) {
+        if (granted[`vault:${r}`] === undefined) {
+          return { ok: false, reason: 'denied' as const }
+        }
+      }
+      const resolved = granted[config.telegram?.bot_token ?? '']
+      return {
+        ok: true,
+        config: { ...config, telegram: { ...config.telegram, bot_token: resolved } },
+      }
+    }) as unknown as typeof resolveVaultReferencesViaBroker
+  }
+
+  const CONFIG_WITH_ADMIN_REFS = {
+    telegram: { bot_token: 'vault:tg/bot' },
+    litellm: { admin_key: 'vault:litellm/master-key' },
+    google_workspace: { google_client_secret: 'vault:google/client-secret' },
+    agents: { klanker: { some_key: 'vault:per-agent/secret' } },
+    vault: { path: '~/.switchroom/vault.enc' },
+  } as unknown as SwitchroomConfig
+
+  it('resolves the sidecar token even when the config carries admin-only vault refs the broker DENIES', async () => {
+    const tok = await materializeSidecarToken({
+      config: CONFIG_WITH_ADMIN_REFS,
+      env: {},
+      resolveViaBroker: makeBatchResolver({ 'vault:voice/sidecar-token': 'deadbeefcafe' }),
+    })
+    expect(tok).toBe('deadbeefcafe')
+  })
+
+  it('invokes the resolver with a config containing exactly ONE vault ref (the sidecar token)', async () => {
+    let seen: Set<string> | null = null
+    await materializeSidecarToken({
+      config: CONFIG_WITH_ADMIN_REFS,
+      env: {},
+      resolveViaBroker: makeBatchResolver(
+        { 'vault:voice/sidecar-token': 'deadbeefcafe' },
+        (refs) => { seen = refs },
+      ),
+    })
+    expect(seen).not.toBeNull()
+    expect([...seen!]).toEqual(['voice/sidecar-token'])
+  })
+})

package/telegram-plugin/tests/voice-transcribe.test.ts

@@ -10,10 +10,18 @@
  */
 
 import { describe, it, expect } from 'bun:test'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
 import {
   transcribeViaWhisper,
   OPENAI_WHISPER_MAX_BYTES,
 } from '../voice-transcribe.js'
+import {
+  materializeVoiceKey,
+  DEFAULT_VOICE_API_KEY_REF,
+} from '../../src/telegram/materialize-voice-key.js'
+import type { resolveVaultReferencesViaBroker } from '../../src/vault/resolver.js'
+import type { SwitchroomConfig } from '../../src/config/schema.js'
 
 const SMALL_AUDIO = new Uint8Array([0x4f, 0x67, 0x67, 0x53]) // OggS magic; not real audio
 
@@ -194,3 +202,183 @@ describe('transcribeViaWhisper — error paths', () => {
     expect(r).toMatchObject({ ok: false, reason: 'timeout' })
   })
 })
+
+// ── PR-A: STT key resolves via the vault broker, not a plaintext file ──
+
+const EMPTY_CONFIG = {} as unknown as SwitchroomConfig
+
+/** A fake broker resolver that returns the value mapped to bot_token (the
+ *  key materializeVoiceKey narrows the reference onto). */
+function makeBrokerResolver(
+  resolvedRefs: Record<string, string>,
+): typeof resolveVaultReferencesViaBroker {
+  return (async (config: SwitchroomConfig) => {
+    const ref = config.telegram?.bot_token
+    if (ref && resolvedRefs[ref] !== undefined) {
+      return {
+        ok: true,
+        config: {
+          ...config,
+          telegram: { ...config.telegram, bot_token: resolvedRefs[ref] },
+        },
+      }
+    }
+    return { ok: false, reason: 'not_found' as const }
+  }) as unknown as typeof resolveVaultReferencesViaBroker
+}
+
+describe('materializeVoiceKey — vault resolution', () => {
+  it('resolves the configured vault ref via the broker', async () => {
+    const key = await materializeVoiceKey({
+      apiKeyRef: 'vault:openai/api-key',
+      config: EMPTY_CONFIG,
+      env: {},
+      resolveViaBroker: makeBrokerResolver({
+        'vault:openai/api-key': 'sk-' + 'resolved' + '-key',
+      }),
+    })
+    expect(key).toBe('sk-' + 'resolved' + '-key')
+  })
+
+  it('defaults to vault:openai/api-key when no ref is configured', async () => {
+    expect(DEFAULT_VOICE_API_KEY_REF).toBe('vault:openai/api-key')
+    const key = await materializeVoiceKey({
+      apiKeyRef: undefined,
+      config: EMPTY_CONFIG,
+      env: {},
+      resolveViaBroker: makeBrokerResolver({
+        'vault:openai/api-key': 'sk-' + 'default' + '-key',
+      }),
+    })
+    expect(key).toBe('sk-' + 'default' + '-key')
+  })
+
+  it('returns a literal (non-vault) key directly without touching the broker', async () => {
+    let brokerCalled = false
+    const key = await materializeVoiceKey({
+      apiKeyRef: 'sk-' + 'literal',
+      config: EMPTY_CONFIG,
+      env: {},
+      resolveViaBroker: (async () => {
+        brokerCalled = true
+        return { ok: false, reason: 'not_found' as const }
+      }) as unknown as typeof resolveVaultReferencesViaBroker,
+    })
+    expect(key).toBe('sk-' + 'literal')
+    expect(brokerCalled).toBe(false)
+  })
+
+  it('returns null (graceful fallback, no throw) when the key is unresolvable', async () => {
+    const key = await materializeVoiceKey(
+      {
+        apiKeyRef: 'vault:openai/api-key',
+        config: EMPTY_CONFIG,
+        env: {}, // no SWITCHROOM_VAULT_PASSPHRASE → no direct-decrypt fallback
+        resolveViaBroker: makeBrokerResolver({}), // broker resolves nothing
+      },
+      () => {}, // swallow the diagnostic log
+    )
+    expect(key).toBeNull()
+  })
+
+  // ── Regression: single-key isolation (voice token bug) ──
+  //
+  // The batch resolver (resolveVaultReferencesViaBroker) fails the WHOLE
+  // resolution unless EVERY vault: ref it finds resolves. Admin-only refs
+  // like litellm.admin_key / google_workspace.google_client_secret are
+  // (correctly) DENIED to a normal agent, so if the materializer passes the
+  // full config those denials sink the resolution even though openai/api-key
+  // itself is granted. The fix passes a MINIMAL config carrying only the one
+  // ref. These tests would fail against the old `...config` spread.
+
+  /** Regex of every vault: ref the resolver sees; denies if it sees any admin-only key. */
+  function collectRefs(v: unknown, out: Set<string>): void {
+    if (typeof v === 'string' && v.startsWith('vault:')) out.add(v.slice('vault:'.length).split('#')[0])
+    else if (Array.isArray(v)) for (const i of v) collectRefs(i, out)
+    else if (v !== null && typeof v === 'object') for (const val of Object.values(v as Record<string, unknown>)) collectRefs(val, out)
+  }
+
+  /**
+   * A resolver stub with the SAME batch semantics as the real one: it fails
+   * (denied) unless every ref it collects is in `granted`. Mirrors how a real
+   * broker denies admin-only keys to a normal agent.
+   */
+  function makeBatchResolver(
+    granted: Record<string, string>,
+    onCall?: (refs: Set<string>) => void,
+  ): typeof resolveVaultReferencesViaBroker {
+    return (async (config: SwitchroomConfig) => {
+      const refs = new Set<string>()
+      collectRefs(config, refs)
+      onCall?.(refs)
+      for (const r of refs) {
+        if (granted[`vault:${r}`] === undefined) {
+          return { ok: false, reason: 'denied' as const }
+        }
+      }
+      const resolvedToken = granted[config.telegram?.bot_token ?? '']
+      return {
+        ok: true,
+        config: { ...config, telegram: { ...config.telegram, bot_token: resolvedToken } },
+      }
+    }) as unknown as typeof resolveVaultReferencesViaBroker
+  }
+
+  const CONFIG_WITH_ADMIN_REFS = {
+    telegram: { bot_token: 'vault:tg/bot' },
+    litellm: { admin_key: 'vault:litellm/master-key' },
+    google_workspace: { google_client_secret: 'vault:google/client-secret' },
+    agents: { klanker: { some_key: 'vault:per-agent/secret' } },
+    vault: { path: '~/.switchroom/vault.enc' },
+  } as unknown as SwitchroomConfig
+
+  it('resolves the STT key even when the config carries admin-only vault refs the broker DENIES', async () => {
+    const key = await materializeVoiceKey({
+      apiKeyRef: 'vault:openai/api-key',
+      config: CONFIG_WITH_ADMIN_REFS,
+      env: {},
+      // ONLY openai/api-key is granted; litellm/google/per-agent all DENY.
+      resolveViaBroker: makeBatchResolver({ 'vault:openai/api-key': 'sk-granted-key' }),
+    })
+    expect(key).toBe('sk-granted-key')
+  })
+
+  it('invokes the resolver with a config containing exactly ONE vault ref (the STT key)', async () => {
+    let seen: Set<string> | null = null
+    await materializeVoiceKey({
+      apiKeyRef: 'vault:openai/api-key',
+      config: CONFIG_WITH_ADMIN_REFS,
+      env: {},
+      resolveViaBroker: makeBatchResolver(
+        { 'vault:openai/api-key': 'sk-granted-key' },
+        (refs) => { seen = refs },
+      ),
+    })
+    expect(seen).not.toBeNull()
+    expect([...seen!]).toEqual(['openai/api-key'])
+  })
+})
+
+describe('voice-in — no plaintext key file is read', () => {
+  it('the gateway never reads ~/.switchroom/openai-api-key as a path', () => {
+    const gatewayPath = fileURLToPath(
+      new URL('../gateway/gateway.ts', import.meta.url),
+    )
+    const src = readFileSync(gatewayPath, 'utf8')
+    // The plaintext file basename must not appear as a path segment in
+    // any source string (it lived in a join(..., 'openai-api-key')).
+    expect(src).not.toContain("'openai-api-key'")
+    expect(src).not.toContain('"openai-api-key"')
+  })
+
+  it('the voice-key materializer reads no openai-api-key path', () => {
+    const helperPath = fileURLToPath(
+      new URL('../../src/telegram/materialize-voice-key.ts', import.meta.url),
+    )
+    const src = readFileSync(helperPath, 'utf8')
+    // The basename appears only inside a code-comment sentence (prose),
+    // never quoted as a path literal that fs would read.
+    expect(src).not.toContain("'openai-api-key'")
+    expect(src).not.toContain('"openai-api-key"')
+  })
+})

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

@@ -115,7 +115,7 @@ describe('renderWorkerActivity', () => {
     expect(out).toContain('─────')
     expect(out).toContain('✅ _PR #21 opened_')
     // latestSummary is the RESULT on the finished path, never also a step.
-    expect(out).not.toContain('_✓ PR #21 opened_')
+    expect(out).not.toContain('~~_✓ PR #21 opened_~~')
   })
 
   it('renders a failed terminal recap', () => {
@@ -155,8 +155,8 @@ describe('renderWorkerActivity', () => {
         narrativeLines: ['read the brief', 'scanned vendor A', 'scanned vendor B'],
       }),
     )
-    expect(out).toContain('_✓ read the brief_')
-    expect(out).toContain('_✓ scanned vendor A_')
+    expect(out).toContain('~~_✓ read the brief_~~')
+    expect(out).toContain('~~_✓ scanned vendor A_~~')
     expect(out).toContain('**→ scanned vendor B**')
     // The single-line latestSummary fallback is NOT used when a block is present.
     expect(out).not.toContain('newest only')
@@ -171,7 +171,7 @@ describe('renderWorkerActivity', () => {
 
   it('drops blank narrative lines from the feed', () => {
     const out = renderWorkerActivity(view({ narrativeLines: ['kept', '   ', 'also kept'] }))
-    expect(out).toContain('_✓ kept_')
+    expect(out).toContain('~~_✓ kept_~~')
     expect(out).toContain('**→ also kept**')
     expect(stepCount(out)).toBe(2)
   })
@@ -183,7 +183,7 @@ describe('renderWorkerActivity', () => {
     expect(out).toContain(`_✓ +${total - STATUS_ROLLING_LINES} earlier…_`)
     expect(out).not.toContain('step 1<')
     const firstVisible = total - STATUS_ROLLING_LINES + 1
-    expect(out).toContain(`_✓ step ${firstVisible}_`)
+    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)
@@ -191,7 +191,7 @@ describe('renderWorkerActivity', () => {
 
   it('strips the CONTENT Markdown markup (the card keeps its own ** / _ wrappers, #2669)', () => {
     // Post-#2669 the card itself is rich markdown — the header is **Worker**
-    // and steps are _✓ …_ / **→ …**. The per-line pipeline still runs
+    // and steps are ~~_✓ …_~~ / **→ …**. The per-line pipeline still runs
     // stripMarkdown over the user-supplied CONTENT so a model-authored
     // `**full**` / `` `git push` `` doesn't inject extra emphasis, but the
     // card's own wrapper markup is expected.
@@ -276,6 +276,24 @@ describe('createWorkerActivityFeed', () => {
     expect(feed.has('w1')).toBe(true)
   })
 
+  it('messageIdOf exposes the posted message id (for status-pin) and is null before paint / after finish', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, firstPaintMinMs: 8000 })
+    // Before paint: no message, no id to pin.
+    clock = 5000
+    await feed.update('w1', 'chat', view({ elapsedMs: 5000 }))
+    expect(feed.messageIdOf('w1')).toBeNull()
+    // After paint: id is the posted message the gateway pins.
+    clock = 9000
+    await feed.update('w1', 'chat', view({ elapsedMs: 9000 }))
+    // The fake mints message ids starting at 1000; first paint → 1000.
+    expect(feed.messageIdOf('w1')).toBe(1000)
+    // After finish: handle is dropped → null (gateway unpins independently).
+    await feed.finish('w1', view({ state: 'done' }))
+    expect(feed.messageIdOf('w1')).toBeNull()
+  })
+
   it('dedups an identical body (no edit)', async () => {
     const bot = makeFakeBot()
     let clock = 10_000
@@ -406,8 +424,8 @@ describe('createWorkerActivityFeed', () => {
     await feed.update('w1', 'chat', view({ toolCount: 3, latestSummary: 'scanned vendor B' }))
 
     const last = bot.edits.at(-1)!
-    expect(last.text).toContain('_✓ read the brief_')
-    expect(last.text).toContain('_✓ scanned vendor A_')
+    expect(last.text).toContain('~~_✓ read the brief_~~')
+    expect(last.text).toContain('~~_✓ scanned vendor A_~~')
     expect(last.text).toContain('**→ scanned vendor B**')
     expect(last.text.match(/[✓→]/g) ?? []).toHaveLength(3)
   })
@@ -462,8 +480,8 @@ describe('createWorkerActivityFeed', () => {
     clock = 13_000
     await feed.update('w1', 'chat', view({ toolCount: 3, latestSummary: 'line C' }))
     const last = bot.edits.at(-1)!
-    expect(last.text).toContain('_✓ line A_')
-    expect(last.text).toContain('_✓ line B_')
+    expect(last.text).toContain('~~_✓ line A_~~')
+    expect(last.text).toContain('~~_✓ line B_~~')
     expect(last.text).toContain('**→ line C**')
   })