switchroom 0.19.23 → 0.19.25

package/telegram-plugin/tests/reply-owner-resolve.test.ts

@@ -34,11 +34,14 @@ import {
   resolveReplyOwnerTurnId,
   resolveReplyOwnerTier,
   decideAnswerLatchSuppression,
+  decideContentGateBypass,
   type ReplyOwnerCandidates,
+  type ReplyOwnerTier,
   type AnswerDeliveredLatch,
 } from '../reply-owner-resolve.js'
 import { FlushedTurnSupersedeRegistry, DEFAULT_SUPERSEDE_TTL_MS } from '../flushed-turn-supersede.js'
 import { OutboundDedupCache } from '../recent-outbound-dedup.js'
+import { latestTurnForChat } from '../gateway/latest-turn-lookup.js'
 
 const NONE: ReplyOwnerCandidates = {
   liveTurnId: null,
@@ -685,3 +688,531 @@ describe('resolveReplyOwnerTier — precedence + latest-ended TTL bound', () =>
     }
   })
 })
+
+/**
+ * `decideContentGateBypass` — WHEN the supersede path may treat a landing reply
+ * as this flushed turn's own answer and collapse the provisional flush even
+ * though the model REWORDED it.
+ *
+ * The rule replaced a blanket ban on the model-supplied `origin`/`quoted` tiers
+ * with CORROBORATION against the framework-derived `latestEndedTurnId`. The two
+ * properties that matter, both asserted below as outcomes:
+ *
+ *   - it closes the 2026-07-27 duplicate: a reply that echoes `origin_turn_id`
+ *     for its OWN turn now bypasses, exactly as it would have by omitting the
+ *     echo (the blanket ban punished the extra information);
+ *   - it grants ZERO new capability: for every candidate shape, a corroborated
+ *     `origin`/`quoted` bypass is reachable by dropping the model-supplied ids
+ *     and landing on `latest-ended` — so nothing bypasses that could not
+ *     already, and a STEERED attribution (pointing at a different turn than the
+ *     framework resolves) still cannot.
+ */
+describe('decideContentGateBypass — corroborated bypass of the #3429 content gate', () => {
+  const OWNER = 'turn-OWNER'
+  const OTHER = 'turn-OTHER'
+
+  /** Candidates whose framework-derived latest-ended IS `latestEnded`, fresh. */
+  const cands = (over: Partial<ReplyOwnerCandidates> = {}): ReplyOwnerCandidates => ({
+    liveTurnId: null,
+    originTurnId: null,
+    quotedTurnId: null,
+    latestEndedTurnId: OWNER,
+    latestEndedAgeMs: 30_000,
+    latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
+    ...over,
+  })
+
+  it('THE 2026-07-27 INCIDENT: an `origin` echo pointing at the SAME turn the ' +
+    'framework resolves bypasses the gate (pre-fix: banned → visible duplicate)', () => {
+    expect(
+      decideContentGateBypass({
+        tier: 'origin',
+        resolvedTurnId: OWNER,
+        candidates: cands({ originTurnId: OWNER }),
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(true)
+  })
+
+  it('a `quoted` attribution corroborated the same way also bypasses', () => {
+    expect(
+      decideContentGateBypass({
+        tier: 'quoted',
+        resolvedTurnId: OWNER,
+        candidates: cands({ quotedTurnId: OWNER }),
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(true)
+  })
+
+  it('THE FABLE VECTOR stays closed: an `origin`/`quoted` attribution STEERED onto ' +
+    'a different turn than the framework resolves never bypasses', () => {
+    for (const tier of ['origin', 'quoted'] as const) {
+      expect(
+        decideContentGateBypass({
+          tier,
+          resolvedTurnId: OTHER,
+          candidates: cands({
+            originTurnId: tier === 'origin' ? OTHER : null,
+            quotedTurnId: tier === 'quoted' ? OTHER : null,
+            latestEndedTurnId: OWNER,
+          }),
+          handbackCouldOwnReply: false,
+        }),
+      ).toBe(false)
+    }
+  })
+
+  it('a decoupled completion in the window keeps the gate on EVERY non-live tier', () => {
+    for (const tier of ['origin', 'quoted', 'latest-ended'] as const) {
+      expect(
+        decideContentGateBypass({
+          tier,
+          resolvedTurnId: OWNER,
+          candidates: cands({
+            originTurnId: tier === 'origin' ? OWNER : null,
+            quotedTurnId: tier === 'quoted' ? OWNER : null,
+          }),
+          handbackCouldOwnReply: true,
+        }),
+      ).toBe(false)
+    }
+  })
+
+  it('`live` bypasses unconditionally — even inside a handback window ' +
+    '(framework-owned, and decideSupersede bars it from another turn record)', () => {
+    expect(
+      decideContentGateBypass({
+        tier: 'live',
+        resolvedTurnId: OWNER,
+        candidates: cands({ liveTurnId: OWNER }),
+        handbackCouldOwnReply: true,
+      }),
+    ).toBe(true)
+  })
+
+  it('`none` never bypasses (nothing to attribute the reply to)', () => {
+    expect(
+      decideContentGateBypass({
+        tier: 'none',
+        resolvedTurnId: null,
+        candidates: cands({ latestEndedTurnId: null }),
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(false)
+  })
+
+  it('a STALE framework candidate corroborates NOTHING — the F2 freshness bound ' +
+    'still denies a past-TTL turn any bypass authority', () => {
+    const stale = cands({
+      originTurnId: OWNER,
+      latestEndedAgeMs: DEFAULT_SUPERSEDE_TTL_MS + 1,
+    })
+    expect(
+      decideContentGateBypass({
+        tier: 'origin',
+        resolvedTurnId: OWNER,
+        candidates: stale,
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(false)
+  })
+
+  it('`latest-ended` behaviour is UNCHANGED by the widening (it corroborates itself)', () => {
+    expect(
+      decideContentGateBypass({
+        tier: 'latest-ended',
+        resolvedTurnId: OWNER,
+        candidates: cands(),
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(true)
+  })
+
+  // ─── #3726: total over degenerate input, and it fails CLOSED ───
+  //
+  // TypeScript makes `candidates` mandatory and the gateway always constructs
+  // it, so this is production-unreachable — but the function is EXPORTED, and a
+  // caller without the gateway's construction discipline used to get a
+  // `TypeError` out of the supersede decision path (fail-open-by-crash) instead
+  // of the safe answer. The safe answer is `false`: keep the #3429 content gate.
+  it('#3726: an absent candidate set returns false (fail CLOSED), never throws', () => {
+    for (const tier of ['origin', 'quoted', 'latest-ended'] as const) {
+      for (const absent of [undefined, null]) {
+        expect(
+          decideContentGateBypass({
+            tier,
+            resolvedTurnId: OWNER,
+            candidates: absent as unknown as ReplyOwnerCandidates,
+            handbackCouldOwnReply: false,
+          }),
+        ).toBe(false)
+      }
+    }
+  })
+
+  // ─── ZERO new capability, as an EXHAUSTIVE property (#3724) ───
+  //
+  // The safety argument for widening `origin`/`quoted` from a blanket ban to
+  // corroboration: every shape that bypasses via a model-supplied tier ALSO
+  // bypasses with those model-supplied ids stripped (i.e. by the model simply
+  // omitting `origin_turn_id` / `reply_to`). So the widening hands a reply no
+  // reach it did not already have.
+  //
+  // #3724 — the previous form of this test hand-picked four candidate shapes and
+  // guarded its assertion behind `if (withModelIds)`, so one of the four
+  // asserted nothing at all, `handbackCouldOwnReply` was pinned `false`, and
+  // `liveTurnId` was never varied. It could only go red if the corroboration
+  // equality were deleted outright. It is replaced here by an exhaustive sweep
+  // of the whole (small) candidate space that derives `tier`/`resolvedTurnId`
+  // from the REAL resolvers rather than passing them in by hand — and, so the
+  // sweep is evidence rather than decoration, by a companion test that runs the
+  // SAME sweep over deliberately broken decisions and asserts it catches them.
+  const IDS = [null, OWNER, OTHER] as const
+  /** fresh / stale / unbounded (no age+ttl — the documented back-compat path). */
+  const AGES = [
+    { label: 'fresh', ageMs: 30_000 as number | null, ttlMs: DEFAULT_SUPERSEDE_TTL_MS as number | undefined },
+    { label: 'stale', ageMs: DEFAULT_SUPERSEDE_TTL_MS + 1, ttlMs: DEFAULT_SUPERSEDE_TTL_MS },
+    { label: 'unbounded', ageMs: null, ttlMs: undefined },
+  ]
+
+  type Decide = typeof decideContentGateBypass
+
+  /** The module's freshness rule, restated locally so the mutants below can
+   *  differ from the real decision in EXACTLY one respect each. */
+  const freshEnough = (c: ReplyOwnerCandidates): boolean =>
+    c.latestEndedTurnId != null &&
+    (c.latestEndedAgeMs == null || c.latestEndedTtlMs == null
+      ? true
+      : c.latestEndedAgeMs <= c.latestEndedTtlMs)
+
+  /**
+   * Sweep the full candidate space against `decide`, reporting every case that
+   * VIOLATES zero-new-capability (bypasses with the model-supplied ids present
+   * but not with them stripped) plus coverage counters that stop the sweep
+   * silently degrading to all-vacuous.
+   */
+  function sweepZeroNewCapability(decide: Decide): {
+    violations: string[]
+    cases: number
+    bypasses: number
+    modelTierBypasses: number
+  } {
+    const violations: string[] = []
+    let cases = 0
+    let bypasses = 0
+    let modelTierBypasses = 0
+    for (const liveTurnId of IDS)
+      for (const originTurnId of IDS)
+        for (const quotedTurnId of IDS)
+          for (const latestEndedTurnId of IDS)
+            for (const age of AGES)
+              for (const handbackCouldOwnReply of [false, true]) {
+                cases++
+                const c: ReplyOwnerCandidates = {
+                  liveTurnId,
+                  originTurnId,
+                  quotedTurnId,
+                  latestEndedTurnId,
+                  latestEndedAgeMs: age.ageMs,
+                  latestEndedTtlMs: age.ttlMs,
+                }
+                const tier = resolveReplyOwnerTier(c)
+                const withModelIds = decide({
+                  tier,
+                  resolvedTurnId: resolveReplyOwnerTurnId(c),
+                  candidates: c,
+                  handbackCouldOwnReply,
+                })
+                // Strip the model-supplied ids: the FRAMEWORK alone resolves the
+                // owner — the reach the model already had by staying silent.
+                const stripped: ReplyOwnerCandidates = {
+                  ...c,
+                  originTurnId: null,
+                  quotedTurnId: null,
+                }
+                const withoutModelIds = decide({
+                  tier: resolveReplyOwnerTier(stripped),
+                  resolvedTurnId: resolveReplyOwnerTurnId(stripped),
+                  candidates: stripped,
+                  handbackCouldOwnReply,
+                })
+                if (withModelIds) {
+                  bypasses++
+                  if (tier === 'origin' || tier === 'quoted') modelTierBypasses++
+                }
+                if (withModelIds && !withoutModelIds) {
+                  violations.push(
+                    `tier=${tier} live=${liveTurnId} origin=${originTurnId} ` +
+                      `quoted=${quotedTurnId} latestEnded=${latestEndedTurnId} ` +
+                      `age=${age.label} handback=${handbackCouldOwnReply}`,
+                  )
+                }
+              }
+    return { violations, cases, bypasses, modelTierBypasses }
+  }
+
+  it('ZERO new capability over the EXHAUSTIVE candidate space: no shape bypasses ' +
+    'with model-supplied ids that would not bypass without them', () => {
+    const r = sweepZeroNewCapability(decideContentGateBypass)
+    // The property itself — every violating shape is NAMED, not just counted.
+    expect(r.violations).toEqual([])
+    // Non-degeneracy: the sweep must actually cover the space and must actually
+    // reach the branch under test, so it can never quietly become a no-op.
+    expect(r.cases).toBe(IDS.length ** 4 * AGES.length * 2)
+    expect(r.bypasses).toBeGreaterThan(0)
+    // …and specifically, many cases must win their bypass on the WIDENED,
+    // model-steerable `origin`/`quoted` tiers — the thing being vouched for.
+    // Exactly 8 of the 486 cases do: no live turn, handback clear, a FRESH
+    // latest-ended id, and the steered id equal to it.
+    //
+    // This floor was 16 before #3725. The other 8 were the `latestEndedAgeMs
+    // == null` (unbounded) shapes, which corroborated a bypass off an anchor
+    // that had never ended. #3725 makes the latest-ended lookup `endedOnly`, so
+    // the age is always a real number and an explicit null age fails CLOSED —
+    // those 8 shapes are now correctly unreachable. Lowering the floor here is
+    // recording that narrowing, not conceding it: the property assertion above
+    // (`violations` empty) is unchanged and still passes.
+    expect(r.modelTierBypasses).toBeGreaterThanOrEqual(8)
+  })
+
+  // NON-VACUITY, asserted deterministically rather than demonstrated by hand:
+  // the same sweep is run over mutants that break zero-new-capability in the two
+  // realistic ways #3724 called out. If it could not go red on these, it would
+  // not be evidence for the real function.
+  it('the sweep is NOT vacuous: it catches a bypass that ignores corroboration, ' +
+    'and one that ignores the handback window on the steerable tiers', () => {
+    // Mutant A — the widening WITHOUT the corroboration equality: `origin`/
+    // `quoted` bypass on any resolved turn. This is the Fable silent-edit-over.
+    const ignoresCorroboration: Decide = (input) => {
+      if (input.tier === 'live') return true
+      if (input.tier === 'none') return false
+      if (input.handbackCouldOwnReply) return false
+      if (input.candidates == null) return false
+      if (input.tier === 'origin' || input.tier === 'quoted') return true
+      if (!freshEnough(input.candidates)) return false
+      return input.resolvedTurnId === input.candidates.latestEndedTurnId
+    }
+    const a = sweepZeroNewCapability(ignoresCorroboration)
+    expect(a.violations.length).toBeGreaterThan(0)
+
+    // Mutant B — corroboration kept, handback guard dropped on the steerable
+    // tiers only. The OLD hand-picked test stayed GREEN under exactly this,
+    // because it pinned `handbackCouldOwnReply: false` in every shape.
+    const ignoresHandback: Decide = (input) => {
+      if (input.tier === 'live') return true
+      if (input.tier === 'none') return false
+      const steerable = input.tier === 'origin' || input.tier === 'quoted'
+      if (input.handbackCouldOwnReply && !steerable) return false
+      if (input.candidates == null) return false
+      if (!freshEnough(input.candidates)) return false
+      return (
+        input.resolvedTurnId != null &&
+        input.resolvedTurnId === input.candidates.latestEndedTurnId
+      )
+    }
+    const b = sweepZeroNewCapability(ignoresHandback)
+    expect(b.violations.length).toBeGreaterThan(0)
+  })
+})
+
+/**
+ * #3725 — the "framework-derived, TTL-bounded" supersede anchor was neither
+ * ended nor bounded.
+ *
+ * The gateway's `recentTurnsById` registry is populated at turn START, so its
+ * tail entry for a chat can be a turn that is STILL RUNNING (`endedAt: null`) —
+ * and because the registry is chat-wide and thread-agnostic, a turn running in
+ * another topic of the same chat lands there. The gateway then computed
+ * `latestEndedAgeMs = endedAt != null ? now - endedAt : null`, and
+ * `latestEndedAccepted` treated a null age as UNBOUNDED (its back-compat escape
+ * for callers that supply no age at all). Net effect: a still-running turn
+ * became a corroborating anchor with NO freshness bound, for the widened
+ * `origin`/`quoted` content-gate bypass #3719 leans on.
+ *
+ * The fix is two-layer and both layers fail CLOSED:
+ *   1. the gateway lookup skips turns with no `endedAt` (`latestTurnForChat`
+ *      with `endedOnly: true`), so the anchor is a genuinely ended turn — and
+ *      when the chat has no ended turn, there is NO anchor rather than a
+ *      running one;
+ *   2. `latestEndedAccepted` distinguishes an OMITTED age (undefined ⇒
+ *      back-compat unbounded) from a COMPUTED-null age (⇒ rejected).
+ */
+describe('#3725 — a still-running turn is not a supersede anchor', () => {
+  const CHAT = '12345'
+  const ENDED = 'turn-ENDED'
+  const RUNNING = 'turn-RUNNING'
+
+  interface RegistryTurn { turnId: string; sessionChatId: string; endedAt: number | null }
+
+  const NOW = 1_000_000
+
+  /**
+   * The gateway's candidate construction (`resolveReplyOwnerTurn`), mirrored
+   * here because `gateway.ts` is not importable in tests — the same convention
+   * the rest of this file uses. `scan` selects the FIXED lookup (`endedOnly`)
+   * or the PRE-FIX one (tail entry regardless of `endedAt`), giving the
+   * red-on-main contrast as an assertion rather than prose.
+   */
+  function gatewayCandidates(
+    turns: RegistryTurn[],
+    scan: 'fixed' | 'prefix',
+    over: Partial<ReplyOwnerCandidates> = {},
+  ): ReplyOwnerCandidates {
+    const latestEnded =
+      scan === 'fixed'
+        ? latestTurnForChat(turns, CHAT, { endedOnly: true })
+        : (turns.filter((t) => t.sessionChatId === CHAT).at(-1) ?? null)
+    return {
+      liveTurnId: null,
+      originTurnId: null,
+      quotedTurnId: null,
+      latestEndedTurnId: latestEnded?.turnId ?? null,
+      latestEndedAgeMs: latestEnded?.endedAt != null ? NOW - latestEnded.endedAt : null,
+      latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
+      ...over,
+    }
+  }
+
+  /**
+   * The PRE-FIX resolver semantics, reproduced verbatim for the red-on-main
+   * contrast. BOTH layers of the defect are here: `latestEndedAccepted` treated
+   * a null age as unbounded (`age == null ⇒ true`), and the gateway's scan (the
+   * `'prefix'` mode above) handed it a turn that had not ended, whose age it
+   * therefore computed as null.
+   */
+  function preFixAccepted(c: ReplyOwnerCandidates): boolean {
+    if (c.latestEndedTurnId == null) return false
+    const age = c.latestEndedAgeMs
+    const ttl = c.latestEndedTtlMs
+    if (age == null || ttl == null) return true
+    return age <= ttl
+  }
+  function preFixTier(c: ReplyOwnerCandidates): ReplyOwnerTier {
+    if (c.liveTurnId != null) return 'live'
+    if (c.originTurnId != null) return 'origin'
+    if (c.quotedTurnId != null) return 'quoted'
+    if (preFixAccepted(c)) return 'latest-ended'
+    return 'none'
+  }
+  function preFixOwnerId(c: ReplyOwnerCandidates): string | null {
+    switch (preFixTier(c)) {
+      case 'live': return c.liveTurnId
+      case 'origin': return c.originTurnId
+      case 'quoted': return c.quotedTurnId
+      case 'latest-ended': return c.latestEndedTurnId
+      case 'none': return null
+    }
+  }
+  /** `decideContentGateBypass` as it stood before this fix (same rule, pre-fix
+   *  acceptance). */
+  function preFixBypass(c: ReplyOwnerCandidates): boolean {
+    const tier = preFixTier(c)
+    if (tier === 'live') return true
+    if (tier === 'none') return false
+    if (!preFixAccepted(c)) return false
+    const id = preFixOwnerId(c)
+    return id != null && id === c.latestEndedTurnId
+  }
+
+  /** A chat whose only ended turn is followed by a turn still running in
+   *  another topic — the registry tail is the RUNNING turn. */
+  const registry: RegistryTurn[] = [
+    { turnId: ENDED, sessionChatId: CHAT, endedAt: NOW - 10_000 },
+    { turnId: RUNNING, sessionChatId: CHAT, endedAt: null },
+  ]
+
+  it('the anchor is the ENDED turn, not the running tail entry (pre-fix scan ' +
+    'picked the running turn with a null — unbounded — age)', () => {
+    expect(gatewayCandidates(registry, 'fixed')).toMatchObject({
+      latestEndedTurnId: ENDED,
+      latestEndedAgeMs: 10_000,
+    })
+    expect(gatewayCandidates(registry, 'prefix')).toMatchObject({
+      latestEndedTurnId: RUNNING,
+      latestEndedAgeMs: null,
+    })
+  })
+
+  it('a model-steered `origin` echo of the RUNNING turn gets NO corroborated ' +
+    'bypass — pre-fix it did', () => {
+    const steered = { originTurnId: RUNNING }
+    const fixed = gatewayCandidates(registry, 'fixed', steered)
+    expect(
+      decideContentGateBypass({
+        tier: resolveReplyOwnerTier(fixed),
+        resolvedTurnId: resolveReplyOwnerTurnId(fixed),
+        candidates: fixed,
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(false)
+    // Red-on-main contrast: the same reply DID bypass the #3429 content gate
+    // before the fix, corroborated by a turn that had not even ended.
+    expect(preFixBypass(gatewayCandidates(registry, 'prefix', steered))).toBe(true)
+  })
+
+  it('a chat with ONLY a running turn yields NO owner and NO bypass (fail ' +
+    'closed), where pre-fix it yielded an unbounded latest-ended owner', () => {
+    const onlyRunning: RegistryTurn[] = [{ turnId: RUNNING, sessionChatId: CHAT, endedAt: null }]
+    const fixed = gatewayCandidates(onlyRunning, 'fixed')
+    expect(fixed.latestEndedTurnId).toBeNull()
+    expect(resolveReplyOwnerTier(fixed)).toBe('none')
+    expect(resolveReplyOwnerTurnId(fixed)).toBeNull()
+    expect(
+      decideContentGateBypass({
+        tier: 'none',
+        resolvedTurnId: null,
+        candidates: fixed,
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(false)
+
+    const prefix = gatewayCandidates(onlyRunning, 'prefix')
+    expect(preFixTier(prefix)).toBe('latest-ended')
+    expect(preFixOwnerId(prefix)).toBe(RUNNING)
+  })
+
+  it('layer 2: an EXPLICIT null age is rejected outright, while an OMITTED age ' +
+    'keeps the pre-F2 back-compat escape', () => {
+    const base: ReplyOwnerCandidates = {
+      liveTurnId: null,
+      originTurnId: null,
+      quotedTurnId: null,
+      latestEndedTurnId: ENDED,
+      latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
+    }
+    // Computed-null (the caller's candidate turn has not ended) ⇒ closed.
+    expect(resolveReplyOwnerTier({ ...base, latestEndedAgeMs: null })).toBe('none')
+    expect(resolveReplyOwnerTurnId({ ...base, latestEndedAgeMs: null })).toBeNull()
+    expect(
+      decideContentGateBypass({
+        tier: 'origin',
+        resolvedTurnId: ENDED,
+        candidates: { ...base, originTurnId: ENDED, latestEndedAgeMs: null },
+        handbackCouldOwnReply: false,
+      }),
+    ).toBe(false)
+    // Property omitted entirely ⇒ unchanged pre-F2 behaviour.
+    expect(resolveReplyOwnerTier(base)).toBe('latest-ended')
+    expect(resolveReplyOwnerTurnId(base)).toBe(ENDED)
+  })
+
+  it('end-to-end: a late reply while another topic is still running cannot ' +
+    "delete a DIFFERENT turn's flush record", () => {
+    const reg = new FlushedTurnSupersedeRegistry()
+    // The still-running turn holds a fresh flush record of its own.
+    reg.record(CHAT, undefined, { turnId: RUNNING, messageIds: [9001], text: 'A' }, NOW)
+    // A late reply lands with no live turn, no echo, no quote. Pre-fix its owner
+    // resolved to the RUNNING turn (registry tail, unbounded) and the take()
+    // consumed that turn's record; with the fix the owner is the ENDED turn, so
+    // the running turn's record is untouched.
+    const onlyRunning: RegistryTurn[] = [
+      { turnId: ENDED, sessionChatId: CHAT, endedAt: NOW - 10_000 },
+      { turnId: RUNNING, sessionChatId: CHAT, endedAt: null },
+    ]
+    const ownerId = resolveReplyOwnerTurnId(gatewayCandidates(onlyRunning, 'fixed'))
+    expect(ownerId).toBe(ENDED)
+    expect(reg.take(CHAT, undefined, { liveTurnId: ownerId, now: NOW + 10 }).supersede).toBe(false)
+    expect(reg.peek(CHAT, undefined, { liveTurnId: RUNNING, now: NOW + 10 }).supersede).toBe(true)
+  })
+})

package/telegram-plugin/tests/secret-detect-false-positives.test.ts

@@ -82,7 +82,7 @@ describe("secret-detect — DOES still fire on actually-shaped secrets (regressi
   // Locking in so a future regex-tightening doesn't over-shoot.
   // Values constructed at runtime so the source file doesn't trip
   // GitHub Push Protection — same pattern as
-  // secret-detect-secretlint.test.ts:1.
+  // secret-detect-sanctum.test.ts:18 (CLAUDE.md § Secrets in tests).
   const fakeApiKey = `sk-ant-${"a1b2c3d4".repeat(4)}XYZ987`; // sk-ant- + 32 chars
   const fakeBearer = `${"abc123".repeat(8)}.${"def456".repeat(4)}`;
   const fakeRandom = `${"x9zM4kP3qR7sT2vW".repeat(2)}`; // 32 chars, high entropy