switchroom 0.16.46 → 0.17.0

package/telegram-plugin/tests/inbound-delivery-confirm.test.ts

@@ -3,12 +3,15 @@ import { describe, expect, it } from 'vitest'
 import {
   ackDelivery,
   createDeliveryQueue,
+  extractEnqueueMessageIds,
   forgetDelivery,
+  isRedeliverySuspended,
   isTrackableResumeSynthetic,
   shouldTrackDelivery,
   sweep,
   trackDelivery,
   type DeliveryQueue,
+  type SuspendedTargets,
 } from '../gateway/inbound-delivery-confirm.js'
 
 /**
@@ -110,6 +113,52 @@ describe('inbound-delivery-confirm (reliable deliver-until-acked queue)', () =>
   })
 })
 
+// Regression for #2787 Mechanism A — a permission / ask_user card must suspend
+// the confirm sweep ONLY for its own chat/topic, never globally. Before the fix
+// the gateway early-returned the whole sweep whenever ANY card was pending
+// anywhere, so one card parked in a single topic (or the operator DM) froze
+// re-delivery of every stranded inbound across every topic until it resolved —
+// the ~5-minute all-topics stall of #1922. isRedeliverySuspended encodes the
+// scoped decision the sweep now makes per swept entry.
+describe('isRedeliverySuspended — per-topic sweep suspension (#2787 Mechanism A)', () => {
+  const none: SuspendedTargets = { keys: new Set(), chats: new Set() }
+
+  it('no cards open → nothing is suspended (sweep runs for every topic)', () => {
+    expect(isRedeliverySuspended('-100:4', none)).toBe(false)
+    expect(isRedeliverySuspended('555:_', none)).toBe(false)
+  })
+
+  it('reproduces the global-stall fix: a card in topic A does NOT suspend topic B', () => {
+    // A permission card is open in supergroup topic 4; a DIFFERENT topic (7) and
+    // an unrelated DM both have inbounds stranded in the composer.
+    const suspended: SuspendedTargets = { keys: new Set(['-100:4']), chats: new Set() }
+    expect(isRedeliverySuspended('-100:4', suspended)).toBe(true) // the card's own topic — deferred
+    expect(isRedeliverySuspended('-100:7', suspended)).toBe(false) // sibling topic keeps flowing
+    expect(isRedeliverySuspended('555:_', suspended)).toBe(false) // unrelated DM keeps flowing
+  })
+
+  it('a card fanned to the operator DM (chatId only, topic unknown) suspends just that chat', () => {
+    const suspended: SuspendedTargets = { keys: new Set(), chats: new Set(['999']) }
+    expect(isRedeliverySuspended('999:_', suspended)).toBe(true) // operator DM — deferred
+    expect(isRedeliverySuspended('-100:4', suspended)).toBe(false) // every topic elsewhere flows
+    expect(isRedeliverySuspended('555:_', suspended)).toBe(false)
+  })
+
+  it('drives the actual sweep: stranded siblings still re-deliver while one topic holds a card', () => {
+    const q = createDeliveryQueue<{ text: string }>()
+    trackDelivery(q, '-100:4', { text: 'msg in the card topic' }, 0)
+    trackDelivery(q, '-100:7', { text: 'msg in a sibling topic' }, 0)
+    trackDelivery(q, '555:_', { text: 'dm msg' }, 0)
+    const suspended: SuspendedTargets = { keys: new Set(['-100:4']), chats: new Set() }
+    // The gateway loop: sweep, then skip only entries suspended for their target.
+    const redelivered = sweep(q, 15_000, TIMEOUT).filter(
+      (p) => !isRedeliverySuspended(p.key, suspended),
+    )
+    const keys = redelivered.map((p) => p.key).sort()
+    expect(keys).toEqual(['-100:7', '555:_']) // the card's topic held; the rest flowed
+  })
+})
+
 // Regression for the cross-source ACK collision (silent drop): `enqueue` fires
 // for EVERY turn start regardless of source. A synthetic-source turn (cron /
 // resume / vault / reaction) that shares the chatKey of a real user message
@@ -151,6 +200,103 @@ describe('ackDelivery — message-id-matched (cross-source false-ack guard)', ()
   })
 })
 
+// Regression for #2786 — the enqueue-ack mismatch that re-delivers a RUNNING
+// turn (a duplicate turn / double-actioned user message). Delivery-confirm
+// re-parses the `<channel message_id="…">` envelope back out of the transcript
+// to match the ack. When the composer merges/reorders inbound envelopes, the
+// single re-parsed id can belong to a sibling, so strict equality mis-concludes
+// "never delivered" and the sweep re-delivers a turn already running. Passing
+// the raw enqueue content lets the ack tolerate that by scanning every id.
+describe('ackDelivery — composer-tolerant match (#2786 duplicate-turn guard)', () => {
+  const envelope = (id: string, text: string) =>
+    `<channel source="telegram" chat_id="555" message_id="${id}" user="ken">${text}</channel>`
+
+  it('reproduces the bug: strict re-parsed id mismatch would NOT ack (pre-fix)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'run the deploy' }, 0, '5002')
+    // Composer merged an earlier sibling first, so parseChannelMeta re-parsed
+    // the FIRST id (5001), not our tracked 5002. Without the content, no ack →
+    // the sweep would re-deliver the already-running turn (the duplicate).
+    expect(ackDelivery(q, 'chat:_', '5001')).toBe(false)
+    expect(sweep(q, 15_000, TIMEOUT)).toHaveLength(1) // would double-action
+  })
+
+  it('acks when the tracked id appears anywhere in the merged enqueue content', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'run the deploy' }, 0, '5002')
+    const merged = `${envelope('5001', 'hi')}\n${envelope('5002', 'run the deploy')}`
+    // First-parsed id is the sibling's 5001, but our 5002 is present in content.
+    expect(ackDelivery(q, 'chat:_', '5001', merged)).toBe(true)
+    expect(q.pending.size).toBe(0)
+    expect(sweep(q, 15_000, TIMEOUT)).toHaveLength(0) // no duplicate turn
+  })
+
+  it('acks on a reformatted single envelope where content still carries the id', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'x' }, 0, '5002')
+    // Re-parse yielded null (wrapper reformatted) but the id survives in content.
+    expect(ackDelivery(q, 'chat:_', null, envelope('5002', 'x'))).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+
+  it('preserves the cross-source false-ack guard: a synthetic turn whose content lacks our id does NOT ack', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg' }, 0, '5002')
+    // A cron/resume turn under the same key — its envelope carries a fabricated
+    // id, never the user's 5002. Even with content scanning, it must not ack.
+    const cron = envelope('1716123456789', 'scheduled digest')
+    expect(ackDelivery(q, 'chat:_', '1716123456789', cron)).toBe(false)
+    expect(q.pending.size).toBe(1)
+    expect(sweep(q, 15_000, TIMEOUT)).toHaveLength(1) // user msg re-delivered, not dropped
+  })
+
+  it('extractEnqueueMessageIds pulls every id from a merged envelope', () => {
+    const merged = `${envelope('5001', 'a')}\n${envelope('5002', 'b')}`
+    expect(extractEnqueueMessageIds(merged)).toEqual(['5001', '5002'])
+    expect(extractEnqueueMessageIds('no envelope here')).toEqual([])
+  })
+
+  // Regression for the unanchored-regex substring collision (silent-drop
+  // hazard on this never-drop path). `target_message_id`, `reply_to_message_id`,
+  // `original_message_id`, `card_message_id` etc. all END in `message_id="…"`.
+  // An unanchored /message_id="([^"]+)"/ grabs those siblings' values as if they
+  // were the real `message_id`, so a synthetic-source turn that merely REFERENCES
+  // message 5002 (e.g. `reply_to_message_id="5002"`) — without actually being
+  // message 5002 — would false-ack and silently drop the still-pending real
+  // inbound 5002. The regex must match ONLY the real `message_id` attribute.
+  it('does NOT extract same-suffix sibling attributes (target_/reply_to_/original_/card_message_id)', () => {
+    const content =
+      'target_message_id="5002" reply_to_message_id="5003" ' +
+      'original_message_id="5004" card_message_id="5005"'
+    expect(extractEnqueueMessageIds(content)).toEqual([])
+  })
+
+  it('extracts the real message_id even when a sibling *_message_id sits alongside it', () => {
+    const content =
+      '<channel source="reaction" chat_id="555" target_message_id="5002" ' +
+      'message_id="9999" user="ken">reacted</channel>'
+    // Only the real attribute (9999) is pulled — never the referenced 5002.
+    expect(extractEnqueueMessageIds(content)).toEqual(['9999'])
+  })
+
+  it('a sibling *_message_id="5002" reference does NOT false-ack a pending entry keyed on 5002 (substring-collision guard)', () => {
+    const q = fresh()
+    trackDelivery(q, 'chat:_', { text: 'real user msg 5002' }, 0, '5002')
+    // A synthetic-source turn (its own id 8000) merely REFERENCES 5002 via
+    // sibling attributes — it is not message 5002 itself.
+    const synthetic =
+      '<channel source="reaction" chat_id="555" message_id="8000" ' +
+      'target_message_id="5002" reply_to_message_id="5002" user="ken">👍</channel>'
+    expect(ackDelivery(q, 'chat:_', '8000', synthetic)).toBe(false)
+    // The real inbound 5002 is still pending — it strands and re-delivers, not dropped.
+    expect(q.pending.size).toBe(1)
+    expect(sweep(q, 15_000, TIMEOUT)).toHaveLength(1)
+    // Its own genuine envelope (real message_id="5002") later acks it cleanly.
+    expect(ackDelivery(q, 'chat:_', '5002', envelope('5002', 'real user msg 5002'))).toBe(true)
+    expect(q.pending.size).toBe(0)
+  })
+})
+
 // Regression for the steer/interrupt re-delivery loop: steering and `!`
 // interrupt inbounds amend the running turn and never emit `enqueue`, so they
 // must NOT be tracked (else the sweep re-delivers them forever). Only

package/telegram-plugin/tests/inbound-spool.test.ts

@@ -435,3 +435,146 @@ describe('inbound-spool — robustness', () => {
     ])
   })
 })
+
+describe('inbound-spool — #2789 C: multi-message drop notice reports the real count', () => {
+  it('passes the true per-chat dropped count to the coalesced notice', () => {
+    const fs = fakeFs()
+    let t = 0
+    const s = createInboundSpool({
+      path: PATH,
+      fs,
+      now: () => t,
+      escalateAfterMs: 100,
+      escalateNoticeCooldownMs: 10_000,
+    })
+    // Four undeliverable synthetics in ONE chat — the historical bug
+    // coalesced these into a notice that read as a SINGLE drop.
+    s.put('marko', msg({ messageId: 0, ts: 1, meta: { source: 'cron' } }))
+    s.put('marko', msg({ messageId: 0, ts: 2, meta: { source: 'cron' } }))
+    s.put('marko', msg({ messageId: 0, ts: 3, meta: { source: 'cron' } }))
+    s.put('marko', msg({ messageId: 0, ts: 4, meta: { source: 'cron' } }))
+    t = 1000 // all older than the 100ms bound
+    const posted: number[] = []
+    const seen: number[] = []
+    const dropped = s.sweepEscalations((_e, { postNotice, droppedCount }) => {
+      seen.push(droppedCount)
+      if (postNotice) posted.push(droppedCount)
+    })
+    expect(dropped).toBe(4) // all four retracted
+    // Every callback for this chat sees the true sweep count (4), and the
+    // ONE posted notice reports 4 — not 1.
+    expect(seen).toEqual([4, 4, 4, 4])
+    expect(posted).toEqual([4])
+  })
+
+  it('reports per-chat counts independently in a mixed sweep', () => {
+    const fs = fakeFs()
+    let t = 0
+    const s = createInboundSpool({
+      path: PATH,
+      fs,
+      now: () => t,
+      escalateAfterMs: 100,
+      escalateNoticeCooldownMs: 10_000,
+    })
+    // 3 in chat A, 1 in chat B.
+    s.put('m', msg({ chatId: 'A', messageId: 0, ts: 1, meta: { source: 'cron' } }))
+    s.put('m', msg({ chatId: 'A', messageId: 0, ts: 2, meta: { source: 'cron' } }))
+    s.put('m', msg({ chatId: 'A', messageId: 0, ts: 3, meta: { source: 'cron' } }))
+    s.put('m', msg({ chatId: 'B', messageId: 0, ts: 4, meta: { source: 'cron' } }))
+    t = 1000
+    const posted = new Map<string, number>()
+    s.sweepEscalations((e, { postNotice, droppedCount }) => {
+      if (postNotice) posted.set(String(e.msg.chatId), droppedCount)
+    })
+    expect(posted.get('A')).toBe(3)
+    expect(posted.get('B')).toBe(1)
+  })
+
+  it('a single drop still reports a count of 1', () => {
+    const fs = fakeFs()
+    let t = 0
+    const s = createInboundSpool({ path: PATH, fs, now: () => t, escalateAfterMs: 100 })
+    s.put('m', msg({ messageId: 0, ts: 1, meta: { source: 'cron' } }))
+    t = 1000
+    const counts: number[] = []
+    s.sweepEscalations((_e, { droppedCount }) => counts.push(droppedCount))
+    expect(counts).toEqual([1])
+  })
+})
+
+describe('inbound-spool — #2789 B: spool write failure surfaces a health signal', () => {
+  // An fs whose appendFileSync can be toggled to fail, modelling a full /
+  // unwritable persistent volume. The append swallows the error (delivery
+  // must not break) but the degradation must be SURFACED, not silent.
+  function toggleableFs(): InboundSpoolFsSeam & { fail: boolean } {
+    const files = new Map<string, string>()
+    const seam = {
+      fail: false,
+      appendFileSync(p: string, d: string) {
+        if (seam.fail) throw new Error('ENOSPC: no space left on device')
+        files.set(p, (files.get(p) ?? '') + d)
+      },
+      readFileSync: (p: string) => files.get(p) ?? '',
+      writeFileSync: (p: string, d: string) => files.set(p, d),
+      renameSync: (from: string, to: string) => {
+        files.set(to, files.get(from) ?? '')
+        files.delete(from)
+      },
+      existsSync: (p: string) => files.has(p),
+      statSizeSync: (p: string) => Buffer.byteLength(files.get(p) ?? ''),
+    }
+    return seam
+  }
+
+  it('raises a latched onDegraded signal when an append fails, and isDegraded() reflects it', () => {
+    const fs = toggleableFs()
+    const events: { degraded: boolean; consecutiveFailures: number }[] = []
+    const s = createInboundSpool({
+      path: PATH,
+      fs,
+      log: () => {},
+      onDegraded: (info) => events.push({ degraded: info.degraded, consecutiveFailures: info.consecutiveFailures }),
+    })
+    expect(s.isDegraded()).toBe(false)
+    fs.fail = true
+    // put() must NOT throw — live delivery keeps working, durability degrades.
+    expect(() => s.put('a', msg({ messageId: 1, ts: 1 }))).not.toThrow()
+    expect(s.isDegraded()).toBe(true)
+    expect(s.appendFailureCount()).toBe(1)
+    // Latched: exactly one transition event on entering degraded.
+    expect(events).toEqual([{ degraded: true, consecutiveFailures: 1 }])
+  })
+
+  it('does not re-fire the degraded signal on every failing append (latched)', () => {
+    const fs = toggleableFs()
+    const events: boolean[] = []
+    const s = createInboundSpool({
+      path: PATH, fs, log: () => {},
+      onDegraded: (info) => events.push(info.degraded),
+    })
+    fs.fail = true
+    s.put('a', msg({ messageId: 1, ts: 1 }))
+    s.put('a', msg({ messageId: 2, ts: 2 }))
+    s.put('a', msg({ messageId: 3, ts: 3 }))
+    expect(s.appendFailureCount()).toBe(3)
+    expect(events).toEqual([true]) // one transition, not three
+  })
+
+  it('surfaces recovery when appends succeed again (health signal un-latches)', () => {
+    const fs = toggleableFs()
+    const events: boolean[] = []
+    const s = createInboundSpool({
+      path: PATH, fs, log: () => {},
+      onDegraded: (info) => events.push(info.degraded),
+    })
+    fs.fail = true
+    s.put('a', msg({ messageId: 1, ts: 1 }))
+    expect(s.isDegraded()).toBe(true)
+    fs.fail = false
+    s.put('a', msg({ messageId: 2, ts: 2 }))
+    expect(s.isDegraded()).toBe(false)
+    expect(s.appendFailureCount()).toBe(0)
+    expect(events).toEqual([true, false]) // degraded → recovered
+  })
+})

package/telegram-plugin/tests/model-command.test.ts

@@ -184,7 +184,7 @@ describe("handleModelCommand — show / help never inject (picker-wedge guard)",
 });
 
 describe("handleModelCommand — set", () => {
-  it("injects exactly `/model <name>` once and relays output + persistence note", async () => {
+  it("injects exactly `/model <name>` once and relays a genuine confirmation + persistence note", async () => {
     const { deps, calls } = makeDeps();
     const reply = await handleModelCommand({ kind: "set", model: "opus" }, deps);
     expect(calls).toEqual([{ agent: "klanker", command: "/model opus" }]);
@@ -193,6 +193,59 @@ describe("handleModelCommand — set", () => {
     expect(reply.html).toBe(true);
   });
 
+  it("SILENT switch: suppresses raw pane scrollback instead of dumping it as a code block", async () => {
+    // claude switches models silently, so the pane capture below the command
+    // echo is just the agent's previous prose answer. It must NOT be relayed.
+    const scrollback = [
+      "Here's the summary you asked for earlier:",
+      "- point one about the deploy",
+      "- point two about the rollback plan",
+    ].join("\n");
+    const { deps } = makeDeps({ inject: async () => okResult(scrollback) });
+    const reply = await handleModelCommand({ kind: "set", model: "fable" }, deps);
+    // The leak: none of the scrollback prose reaches the reply, and there is
+    // no <pre> code block echoing the capture.
+    expect(reply.text).not.toContain("summary you asked for");
+    expect(reply.text).not.toContain("rollback plan");
+    expect(reply.text).not.toContain("<pre>");
+    // A clean, session-scoped confirmation is sent instead.
+    expect(reply.text).toContain("/model fable");
+    expect(reply.text).toContain("switched (session)");
+    expect(reply.text).toContain("Session-only");
+    expect(reply.html).toBe(true);
+  });
+
+  it("relays only the confirmation line when the capture also carries scrollback", async () => {
+    const mixed = [
+      "Some earlier prose that must not leak",
+      "⏺ Set model to Fable 5 for this session",
+    ].join("\n");
+    const { deps } = makeDeps({ inject: async () => okResult(mixed) });
+    const reply = await handleModelCommand({ kind: "set", model: "fable" }, deps);
+    expect(reply.text).toContain("<pre>⏺ Set model to Fable 5 for this session</pre>");
+    expect(reply.text).not.toContain("earlier prose that must not leak");
+  });
+
+  it("does NOT relay scrollback prose that merely contains 'switched'/'set model' as ordinary words", async () => {
+    // No line begins with claude's real confirmation phrasing — these are just
+    // English sentences that happen to use the words. None must be relayed.
+    const prose = [
+      "I switched the deploy to blue-green as we discussed.",
+      "Then I set model behaviour aside and moved on to the tests.",
+      "The team kept model changes out of this release entirely.",
+    ].join("\n");
+    const { deps } = makeDeps({ inject: async () => okResult(prose) });
+    const reply = await handleModelCommand({ kind: "set", model: "fable" }, deps);
+    // The anchored regex rejects all three lines, so nothing leaks and there is
+    // no <pre> block. A clean session confirmation is sent instead.
+    expect(reply.text).not.toContain("<pre>");
+    expect(reply.text).not.toContain("switched the deploy");
+    expect(reply.text).not.toContain("set model behaviour");
+    expect(reply.text).not.toContain("kept model changes");
+    expect(reply.text).toContain("switched (session)");
+    expect(reply.html).toBe(true);
+  });
+
   it("re-gates the model arg at the seam (caller bypassing the parser)", async () => {
     const { deps, calls } = makeDeps();
     const reply = await handleModelCommand({ kind: "set", model: "a b; reboot" }, deps);

package/telegram-plugin/tests/multitopic-routing-wiring.test.ts

@@ -50,15 +50,9 @@ describe('component 3 — turn-origin reply routing', () => {
     expect(fn).toMatch(/resolveAnswerThread\w*\(/)
   })
 
-  it('executeStreamReply resolves the answer thread via the origin turn too', () => {
-    const fn = gatewaySrc.split('async function executeStreamReply')[1]?.split('\nasync function ')[0] ?? ''
-    expect(fn).toMatch(/findTurnByOriginId\(args\.origin_turn_id/)
-    expect(fn).toMatch(/resolveAnswerThread\w*\(/)
-  })
-
-  it('the reply + stream_reply tool schemas expose origin_turn_id to the model', () => {
+  it('the reply tool schema exposes origin_turn_id to the model', () => {
     const occurrences = bridgeSrc.match(/origin_turn_id: \{ type: 'string'/g) ?? []
-    expect(occurrences.length).toBe(2) // reply + stream_reply
+    expect(occurrences.length).toBe(1) // reply
   })
 
   it('recentTurnsById is a BOUNDED registry (cannot grow unbounded)', () => {
@@ -78,8 +72,8 @@ describe('framework-owned origin recovery (determinism residual, 2026-06-05)', (
     expect(fn).toMatch(/recentTurnIdBySourceMessageId\.delete\(evicted\.sourceMessageId\)/)
   })
 
-  it('both reply paths recover origin from the quoted message_id when the model omits the echo', () => {
-    for (const name of ['executeReply', 'executeStreamReply']) {
+  it('the reply path recovers origin from the quoted message_id when the model omits the echo', () => {
+    for (const name of ['executeReply']) {
       const fn = gatewaySrc.split(new RegExp(`async function ${name}`))[1]?.split('\nasync function ')[0] ?? ''
       // Echo first (authoritative), quoted message_id as the framework fallback.
       expect(fn).toMatch(/const echoedTurn = findTurnByOriginId\(args\.origin_turn_id/)
@@ -144,7 +138,7 @@ describe('component 5 — queued-status UX (delete-on-answer)', () => {
 
   it('Hook C reaps the placeholder on the answer (executeReply / stream)', () => {
     const reapCalls = gatewaySrc.match(/reapQueuedStatus\(/g) ?? []
-    // definition + executeReply + executeStreamReply + purge cleanup (2 branches)
+    // definition + executeReply + purge cleanup (2 branches)
     expect(reapCalls.length).toBeGreaterThanOrEqual(4)
   })