switchroom 0.18.12 → 0.18.13

package/telegram-plugin/tests/history.test.ts

@@ -542,6 +542,121 @@ describe('hasOutboundDeliveredSince', () => {
   })
 })
 
+// Review finding H5 regression: the original PRIMARY KEY (chat_id, thread_id, message_id) does
+// NOT dedupe thread-less rows because SQLite treats NULL as distinct from NULL
+// in a UNIQUE/PK index. The documented at-least-once boot replay re-records an
+// already-stored DM/non-topic message, so `INSERT OR REPLACE` appended a
+// DUPLICATE row instead of replacing — over-counting the silence / over-ping
+// detectors. The COALESCE(thread_id,'') unique index makes the upsert
+// idempotent. These tests fail (duplicate rows) without the fix.
+describe('idempotent upsert for null-thread rows (H5)', () => {
+  beforeEach(() => initHistory(stateDir, 30))
+
+  it('re-recording the same null-thread inbound yields exactly ONE row', () => {
+    const msg = {
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 7,
+      user: 'alice',
+      user_id: '111',
+      ts: 1000,
+      text: 'hello',
+    }
+    // Simulate the at-least-once replay: record the same message twice.
+    recordInbound(msg)
+    recordInbound(msg)
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]).toMatchObject({ message_id: 7, role: 'user', text: 'hello' })
+    // The over-count surface the finding calls out must stay accurate.
+    expect(getRecentOutboundCount('-100', 999_999)).toBe(0)
+  })
+
+  it('re-recording the same null-thread outbound yields exactly ONE row', () => {
+    const now = Math.floor(Date.now() / 1000)
+    const send = {
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [42],
+      texts: ['the answer'],
+      ts: now,
+    }
+    recordOutbound(send)
+    recordOutbound(send)
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(1)
+    // hasOutboundDeliveredSince / getRecentOutboundCount read this table; a
+    // duplicate here would double-count and over-ping.
+    expect(getRecentOutboundCount('-100', 60)).toBe(1)
+  })
+
+  it('a re-record REPLACES rather than appends (newest text wins)', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 7, user: 'a', user_id: '1', ts: 1000, text: 'first version' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 7, user: 'a', user_id: '1', ts: 1000, text: 'second version' })
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]?.text).toBe('second version')
+  })
+
+  it('a topic row and a general row with the SAME message_id stay DISTINCT', () => {
+    // Same chat_id + message_id, but one is in a forum topic (thread 5) and one
+    // is the general/DM row (null thread). These are different logical messages
+    // and must both survive — the COALESCE sentinel keeps them separate.
+    recordInbound({ chat_id: '-100', thread_id: 5, message_id: 9, user: 'a', user_id: '1', ts: 100, text: 'in topic 5' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 9, user: 'a', user_id: '1', ts: 100, text: 'in general' })
+    expect(query({ chat_id: '-100' })).toHaveLength(2)
+    expect(query({ chat_id: '-100', thread_id: 5 }).map(r => r.text)).toEqual(['in topic 5'])
+    expect(query({ chat_id: '-100', thread_id: null }).map(r => r.text)).toEqual(['in general'])
+  })
+
+  it('two distinct forum topics with the same message_id stay DISTINCT', () => {
+    recordInbound({ chat_id: '-100', thread_id: 5, message_id: 9, user: 'a', user_id: '1', ts: 100, text: 'topic5' })
+    recordInbound({ chat_id: '-100', thread_id: 6, message_id: 9, user: 'a', user_id: '1', ts: 100, text: 'topic6' })
+    expect(query({ chat_id: '-100' })).toHaveLength(2)
+    expect(query({ chat_id: '-100', thread_id: 5 }).map(r => r.text)).toEqual(['topic5'])
+    expect(query({ chat_id: '-100', thread_id: 6 }).map(r => r.text)).toEqual(['topic6'])
+  })
+
+  it('migration de-dupes pre-existing null-thread duplicates from a legacy DB', async () => {
+    // Simulate a DB written by the pre-fix build: insert duplicate null-thread
+    // rows DIRECTLY, bypassing the (now-fixed) upsert, to reproduce the exact
+    // corruption the finding describes. Then re-init to fire the migration.
+    const { Database } = await import('bun:sqlite')
+    const dbPath = join(stateDir, 'history.db')
+    const now = Math.floor(Date.now() / 1000) // recent ts so the retention sweep keeps them
+    _resetForTests()
+    const raw = new Database(dbPath)
+    // Drop the logical-key index so we're back to the legacy, dupe-permitting
+    // schema, then append two rows sharing the same (chat, null-thread, msg).
+    raw.exec('DROP INDEX IF EXISTS idx_messages_logical_key')
+    const insert = raw.prepare(
+      `INSERT INTO messages (chat_id, thread_id, message_id, role, user, user_id, ts, text, group_id)
+       VALUES (?, NULL, ?, 'user', 'a', '1', ?, ?, NULL)`,
+    )
+    insert.run('-100', 7, now, 'stale copy')
+    insert.run('-100', 7, now + 1, 'newest copy')
+    // A distinct topic row with the same message_id must survive the migration.
+    raw.prepare(
+      `INSERT INTO messages (chat_id, thread_id, message_id, role, user, user_id, ts, text, group_id)
+       VALUES (?, 5, ?, 'user', 'a', '1', ?, ?, NULL)`,
+    ).run('-100', 7, now, 'topic row')
+    raw.close()
+
+    // Re-open through initHistory → runs the H5 migration (dedupe + index).
+    initHistory(stateDir, 30)
+    const general = query({ chat_id: '-100', thread_id: null })
+    expect(general).toHaveLength(1)
+    expect(general[0]?.text).toBe('newest copy') // kept the newest (highest ts/rowid)
+    // The topic row with the same message_id is untouched.
+    expect(query({ chat_id: '-100', thread_id: 5 }).map(r => r.text)).toEqual(['topic row'])
+    expect(query({ chat_id: '-100' })).toHaveLength(2)
+
+    // And the upsert is idempotent going forward.
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 7, user: 'a', user_id: '1', ts: now + 2, text: 'replay' })
+    expect(query({ chat_id: '-100', thread_id: null })).toHaveLength(1)
+  })
+})
+
 describe('secret redaction at persistence (both directions)', () => {
   beforeEach(() => initHistory(stateDir, 30))
 

package/telegram-plugin/tests/inbound-message-types.test.ts

@@ -206,7 +206,11 @@ describe('inbound message-type helpers: handleAckOnly + handleRefusal', () => {
     const fnStart = SRC.indexOf('async function handleAckOnly(')
     const fnSlice = SRC.slice(fnStart, fnStart + 2000)
     expect(fnSlice).toContain('gate(ctx)')
-    expect(fnSlice).toContain('setMessageReaction')
+    // #3155: the reaction now routes through the gated `sendReaction` helper
+    // (send gate + flood breaker, cosmetic) instead of a raw
+    // `bot.api.setMessageReaction`. The invariant is unchanged: it gates, THEN
+    // reacts.
+    expect(fnSlice).toContain('sendReaction(')
   })
 
   it('handleAckOnly drops non-allowlisted senders silently', () => {

package/telegram-plugin/tests/inline-keyboard-callbacks.test.ts

@@ -14,6 +14,7 @@ import {
   AGENT_CALLBACK_PREFIX,
   AGENT_CALLBACK_DATA_MAX,
   wrapAgentCallbacks,
+  redactAgentKeyboard,
   parseAgentCallback,
   validateAndWrapAgentKeyboard,
   extractAgentButtonMeta,
@@ -22,6 +23,7 @@ import {
   escapeHtmlEntities,
   applyTapAnnotationEdit,
 } from '../inline-keyboard-callbacks.js'
+import { redact } from '../secret-detect/redact.js'
 
 describe('inline-keyboard-callbacks (#271)', () => {
   describe('AGENT_CALLBACK_DATA_MAX', () => {
@@ -431,4 +433,166 @@ describe('inline-keyboard-callbacks (#271)', () => {
       expect(outcome).toBe('failed')
     })
   })
+
+  // ─── #3148 fast-follow: agent-authored keyboard secret scrub ──────────────
+  //
+  // wrapAgentCallbacks rewrites ONLY callback_data; the visible `text` label,
+  // the `ack_text` toast, and any `copy_text.text` clipboard payload passed
+  // through VERBATIM before this fix — so a secret an agent placed in any of
+  // them transmitted to Telegram unmasked and resurfaced on tap (echo, toast,
+  // "✅ You chose" annotation). redactAgentKeyboard masks those three fields at
+  // the outbound boundary using the SAME redact() the reply body uses, while
+  // leaving the routing key (callback_data) exact.
+  describe('redactAgentKeyboard (#3148 fast-follow)', () => {
+    // Assemble the fixture at runtime so this source file never carries a
+    // contiguous token that trips push-protection / secretlint (CLAUDE.md).
+    const GITHUB_PAT = 'ghp' + '_' + '16C7e42F292c6912E7710c838347Ae178B4a'
+
+    it('masks a secret in a button `text` label in the sent payload (real redact)', () => {
+      const raw = [
+        [{ text: `Use ${GITHUB_PAT}`, callback_data: 'use_token' }],
+      ]
+      // Mirror the gateway pipeline: redact BEFORE wrap.
+      const wrapped = wrapAgentCallbacks(redactAgentKeyboard(raw, redact))
+      const btn = wrapped[0]![0]!
+      // OUTCOME: the label bytes actually shipped to Telegram carry no secret.
+      expect(btn.text as string).not.toContain(GITHUB_PAT)
+      expect(btn.text as string).toContain('[REDACTED')
+      expect((btn.text as string).length).toBeGreaterThan(0)
+      // Routing key untouched (only the agent: namespace prefix was added).
+      expect(btn.callback_data).toBe(`${AGENT_CALLBACK_PREFIX}use_token`)
+    })
+
+    it('masks a secret in `ack_text` in the extracted per-button meta (real redact)', () => {
+      const raw = [
+        [{ text: 'Deploy', callback_data: 'deploy', ack_text: `token ${GITHUB_PAT}` }],
+      ]
+      // Mirror the gateway: extract meta from the REDACTED keyboard so the
+      // stashed toast (shown via answerCallbackQuery on tap) is masked.
+      const meta = extractAgentButtonMeta(redactAgentKeyboard(raw, redact))
+      const ack = meta.get('deploy')!.ack_text!
+      expect(ack).not.toContain(GITHUB_PAT)
+      expect(ack).toContain('[REDACTED')
+    })
+
+    it('masks a secret in `copy_text.text` clipboard payload (real redact)', () => {
+      const raw = [
+        [{ text: 'Copy token', callback_data: 'copy', copy_text: { text: GITHUB_PAT } }],
+      ]
+      const [[btn]] = redactAgentKeyboard(raw, redact)
+      const ct = (btn as { copy_text: { text: string } }).copy_text.text
+      expect(ct).not.toContain(GITHUB_PAT)
+      expect(ct).toContain('[REDACTED')
+    })
+
+    it('never empties a label that is ENTIRELY a secret (non-empty invariant)', () => {
+      const raw = [[{ text: GITHUB_PAT, callback_data: 'x' }]]
+      const [[btn]] = redactAgentKeyboard(raw, redact)
+      expect((btn.text as string).length).toBeGreaterThan(0)
+      expect(btn.text as string).not.toContain(GITHUB_PAT)
+    })
+
+    it('leaves a legit (secret-free) label unchanged', () => {
+      const raw = [
+        [{ text: 'Approve PR #547', callback_data: 'approve', ack_text: 'Approved ✓' }],
+        [{ text: 'Hold', callback_data: 'hold' }],
+      ]
+      const out = redactAgentKeyboard(raw, redact)
+      expect(out[0]![0]!.text).toBe('Approve PR #547')
+      expect(out[0]![0]!.ack_text).toBe('Approved ✓')
+      expect(out[1]![0]!.text).toBe('Hold')
+    })
+
+    it('NEVER passes callback_data through the redactor (routing key stays exact)', () => {
+      // A fake redactor that mangles everything it sees; anything the routing
+      // key touched would be corrupted. Proves copy_text/url/callback_data are
+      // handled correctly by field, not blanket-scrubbed.
+      const seen: string[] = []
+      const mangle = (s: string) => {
+        seen.push(s)
+        return `X${s}X`
+      }
+      const raw = [
+        [
+          { text: 'Label', callback_data: 'route_key_do_not_touch', ack_text: 'toast' },
+          { text: 'Link', url: 'https://example.com/keep' },
+          { text: 'Clip', callback_data: 'c2', copy_text: { text: 'secret-clip' } },
+        ],
+      ]
+      const out = redactAgentKeyboard(raw, mangle)
+      // callback_data + url are byte-exact.
+      expect(out[0]![0]!.callback_data).toBe('route_key_do_not_touch')
+      expect(out[0]![1]!.url).toBe('https://example.com/keep')
+      expect(out[0]![2]!.callback_data).toBe('c2')
+      // Only free-text fields were routed through the redactor.
+      expect(out[0]![0]!.text).toBe('XLabelX')
+      expect(out[0]![0]!.ack_text).toBe('XtoastX')
+      expect((out[0]![2]! as { copy_text: { text: string } }).copy_text.text).toBe('Xsecret-clipX')
+      expect(seen).toEqual(['Label', 'toast', 'Link', 'Clip', 'secret-clip'])
+      expect(seen).not.toContain('route_key_do_not_touch')
+      expect(seen).not.toContain('https://example.com/keep')
+      expect(seen).not.toContain('c2')
+    })
+
+    it('masks a secret in switch_inline_query* (pasted into the chat input on tap)', () => {
+      const raw = [
+        [{ text: 'Share', callback_data: 's', switch_inline_query: `key ${GITHUB_PAT}` }],
+        [{
+          text: 'Fill here',
+          callback_data: 'f',
+          switch_inline_query_current_chat: `key ${GITHUB_PAT}`,
+        }],
+      ]
+      const out = redactAgentKeyboard(raw, redact)
+      const siq = (out[0]![0]! as { switch_inline_query: string }).switch_inline_query
+      const siqc = (out[1]![0]! as { switch_inline_query_current_chat: string })
+        .switch_inline_query_current_chat
+      expect(siq).not.toContain(GITHUB_PAT)
+      expect(siq).toContain('[REDACTED')
+      expect(siqc).not.toContain(GITHUB_PAT)
+      expect(siqc).toContain('[REDACTED')
+    })
+
+    it('masks a secret in switch_inline_query_chosen_chat.query', () => {
+      const raw = [[{
+        text: 'Share to…',
+        callback_data: 'cc',
+        switch_inline_query_chosen_chat: { query: `key ${GITHUB_PAT}`, allow_user_chats: true },
+      }]]
+      const [[btn]] = redactAgentKeyboard(raw, redact)
+      const cc = (btn as { switch_inline_query_chosen_chat: { query: string; allow_user_chats?: boolean } })
+        .switch_inline_query_chosen_chat
+      expect(cc.query).not.toContain(GITHUB_PAT)
+      expect(cc.query).toContain('[REDACTED')
+      // sibling sub-fields are preserved
+      expect(cc.allow_user_chats).toBe(true)
+    })
+
+    it('clamps a masked field that the marker pushed over the Telegram cap (reply not dropped)', () => {
+      // A 60-char label (< 64 cap) whose short secret expands under the marker
+      // would exceed 64 and 400-drop the whole reply; the clamp keeps it ≤ cap.
+      const shortSecret = 'AKIAIOSFODNN7EXAMPLE' // 20 chars, AWS-key shaped
+      const label = `${shortSecret} ${'x'.repeat(43)}` // 64 chars total, at the cap
+      const raw = [[{ text: label, callback_data: 'x' }]]
+      const [[btn]] = redactAgentKeyboard(raw, redact)
+      const text = btn.text as string
+      expect(text.length).toBeLessThanOrEqual(64)
+      expect(text).not.toContain(shortSecret)
+    })
+
+    it('preserves keyboard structure, row/column order, and does not mutate input', () => {
+      const raw = [
+        [{ text: 'A', callback_data: 'a' }, { text: 'B', callback_data: 'b' }],
+        [{ text: 'C', callback_data: 'c' }],
+      ]
+      const out = redactAgentKeyboard(raw, (s) => s)
+      expect(out.map((r) => r.map((b) => b.callback_data))).toEqual([
+        ['a', 'b'],
+        ['c'],
+      ])
+      // Fresh objects — input untouched.
+      expect(out[0]![0]).not.toBe(raw[0]![0])
+      expect(raw[0]![0]!.text).toBe('A')
+    })
+  })
 })

package/telegram-plugin/tests/operator-events-session-tail.test.ts

@@ -9,6 +9,7 @@ import { tmpdir } from 'os'
 import { join } from 'path'
 import { detectErrorInTranscriptLine, startSessionTail } from '../session-tail.js'
 import { resetAllCooldowns } from '../operator-events.js'
+import { resolveModelUnavailableFromOperatorEvent } from '../model-unavailable.js'
 
 // ─── detectErrorInTranscriptLine unit tests ───────────────────────────────────
 
@@ -155,6 +156,79 @@ describe('detectErrorInTranscriptLine — error detection', () => {
     expect(result!.detail).toContain('hit your limit')
   })
 
+  // Regression — the carrie incident (2026-07-12). Anthropic also emits a
+  // 429 for a TRANSIENT per-account burst / RPM throttle whose wording
+  // explicitly negates the account-quota reading ("would exceed your
+  // account's rate limit … not your usage limit"). That is a self-healing
+  // few-second throttle Claude Code retries internally — it must NOT be
+  // labeled quota-exhausted (which always shows the scary "model
+  // unavailable" card + drives failover). It must take the calm
+  // rate-limited path.
+  it('classifies a TRANSIENT burst 429 (explicit negation) as rate-limited, NOT quota-exhausted', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        model: '<synthetic>',
+        content: [
+          {
+            type: 'text',
+            text:
+              'API Error: 429 rate_limit_error This request would exceed ' +
+              "your account's rate limit. Please try again later. This is a " +
+              'short-term burst limit, not your usage limit.',
+          },
+        ],
+      },
+      error: 'rate_limit',
+      isApiErrorMessage: true,
+      apiErrorStatus: 429,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result).not.toBeNull()
+    // Wording-based classification: explicit transient negation → calm path.
+    expect(result!.kind).toBe('rate-limited')
+    expect(result!.transient).toBe(true)
+    // End-to-end: the resolver must NOT produce a model-unavailable card for
+    // this kind (the calm rate-limited branch returns null on a bare burst).
+    const detection = resolveModelUnavailableFromOperatorEvent({
+      kind: result!.kind,
+      detail: result!.detail,
+    })
+    expect(detection).toBeNull()
+  })
+
+  // Guard against over-correcting: a GENUINE quota wall (no transient marker)
+  // must STILL be quota-exhausted AND still resolve to a card.
+  it('a genuine quota-wall 429 still produces the quota-exhausted card', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        model: '<synthetic>',
+        content: [
+          {
+            type: 'text',
+            text: "You've hit your limit · resets 8:50am (Australia/Melbourne)",
+          },
+        ],
+      },
+      error: 'rate_limit',
+      isApiErrorMessage: true,
+      apiErrorStatus: 429,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result).not.toBeNull()
+    expect(result!.kind).toBe('quota-exhausted')
+    // The quota-exhausted branch ALWAYS returns a detection (the card).
+    const detection = resolveModelUnavailableFromOperatorEvent({
+      kind: result!.kind,
+      detail: result!.detail,
+    })
+    expect(detection).not.toBeNull()
+    expect(detection!.kind).toBe('quota_exhausted')
+  })
+
   it('still returns null for a normal (non-error) assistant message', () => {
     // No isApiErrorMessage flag → must NOT be treated as an error.
     const line = JSON.stringify({

package/telegram-plugin/tests/outbound-field-redact.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest'
+import {
+  redactAskUserFields,
+  redactChecklistFields,
+} from '../outbound-field-redact.js'
+import { redact } from '../secret-detect/redact.js'
+
+/**
+ * OUTCOME tests for the #2044 structured-payload outbound scrub (F1/F2).
+ *
+ * These exercise the exact helpers the gateway calls (redactAskUserFields
+ * for ask_user, redactChecklistFields for send_checklist / update_checklist),
+ * injecting the SAME real `redact()` the gateway's redactOutboundText wraps.
+ * The assertion is on the SENT PAYLOAD the helper returns — a secret echoed
+ * into a question, an option/button label, a checklist title, or a task's
+ * text must be masked (marker present, raw token absent) — not merely that a
+ * redactor was invoked.
+ *
+ * Secrets are assembled at runtime (per CLAUDE.md "Secrets in tests") so the
+ * source file never contains a contiguous token that trips push-protection.
+ */
+
+// A realistic GitHub classic PAT shape (ghp_ + 36 chars) — high-confidence,
+// masked by redact() to a [REDACTED:github_pat_classic] marker.
+const SECRET = 'ghp' + '_' + 'AbCdEfGhIj0123456789KlMnOpQrStUvWxYz'
+
+describe('redactAskUserFields — ask_user outbound scrub (F1)', () => {
+  it('masks a secret echoed into the QUESTION text', () => {
+    const out = redactAskUserFields(
+      `Deploy with token ${SECRET}?`,
+      ['Yes', 'No'],
+      redact,
+    )
+    expect(out.question).not.toContain(SECRET)
+    expect(out.question).toContain('[REDACTED')
+    // Non-secret prose is preserved.
+    expect(out.question).toContain('Deploy with token')
+  })
+
+  it('masks a secret echoed into an OPTION / button label', () => {
+    const out = redactAskUserFields(
+      'Which key?',
+      ['Cancel', `Use ${SECRET}`],
+      redact,
+    )
+    expect(out.options[0]).toBe('Cancel')
+    expect(out.options[1]).not.toContain(SECRET)
+    expect(out.options[1]).toContain('[REDACTED')
+  })
+
+  it('leaves clean question + options untouched', () => {
+    const out = redactAskUserFields('Proceed?', ['Yes', 'No'], redact)
+    expect(out.question).toBe('Proceed?')
+    expect(out.options).toEqual(['Yes', 'No'])
+  })
+
+  it('does not mutate the caller-supplied options array', () => {
+    const options = ['Cancel', `Use ${SECRET}`]
+    redactAskUserFields('q', options, redact)
+    expect(options[1]).toBe(`Use ${SECRET}`) // original array untouched
+  })
+})
+
+describe('redactChecklistFields — checklist outbound scrub (F2)', () => {
+  it('masks a secret in the checklist TITLE', () => {
+    const out = redactChecklistFields(
+      `Rotate ${SECRET}`,
+      [{ text: 'step one' }],
+      redact,
+    )
+    expect(out.title).not.toContain(SECRET)
+    expect(out.title).toContain('[REDACTED')
+  })
+
+  it('masks a secret in a TASK text and preserves other task fields', () => {
+    const out = redactChecklistFields(
+      'Onboarding',
+      [
+        { text: 'read the docs', done: true },
+        { text: `save ${SECRET} to vault`, id: '7' },
+      ],
+      redact,
+    )
+    expect(out.tasks![0]).toEqual({ text: 'read the docs', done: true })
+    expect(out.tasks![1]!.text).not.toContain(SECRET)
+    expect(out.tasks![1]!.text).toContain('[REDACTED')
+    // Sibling fields on the redacted task are carried through untouched.
+    expect(out.tasks![1]!.id).toBe('7')
+  })
+
+  it('passes undefined title / tasks through (update_checklist partial patch)', () => {
+    const out = redactChecklistFields(undefined, undefined, redact)
+    expect(out.title).toBeUndefined()
+    expect(out.tasks).toBeUndefined()
+  })
+
+  it('leaves an id-only task (no text) untouched', () => {
+    const out = redactChecklistFields(undefined, [{ id: '3', done: true }], redact)
+    expect(out.tasks![0]).toEqual({ id: '3', done: true })
+  })
+
+  it('does not mutate the caller-supplied task objects', () => {
+    const tasks = [{ text: `save ${SECRET}` }]
+    redactChecklistFields('t', tasks, redact)
+    expect(tasks[0]!.text).toBe(`save ${SECRET}`) // original untouched
+  })
+})