switchroom 0.19.22 → 0.19.24

package/telegram-plugin/tests/captured-answer-resume.test.ts

@@ -271,6 +271,110 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
     expect(oblLedger.isOpen('#t1')).toBe(false)
   })
 
+  // #3702 L3 — the close condition is LANDED, not confirmed. A snapshot whose
+  // chunks all landed but were NEVER corroborated (the read-back is 100% shed in
+  // production, #3703) is resolved on HYDRATION alone: the resume re-probes,
+  // resolves nothing again, sends zero messages, and closes.
+  //
+  // This is the case the durable outbound-text oracle CANNOT reach — history
+  // disabled here, so `hasOutboundWithText` never fires and the old
+  // confirmation-gated verdict would have kept the obligation OPEN, re-running
+  // the same shed probe on every sweep with no send available to it, until the
+  // represent cap escalated a false "never answered you" to the operator.
+  it('fully-landed-but-UNCONFIRMED snapshot, no oracle ⇒ ZERO sends and the obligation CLOSES', async () => {
+    const chunks = ['c0', 'c1']
+    const snapshot = {
+      chunks,
+      chunkStates: [
+        { index: 0, messageIds: [5000], confirmed: false },
+        { index: 1, messageIds: [5001], confirmed: false },
+      ],
+    }
+    const resumeLedger = new BackstopDeliveryLedger()
+    const sentIdx: number[] = []
+    const oblLedger = new ObligationLedger(2)
+    oblLedger.openIfAbsent(obligation({ capturedDelivery: snapshot }))
+    oblLedger.noteCapturedDelivery('#t1', snapshot)
+
+    // No durable corroboration is available from EITHER source: the snapshot
+    // flags are false, history is off, and the re-probe sheds (ambiguous).
+    mockOracle = () => false
+
+    const lines: string[] = []
+    const dispatcher = createCapturedResumeDispatcher({
+      deliverAnswer: async (a) => {
+        a.resume.hydrate(resumeLedger, a.turnId)
+        const res = await runBackstopDelivery(
+          resumeLedger, a.turnId, a.resume.snapshot.chunks, a.cardMessageId,
+          {
+            sendChunk: async (i: number) => { sentIdx.push(i); return [7000 + i] },
+            readBack: async (): Promise<ReadBackResult> => 'ambiguous',
+          },
+          3,
+        )
+        expect(res.confirmed).toBe(false) // nothing corroborated it, at any point
+        expect(res.landedUnconfirmedIds).toEqual([5000, 5001]) // ...and it is counted
+        return { delivered: res.delivered, sentIds: res.sentIds }
+      },
+      obligationLedger: oblLedger,
+      backstopDeliveryLedger: resumeLedger,
+      flushedTurnSupersede: { record: () => {} },
+      historyEnabled: false,
+      stderr: (s) => lines.push(s),
+    })
+    dispatcher.dispatch(oblLedger.list()[0])
+    await flush(dispatcher)
+
+    expect(sentIdx).toEqual([]) // nothing re-posted — the user never sees a duplicate
+    expect(oblLedger.isOpen('#t1')).toBe(false) // closed on the landed-id evidence
+    // ...and the log must say what actually happened. These ids are LANDED, not
+    // confirmed: calling them "confirmed" is the overstatement #3702 removed from
+    // the verdict, and a log that reintroduces it re-lies to the next debugger.
+    const closed = lines.find((l) => l.includes('resume delivered'))
+    expect(closed).toBeDefined()
+    expect(closed).toContain('2 message id(s) landed')
+    expect(closed).not.toContain('confirmed')
+  })
+
+  // The other half of that decision: a positive ABSENCE still re-opens the send
+  // path, so "landed" is not a rubber stamp. (Inert in production until #3703
+  // wakes the probe, but the mechanism must remain correct.)
+  it('a landed chunk the re-probe finds ABSENT is demoted and RE-SENT, not closed on the stale id', async () => {
+    const chunks = ['c0']
+    const snapshot = { chunks, chunkStates: [{ index: 0, messageIds: [5000], confirmed: false }] }
+    const resumeLedger = new BackstopDeliveryLedger()
+    const sentIdx: number[] = []
+    const oblLedger = new ObligationLedger(2)
+    oblLedger.openIfAbsent(obligation({ capturedDelivery: snapshot }))
+    oblLedger.noteCapturedDelivery('#t1', snapshot)
+    mockOracle = () => false
+
+    let probes = 0
+    const dispatcher = createCapturedResumeDispatcher({
+      deliverAnswer: async (a) => {
+        a.resume.hydrate(resumeLedger, a.turnId)
+        const res = await runBackstopDelivery(
+          resumeLedger, a.turnId, a.resume.snapshot.chunks, a.cardMessageId,
+          {
+            sendChunk: async (i: number) => { sentIdx.push(i); return [7000 + i] },
+            readBack: async (): Promise<ReadBackResult> => (++probes === 1 ? 'absent' : 'exists'),
+          },
+          3,
+        )
+        return { delivered: res.delivered, sentIds: res.sentIds }
+      },
+      obligationLedger: oblLedger,
+      backstopDeliveryLedger: resumeLedger,
+      flushedTurnSupersede: { record: () => {} },
+      historyEnabled: false,
+    })
+    dispatcher.dispatch(oblLedger.list()[0])
+    await flush(dispatcher)
+
+    expect(sentIdx).toEqual([0]) // the silently-dropped chunk IS re-sent
+    expect(oblLedger.isOpen('#t1')).toBe(false)
+  })
+
   it('a partial RESUME (tail still fails) leaves the obligation OPEN + consumes represent budget', async () => {
     const chunks = ['c0', 'c1']
     const snapshot = {

package/telegram-plugin/tests/latest-turn-lookup.test.ts

@@ -0,0 +1,77 @@
+/**
+ * #3725 — the "latest-ended" supersede anchor was the most-recently-STARTED turn.
+ *
+ * `recentTurnsById` is populated at turn START (`rememberRecentTurn` fires from
+ * the `enqueue` lifecycle event in `stream-render.ts`, and the atom is built with
+ * `endedAt: null`; `endedAt` is stamped later in `turn-end.ts`). The gateway's
+ * lookup had NO `endedAt` filter, so `findLatestEndedTurnForChat` returned the
+ * chat's tail entry even when that turn was still RUNNING — its own docstring
+ * admitted it ("the most-recently-STARTED turn") while the name and every caller
+ * said otherwise. Because the registry is chat-wide and thread-agnostic, a turn
+ * running in ANOTHER topic of the same chat was a live route into that state.
+ *
+ * These tests pin the OUTCOME of the scan (which turn comes back), not the
+ * shape of the code.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { latestTurnForChat, type LatestTurnLookupAtom } from '../gateway/latest-turn-lookup.js'
+
+interface Turn extends LatestTurnLookupAtom {
+  turnId: string
+  sessionThreadId?: number
+}
+
+const CHAT = '12345'
+const OTHER_CHAT = '99999'
+
+/** Registry insertion order = turn-START order (what `rememberRecentTurn` does). */
+const registry = (...turns: Turn[]): Map<string, Turn> =>
+  new Map(turns.map((t) => [t.turnId, t]))
+
+describe('latestTurnForChat — endedOnly (#3725)', () => {
+  it('does NOT return a still-running turn as the latest ENDED turn — it falls ' +
+    'back to the most recent turn that actually ended', () => {
+    // Topic A ended at t=1000; topic B started after and is STILL RUNNING, so it
+    // sits at the registry tail. This is the exact incident shape.
+    const ended = { turnId: 'A#1', sessionChatId: CHAT, endedAt: 1_000, sessionThreadId: 11 }
+    const running = { turnId: 'B#2', sessionChatId: CHAT, endedAt: null, sessionThreadId: 22 }
+    const turns = registry(ended, running)
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: true })).toBe(ended)
+    // The routing consumer still wants the tail entry (running or not) — it only
+    // picks a topic to deliver into and deletes nothing.
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: false })).toBe(running)
+  })
+
+  it('returns NULL when the chat has only a running turn — the destructive tier ' +
+    'gets no anchor at all rather than an unbounded one (fail closed)', () => {
+    const turns = registry({ turnId: 'B#2', sessionChatId: CHAT, endedAt: null })
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: true })).toBeNull()
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: false })).not.toBeNull()
+  })
+
+  it('picks the LAST ended turn in insertion order when several have ended', () => {
+    const turns = registry(
+      { turnId: 'A#1', sessionChatId: CHAT, endedAt: 1_000 },
+      { turnId: 'A#2', sessionChatId: CHAT, endedAt: 2_000 },
+      { turnId: 'B#3', sessionChatId: CHAT, endedAt: null },
+    )
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: true })?.turnId).toBe('A#2')
+  })
+
+  it('never crosses chats (the scan is chat-scoped in BOTH modes)', () => {
+    const turns = registry(
+      { turnId: 'A#1', sessionChatId: CHAT, endedAt: 1_000 },
+      { turnId: 'X#1', sessionChatId: OTHER_CHAT, endedAt: 2_000 },
+      { turnId: 'X#2', sessionChatId: OTHER_CHAT, endedAt: null },
+    )
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: true })?.turnId).toBe('A#1')
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: false })?.turnId).toBe('A#1')
+    expect(latestTurnForChat(turns.values(), 'nobody', { endedOnly: false })).toBeNull()
+  })
+
+  it('an endedAt of 0 counts as ENDED (null is the only "still running" marker)', () => {
+    const turns = registry({ turnId: 'A#1', sessionChatId: CHAT, endedAt: 0 })
+    expect(latestTurnForChat(turns.values(), CHAT, { endedOnly: true })?.turnId).toBe('A#1')
+  })
+})

