switchroom 0.13.12 → 0.13.14

package/telegram-plugin/tests/pending-work-progress.test.ts

@@ -0,0 +1,354 @@
+/**
+ * Unit tests for cross-turn pending-async progress (#1445).
+ *
+ * Pins the deterministic state machine + edit cadence in isolation
+ * from the gateway. The integration with gateway hooks is exercised
+ * by the UAT scenario `silence-poke-debug-dm.test.ts`.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+
+import {
+  EDIT_INTERVAL_MS,
+  MAX_LIFETIME_MS,
+  TELEGRAM_MSG_CAP,
+  __getStateForTests,
+  __resetAllForTests,
+  __setDepsForTests,
+  __tickForTests,
+  clearPending,
+  noteAsyncDispatch,
+  noteOutbound,
+  noteTurnEnd,
+  startTurn,
+  type PendingProgressEditCtx,
+  type PendingProgressMetric,
+} from '../pending-work-progress.js'
+
+const KEY = '12345:_'
+
+interface Capture {
+  edits: PendingProgressEditCtx[]
+  metrics: PendingProgressMetric[]
+  now: number
+}
+
+function setup(): Capture {
+  const cap: Capture = { edits: [], metrics: [], now: 0 }
+  __resetAllForTests()
+  __setDepsForTests({
+    editMessage: async (ctx) => {
+      cap.edits.push(ctx)
+    },
+    emitMetric: (e) => {
+      cap.metrics.push(e)
+    },
+    nowMs: () => cap.now,
+  })
+  return cap
+}
+
+async function flush(): Promise<void> {
+  // Allow the fire-and-forget promise chain in tick() to settle.
+  await Promise.resolve()
+  await Promise.resolve()
+}
+
+describe('pending-work-progress', () => {
+  beforeEach(() => {
+    delete process.env.SWITCHROOM_DISABLE_PENDING_PROGRESS
+  })
+  afterEach(() => {
+    __resetAllForTests()
+  })
+
+  it('does nothing on turns without an async dispatch', () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'simple reply' })
+    noteTurnEnd(KEY)
+    expect(__getStateForTests(KEY)).toBeUndefined()
+    cap.now = 60_000
+    __tickForTests(cap.now)
+    expect(cap.edits).toHaveLength(0)
+    expect(cap.metrics).toHaveLength(0)
+  })
+
+  it('activates when turn ends with async dispatch + anchor', () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'worker dispatched' })
+    cap.now = 1_000
+    noteTurnEnd(KEY)
+    const s = __getStateForTests(KEY)
+    expect(s).toBeDefined()
+    expect(s?.activatedAt).toBe(1_000)
+    expect(s?.anchorMessageId).toBe(100)
+    expect(s?.anchorOriginalText).toBe('worker dispatched')
+    expect(cap.metrics).toContainEqual({
+      kind: 'pending_progress_started',
+      chatKey: KEY,
+    })
+  })
+
+  it('does not activate when async dispatch happened but no anchor was captured', () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    // no noteOutbound — model never sent a reply (silent end)
+    noteTurnEnd(KEY)
+    expect(__getStateForTests(KEY)).toBeUndefined()
+    cap.now = 60_000
+    __tickForTests(cap.now)
+    expect(cap.edits).toHaveLength(0)
+  })
+
+  it('does not activate when an anchor exists but no async dispatch happened', () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'just chatting' })
+    noteTurnEnd(KEY)
+    expect(__getStateForTests(KEY)).toBeUndefined()
+    cap.now = 60_000
+    __tickForTests(cap.now)
+    expect(cap.edits).toHaveLength(0)
+  })
+
+  it('edits anchor with elapsed-time suffix at EDIT_INTERVAL_MS cadence', async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, {
+      messageId: 100,
+      text: 'Background sleep running; awaiting completion.',
+    })
+    cap.now = 0
+    noteTurnEnd(KEY)
+
+    // Tick at half-interval — no edit yet.
+    cap.now = EDIT_INTERVAL_MS / 2
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits).toHaveLength(0)
+
+    // Tick at full interval — first edit fires, "1m" suffix.
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits).toHaveLength(1)
+    expect(cap.edits[0].messageId).toBe(100)
+    expect(cap.edits[0].newText).toBe(
+      'Background sleep running; awaiting completion.\n\n— still working (1m)',
+    )
+
+    // Tick at 3 intervals total — second edit, "3m".
+    cap.now = EDIT_INTERVAL_MS * 3
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits).toHaveLength(2)
+    expect(cap.edits[1].newText).toBe(
+      'Background sleep running; awaiting completion.\n\n— still working (3m)',
+    )
+  })
+
+  it('strips prior suffix before re-appending so anchor never accumulates', async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    // Simulate a noteOutbound for text that already carries a stale
+    // suffix from an earlier round (defence in depth).
+    noteOutbound(KEY, {
+      messageId: 100,
+      text: 'worker dispatched\n\n— still working (12m)',
+    })
+    noteTurnEnd(KEY)
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    // The new edit should be based on 'worker dispatched' alone.
+    expect(cap.edits[0].newText).toBe(
+      'worker dispatched\n\n— still working (1m)',
+    )
+  })
+
+  it("clears on 'inbound' reason — user re-engaged", () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'wd' })
+    noteTurnEnd(KEY)
+    cap.now = EDIT_INTERVAL_MS * 2
+    clearPending(KEY, 'inbound')
+    expect(__getStateForTests(KEY)).toBeUndefined()
+    expect(cap.metrics).toContainEqual({
+      kind: 'pending_progress_cleared',
+      chatKey: KEY,
+      elapsedMs: EDIT_INTERVAL_MS * 2,
+      reason: 'inbound',
+    })
+    // No further edits after clear.
+    cap.now = EDIT_INTERVAL_MS * 3
+    __tickForTests(cap.now)
+    expect(cap.edits).toHaveLength(0)
+  })
+
+  it("clears on 'handback' reason — model is about to re-engage", () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'wd' })
+    noteTurnEnd(KEY)
+    clearPending(KEY, 'handback')
+    expect(__getStateForTests(KEY)).toBeUndefined()
+    expect(cap.metrics.some((m) => m.kind === 'pending_progress_cleared' && m.reason === 'handback')).toBe(true)
+  })
+
+  it('times out at MAX_LIFETIME_MS', async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'wd' })
+    cap.now = 0
+    noteTurnEnd(KEY)
+    // Halfway — still active.
+    cap.now = MAX_LIFETIME_MS / 2
+    __tickForTests(cap.now)
+    await flush()
+    expect(__getStateForTests(KEY)).toBeDefined()
+    // Past the budget — auto-cleared.
+    cap.now = MAX_LIFETIME_MS + 1
+    __tickForTests(cap.now)
+    await flush()
+    expect(__getStateForTests(KEY)).toBeUndefined()
+    expect(cap.metrics.some((m) => m.kind === 'pending_progress_cleared' && m.reason === 'timeout')).toBe(true)
+  })
+
+  it('skips edit (but advances cadence) if total would exceed Telegram message cap', async () => {
+    const cap = setup()
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    // Anchor text long enough that even the smallest suffix overflows.
+    const bigText = 'x'.repeat(TELEGRAM_MSG_CAP - 5)
+    noteOutbound(KEY, { messageId: 100, text: bigText })
+    cap.now = 0
+    noteTurnEnd(KEY)
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits).toHaveLength(0)
+    // lastEditAt still advanced — we won't spin retrying every tick.
+    const s = __getStateForTests(KEY)
+    expect(s?.lastEditAt).toBe(EDIT_INTERVAL_MS)
+  })
+
+  it('honors the kill switch — no state, no edits, no metrics', async () => {
+    const cap = setup()
+    process.env.SWITCHROOM_DISABLE_PENDING_PROGRESS = '1'
+    try {
+      startTurn(KEY)
+      noteAsyncDispatch(KEY)
+      noteOutbound(KEY, { messageId: 100, text: 'wd' })
+      noteTurnEnd(KEY)
+      expect(__getStateForTests(KEY)).toBeUndefined()
+      cap.now = EDIT_INTERVAL_MS * 3
+      __tickForTests(cap.now)
+      await flush()
+      expect(cap.edits).toHaveLength(0)
+      expect(cap.metrics).toHaveLength(0)
+    } finally {
+      delete process.env.SWITCHROOM_DISABLE_PENDING_PROGRESS
+    }
+  })
+
+  it('startTurn resets per-turn fields but NOT cross-turn activation', () => {
+    const cap = setup()
+    // Turn 1: dispatches async, ends, pending-progress active.
+    startTurn(KEY)
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'wd' })
+    cap.now = 1_000
+    noteTurnEnd(KEY)
+    expect(__getStateForTests(KEY)?.activatedAt).toBe(1_000)
+    // Turn 2 starts (e.g. via the gateway's inbound path that already
+    // called clearPending). startTurn resets per-turn fields but the
+    // map entry has been deleted by clearPending, so this should
+    // simply do nothing dangerous if called against an absent key.
+    clearPending(KEY, 'inbound')
+    startTurn(KEY)
+    expect(__getStateForTests(KEY)).toBeUndefined()
+  })
+
+  it('no stale carryover: turn 1 activates, clearPending fires, turn 2 (no async) does not re-activate', async () => {
+    // Reproduces the reviewer's blocker #2 path: turn 1 with async
+    // dispatch activates pending-progress; an arriving turn 2 (real
+    // inbound OR synthesised wake) must clear state so a turn 2 that
+    // does NOT itself dispatch async never inherits the prior turn's
+    // `pending=true` and re-activates against turn 2's anchor.
+    const cap = setup()
+    // ── Turn 1: dispatch async, reply, end — activates.
+    noteAsyncDispatch(KEY)
+    noteOutbound(KEY, { messageId: 100, text: 'worker dispatched' })
+    cap.now = 1_000
+    noteTurnEnd(KEY)
+    expect(__getStateForTests(KEY)?.activatedAt).toBe(1_000)
+
+    // ── Inbound (or handback / cron / vault grant) for turn 2.
+    // Gateway clears state — exactly what the inbound/enqueue hooks
+    // wire up at handleInbound + handleSessionEvent.enqueue.
+    cap.now = 90_000
+    clearPending(KEY, 'inbound')
+    expect(__getStateForTests(KEY)).toBeUndefined()
+
+    // ── Turn 2: reply only, NO async dispatch this turn.
+    noteOutbound(KEY, { messageId: 200, text: 'just answering' })
+    cap.now = 91_000
+    noteTurnEnd(KEY)
+
+    // Turn 2 must NOT activate — no async was dispatched in this turn.
+    // Pre-fix this assertion would fail because the prior turn's
+    // `pending=true` was never reset and `noteTurnEnd` re-activated
+    // against turn 2's fresh anchor.
+    expect(__getStateForTests(KEY)).toBeUndefined()
+
+    // Confirm: no edits fire over the next several poll intervals.
+    cap.now = 91_000 + EDIT_INTERVAL_MS * 3
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits).toHaveLength(0)
+  })
+
+  it('multiple chats — independent state', async () => {
+    const cap = setup()
+    const KEY_A = 'A:_'
+    const KEY_B = 'B:42'
+    startTurn(KEY_A)
+    noteAsyncDispatch(KEY_A)
+    noteOutbound(KEY_A, { messageId: 10, text: 'wd-A' })
+    cap.now = 0
+    noteTurnEnd(KEY_A)
+
+    startTurn(KEY_B)
+    noteAsyncDispatch(KEY_B)
+    noteOutbound(KEY_B, { messageId: 20, text: 'wd-B' })
+    noteTurnEnd(KEY_B)
+
+    cap.now = EDIT_INTERVAL_MS
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits).toHaveLength(2)
+    const byMsg = new Map(cap.edits.map((e) => [e.messageId, e]))
+    expect(byMsg.get(10)?.chatId).toBe('A')
+    expect(byMsg.get(10)?.threadId).toBe(null)
+    expect(byMsg.get(20)?.chatId).toBe('B')
+    expect(byMsg.get(20)?.threadId).toBe(42)
+
+    // Clear A only; B should keep ticking.
+    clearPending(KEY_A, 'inbound')
+    cap.now = EDIT_INTERVAL_MS * 2
+    __tickForTests(cap.now)
+    await flush()
+    expect(cap.edits.filter((e) => e.messageId === 10)).toHaveLength(1)
+    expect(cap.edits.filter((e) => e.messageId === 20)).toHaveLength(2)
+  })
+})

package/telegram-plugin/tests/silent-end.test.ts

@@ -8,8 +8,10 @@ import {
   clearSilentEndState,
   readSilentEndState,
   recordSilentTurnEnd,
+  recordUndeliveredTurnEnd,
   SILENT_END_MAX_RETRIES,
 } from '../silent-end.js'
+import { isFinalAnswerReply } from '../final-answer-detect.js'
 
 let stateDir: string
 const ORIG_ENV = process.env.TELEGRAM_STATE_DIR
@@ -187,6 +189,118 @@ describe('recordSilentTurnEnd — #1161 exhaustion detection', () => {
   })
 })
 
+describe('recordUndeliveredTurnEnd — #1664 extended trigger', () => {
+  it('is the same function as recordSilentTurnEnd (semantic alias)', () => {
+    expect(recordUndeliveredTurnEnd).toBe(recordSilentTurnEnd)
+  })
+
+  // The gateway computes `finalAnswerDelivered` by OR-ing isFinalAnswerReply
+  // across every reply landed this turn, then engages the re-prompt iff the
+  // flag is still false at turn_end. These tests reproduce that exact
+  // decision: classify the turn's replies, then call recordUndeliveredTurnEnd
+  // only when no reply qualified.
+  function simulateTurnEnd(
+    replies: Array<{ text: string; disableNotification: boolean; done?: boolean }>,
+    turnKey: string,
+  ): { finalAnswerDelivered: boolean; rePromptEngaged: boolean } {
+    const finalAnswerDelivered = replies.some((r) =>
+      isFinalAnswerReply(r),
+    )
+    let rePromptEngaged = false
+    if (finalAnswerDelivered === false) {
+      recordUndeliveredTurnEnd({ chatId: 'c', threadId: null, turnKey })
+      rePromptEngaged = true
+    }
+    return { finalAnswerDelivered, rePromptEngaged }
+  }
+
+  it('#1664 regression: ack reply + answer-as-transcript → re-prompt fires', () => {
+    // The exact #1664 shape: the model sent a short interim ack via the
+    // reply tool (disable_notification:true), then ended the turn with its
+    // real answer as plain transcript text — which the gateway renders into
+    // an ephemeral draft and retracts at turn_end, never finalized. No
+    // reply qualified as the final answer, so the turn is undelivered.
+    const r = simulateTurnEnd(
+      [{ text: 'On it — give me a moment.', disableNotification: true }],
+      'c:1664',
+    )
+    expect(r.finalAnswerDelivered).toBe(false)
+    expect(r.rePromptEngaged).toBe(true)
+    // State file written so silent-end-interrupt-stop.mjs blocks the stop.
+    expect(readSilentEndState()).toMatchObject({ turnKey: 'c:1664', retryCount: 0 })
+  })
+
+  it('a turn with a final-answer reply (notification-bearing) → re-prompt NOT engaged', () => {
+    const r = simulateTurnEnd(
+      [{ text: 'Here is the answer.', disableNotification: false }],
+      'c:final',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('a long reply mis-marked interim → re-prompt NOT engaged (length backstop)', () => {
+    const r = simulateTurnEnd(
+      [{ text: 'x'.repeat(500), disableNotification: true }],
+      'c:long',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('zero-outbound turn → re-prompt still engaged (regression of the original case)', () => {
+    // No replies at all — the original #1122 silent-end case is now just
+    // the subset of "no final answer delivered" where nothing landed.
+    const r = simulateTurnEnd([], 'c:zero')
+    expect(r.finalAnswerDelivered).toBe(false)
+    expect(r.rePromptEngaged).toBe(true)
+    expect(readSilentEndState()).toMatchObject({ turnKey: 'c:zero', retryCount: 0 })
+  })
+
+  it('interim ack followed by a final-answer reply in the same turn → NOT engaged', () => {
+    // The model ack'd first then properly delivered — finalAnswerDelivered
+    // latches true on the second reply; the turn is answered.
+    const r = simulateTurnEnd(
+      [
+        { text: 'Looking into it…', disableNotification: true },
+        { text: 'Done — the result is 42.', disableNotification: false },
+      ],
+      'c:ack-then-final',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('stream_reply done=true counts as the final answer → NOT engaged', () => {
+    const r = simulateTurnEnd(
+      [{ text: 'ok', disableNotification: true, done: true }],
+      'c:stream-done',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('exhaustion still applies on the #1664 path after the Stop-hook re-prompt', () => {
+    // First undelivered turn-end writes state.
+    expect(simulateTurnEnd(
+      [{ text: 'one sec', disableNotification: true }],
+      'c:exhaust',
+    ).rePromptEngaged).toBe(true)
+    // Stop hook blocks once and bumps retryCount (simulated).
+    const path = join(stateDir, 'silent-end-pending.json')
+    const s = readSilentEndState()!
+    writeFileSync(path, JSON.stringify({ ...s, retryCount: s.retryCount + 1 }))
+    // Re-prompted turn STILL ends with only an interim ack → exhausted.
+    const second = recordUndeliveredTurnEnd({ chatId: 'c', threadId: null, turnKey: 'c:exhaust' })
+    expect(second.exhausted).toBe(true)
+    expect(readSilentEndState()).toBeNull()
+  })
+})
+
 describe('silent-end-interrupt-stop hook — integration', () => {
   const hookPath = join(__dirname, '..', 'hooks', 'silent-end-interrupt-stop.mjs')
 
@@ -222,6 +336,10 @@ describe('silent-end-interrupt-stop hook — integration', () => {
     const out = JSON.parse(r.stdout.trim())
     expect(out.decision).toBe('block')
     expect(out.reason).toContain('reply')
+    // #1664 — the re-prompt must offer the NO_REPLY escape hatch so a
+    // model that already delivered (or intentionally has nothing to add)
+    // can end the turn cleanly instead of being forced to re-send.
+    expect(out.reason).toContain('NO_REPLY')
     // retryCount must have been incremented to 1
     expect(readSilentEndState()!.retryCount).toBe(1)
   })