package/telegram-plugin/tests/narrative-lane-golden.test.ts

@@ -35,6 +35,28 @@ import { FlushedTurnSupersedeRegistry } from '../flushed-turn-supersede.js'
 import { BackstopDeliveryLedger } from '../gateway/backstop-delivery.js'
 import { redact } from '../secret-detect/redact.js'
 import type { CurrentTurn, NarrativeLaneDeps } from '../gateway/gateway.js'
+import type { ReplyOwnerTier } from '../reply-owner-resolve.js'
+
+/** The owner-resolution shape `resolveReplyOwnerTurn` returns, including the
+ *  candidate set the content-gate bypass corroborates against. These fixtures
+ *  never exercise the supersede path, so the candidates mirror the resolved turn
+ *  (the corroborated shape) with no override needed. */
+function ownerRes(turn: CurrentTurn | null, tier: ReplyOwnerTier) {
+  const id = turn?.turnId ?? null
+  return {
+    turn,
+    tier,
+    candidates: {
+      liveTurnId: tier === 'live' ? id : null,
+      originTurnId: null,
+      quotedTurnId: null,
+      latestEndedTurnId: id,
+      latestEndedAgeMs: 1_000,
+      latestEndedTtlMs: 60_000,
+    },
+  }
+}
+
 
 const CHAT = '1001'
 
@@ -371,7 +393,7 @@ function makeSendReplyDeps(dedup: OutboundDedupCache) {
     assertSendable: () => {},
     statusKey: key,
     streamKey: key,
-    resolveReplyOwnerTurn: () => ({ turn: null, tier: 'none' as const }),
+    resolveReplyOwnerTurn: () => ownerRes(null, 'none'),
     getLastSubagentHandbackAt: () => null,
     findTurnByOriginId: () => null,
     findTurnByQuotedMessageId: () => null,