switchroom 0.19.23 → 0.19.25

package/telegram-plugin/tests/stream-controller-send-gate.test.ts

@@ -16,12 +16,16 @@
  *     collapse; the latest snapshot lands floor-paced
  *   - the floor is per-message (stream A does not delay stream B)
  *   - the gate's no-op skip drops a repeat payload for the same message
- *   - an open flood window sheds draft edits with ZERO API calls, and the
- *     stream recovers with full state after the window closes
- *   - a shed draft is NOT recorded as delivered — a later flush of the
- *     SAME text (the completed answer) still lands
+ *   - an open flood window COALESCES draft edits with ZERO API calls, and the
+ *     newest state lands once the window closes (#3716 — cosmetic edits are
+ *     never shed; the last edit of a burst is the one still on screen, so
+ *     dropping it stranded the message on a stale body)
+ *   - a draft held through a window still renders the completed answer — a
+ *     later flush of the SAME text is then a benign no-op, not a loss
  *   - the finalize flush is `critical`: never shed; waits out a short
  *     window; fails fast (structured, logged) on a long one
+ *   - shed-honesty (F2+F3) remains wired for any `SEND_GATE_SHED` the retry
+ *     policy does return, pinned directly rather than through the gate
  *   - regression pin: the controller passes messageId / editPayload /
  *     priorityClass through the retry policy on every edit
  *
@@ -32,7 +36,7 @@
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { createStreamController, type RetryPolicy } from '../stream-controller.js'
-import { createSendGate, type Clock, type SendGateConfig } from '../send-gate.js'
+import { createSendGate, SEND_GATE_SHED, type Clock, type SendGateConfig } from '../send-gate.js'
 import { isFloodWaitActiveError } from '../retry-api-call.js'
 import { renderOutboundChunks } from '../render/rich-render.js'
 import { createMockBot, installBotResetHook } from './bot-api.harness.js'
@@ -221,7 +225,7 @@ describe('stream-controller × send gate (#3110)', () => {
     expect(bot.api.editMessageText).toHaveBeenCalledTimes(1)
   })
 
-  it('open flood window: draft edits shed with ZERO API calls; full state lands after it closes', async () => {
+  it('open flood window: draft edits COALESCE with ZERO API calls; newest state lands after it closes (#3716)', async () => {
     const { clock, gate, retry } = makeGatedRetry({ editFloorMs: 1500 })
     const stream = createStreamController({
       bot, chatId: '1', throttleMs: 250, retry, initialMessageId: 7777,
@@ -233,17 +237,24 @@ describe('stream-controller × send gate (#3110)', () => {
     await flush()
     void stream.update('draft b')
     await tick()
-    // Both drafts shed as cosmetic — nothing reached the API.
+    // Flood safety is unchanged — still ZERO API calls while the window is
+    // open. What changed is the mechanism: the drafts are HELD (last-write-
+    // wins), not discarded, so no state is lost.
     expect(bot.api.editMessageText).not.toHaveBeenCalled()
-    expect(gate.stats().global.shed).toBe(2)
+    expect(gate.stats().global.shed).toBe(0)
 
-    await clock.advance(30_000) // window closes
+    await clock.advance(30_000) // window closes → the held draft lands
     void stream.update('draft c — full state')
     await tick()
-    expect(editBodies()).toEqual(['draft c — full state'])
+    await clock.advance(1_500) // clear the per-message edit floor
+
+    // The guarantee is the newest state reaches the screen, never that some
+    // intermediate was dropped to get there.
+    expect(editBodies().at(-1)).toBe('draft c — full state')
+    expect(gate.stats().global.shed).toBe(0)
   })
 
-  it('a shed draft is NOT recorded as delivered: a later finalize of the SAME text still lands', async () => {
+  it('a draft held through a window still renders: the completed answer reaches the screen exactly once', async () => {
     const { clock, gate, retry } = makeGatedRetry({ editFloorMs: 1500 })
     const stream = createStreamController({
       bot, chatId: '1', throttleMs: 250, retry, initialMessageId: 7777,
@@ -253,12 +264,16 @@ describe('stream-controller × send gate (#3110)', () => {
     void stream.update('the completed answer')
     await flush()
     expect(bot.api.editMessageText).not.toHaveBeenCalled()
-    expect(gate.stats().global.shed).toBe(1)
+    expect(gate.stats().global.shed).toBe(0)
 
-    await clock.advance(30_000)
-    // stream_reply done=true with the same text → finalize(text). If the shed
-    // draft had been recorded as on-screen, draft-stream's dedupe would skip
-    // this flush and the completed answer would never render.
+    await clock.advance(30_000) // window closes → the held draft lands
+
+    // stream_reply done=true with the same text → finalize(text). Pre-#3716
+    // the draft was SHED here, and the guarantee was that the stream must not
+    // record it as on-screen so this flush could re-deliver it. Now the draft
+    // is never dropped, so it renders on its own and the identical finalize is
+    // a benign no-op. Either way the user sees the completed answer — and now
+    // it costs one API call instead of two.
     await stream.finalize('the completed answer')
     expect(editBodies()).toEqual(['the completed answer'])
   })
@@ -277,7 +292,7 @@ describe('stream-controller × send gate (#3110)', () => {
     gate.openFloodWindow('global', clock.now() + 30_000) // short: <= 60s fail-fast ceiling
     void stream.update('draft while banned')
     await flush()
-    expect(bot.api.editMessageText).not.toHaveBeenCalled() // draft shed
+    expect(bot.api.editMessageText).not.toHaveBeenCalled() // draft held, not sent
 
     const fin = stream.finalize('the answer')
     await flush()
@@ -286,9 +301,12 @@ describe('stream-controller × send gate (#3110)', () => {
 
     await clock.advance(30_000)
     await fin
+    // The critical finalize coalesced ONTO the held draft and upgraded its
+    // class, so the whole burst resolves as a single send carrying the final
+    // body — the draft is superseded rather than dropped.
     expect(editBodies()).toEqual(['the answer'])
     expect(editTimes).toEqual([30_000])
-    expect(gate.stats().global.shed).toBe(1) // only the draft
+    expect(gate.stats().global.shed).toBe(0) // nothing is shed any more
   })
 
   it('finalize under a LONG window fails fast (structured FLOOD_WAIT_ACTIVE, logged) — no API call, no hang', async () => {
@@ -316,6 +334,40 @@ describe('stream-controller × send gate (#3110)', () => {
     }
   })
 
+  /**
+   * REGRESSION PIN for the trap #3716 opened. Once cosmetic edits stopped
+   * shedding they began OCCUPYING the driver, and draft-stream serializes its
+   * own flushes — so a draft parked behind a 6h ban held the finalize upstream
+   * of the gate, where the fail-fast path could never see it. `failedFast` went
+   * to 0 and the reply path wedged for the length of the ban: the exact failure
+   * the gate was built to eliminate, reintroduced by the fix for a different
+   * one. The preceding test does NOT catch this — it finalizes with no draft in
+   * flight.
+   */
+  it('a draft parked behind a LONG window never wedges the finalize behind it (#3716)', async () => {
+    const { clock, gate, retry } = makeGatedRetry({ editFloorMs: 1500 })
+    const logs: string[] = []
+    const stream = createStreamController({
+      bot, chatId: '1', throttleMs: 250, retry, initialMessageId: 7777,
+      log: (m) => logs.push(m),
+    })
+
+    gate.openFloodWindow('global', clock.now() + 21_397_000) // the 2026-07-12 ban: ~5.9h
+    void stream.update('draft while banned')
+    await flush()
+    expect(gate.stats().global.shed).toBe(0) // held, not dropped
+
+    // The cosmetic draft settles its caller as soon as it is queued, so the
+    // finalize reaches the gate. If it did not, this await never returns.
+    const fin = stream.finalize('the answer')
+    await tick()
+    await fin
+
+    expect(gate.stats().global.failedFast).toBe(1)
+    expect(bot.api.editMessageText).not.toHaveBeenCalled()
+    expect(logs.some((m) => m.includes('FLOOD_WAIT_ACTIVE'))).toBe(true)
+  })
+
   it('REGRESSION PIN: every edit passes messageId / editPayload / priorityClass to the retry policy', async () => {
     // Spy retry with NO gate — pins exactly what the controller hands to
     // robustApiCall (the #3110 bypass was these fields being absent).
@@ -474,7 +526,7 @@ describe('stream-controller × send gate (#3110)', () => {
     expect(bot.api.editMessageText.mock.calls.length).toBe(editCalls)
   })
 
-  it('a shed TAIL is not recorded as delivered: argument-less finalize() re-flushes and lands it (F2+F3)', async () => {
+  it('a TAIL suppressed by a msg-scoped window is HELD, not lost: the completed answer lands when it closes', async () => {
     const { clock, gate, retry } = makeGatedRetry({
       editFloorMs: 1500,
       globalPerSec: 1000, globalBurst: 100, perChatPerSec: 1000, perChatBurst: 100,
@@ -495,27 +547,81 @@ describe('stream-controller × send gate (#3110)', () => {
     const lastTailId = anchorId + pieceCount - 1
 
     // Flood window scoped to the LAST tail message only (H1 msg-edit scope):
-    // its edit sheds; the anchor and other pieces are unaffected.
+    // its edit is suppressed; the anchor and other pieces are unaffected.
     gate.openFloodWindow(`msg-edit:1:${lastTailId}`, clock.now() + 30_000)
 
     void stream.update(b2)
     await tick()
-    // The changed piece is the suppressed tail → shed, zero edits landed on
-    // it; the flush is reported shed and the snapshot preserved (F2), NOT
-    // recorded as delivered (F3).
+    // The changed piece is the suppressed tail → zero edits land on it while
+    // the window is open. Pre-#3716 it was SHED and the completed answer only
+    // survived because the stream refused to record it as delivered; now the
+    // edit is held by the gate, so the content is safe by construction.
     const tailEdits = () =>
       bot.api.editMessageText.mock.calls.filter(([, id]) => id === lastTailId)
     expect(tailEdits()).toHaveLength(0)
-    expect(gate.stats().global.shed).toBe(1)
-    expect(logs.some((m) => m.includes('shed by send gate'))).toBe(true)
+    expect(gate.stats().global.shed).toBe(0)
+    expect(logs.some((m) => m.includes('shed by send gate'))).toBe(false)
 
-    // Window closes; the gateway-style ARGUMENT-LESS finalize (the
-    // disconnect-flush / turn-end cleanup path) must re-deliver the shed
-    // snapshot — pre-F2 the content was silently lost here.
+    // Window closes → the held tail edit lands on its own. The gateway-style
+    // ARGUMENT-LESS finalize (disconnect-flush / turn-end cleanup) is then a
+    // no-op rather than a rescue.
     await clock.advance(31_000)
     await stream.finalize()
     expect(tailEdits()).toHaveLength(1)
     const [, , tailBody] = tailEdits()[0]
     expect(String(tailBody)).toContain('tail v2')
   })
+
+  /**
+   * #3716 removed the gate's cosmetic-EDIT shed, so no edit the stream makes
+   * can return `SEND_GATE_SHED` any more. The sentinel is still the contract
+   * for non-edit cosmetic sends, and the controller's F2/F3 shed-honesty
+   * handling is the guard if any edit path is ever re-tagged — so pin it
+   * directly against the retry seam instead of through the gate, where it
+   * would silently rot into an assertion about behaviour that cannot occur.
+   */
+  it('F2+F3 shed-honesty is still wired: a SHED tail is not recorded as delivered and re-flushes', async () => {
+    const base = ('a_b_c_d_e ').repeat(3000)
+    const b1 = `${base}tail v1`
+    const b2 = `${base}tail v2 — the completed answer`
+    const pieceCount = renderOutboundChunks(b1).length
+    expect(pieceCount).toBeGreaterThan(1)
+
+    // Shed exactly one message id, chosen after the first flush assigns ids.
+    let shedId: number | null = null
+    const retry: RetryPolicy = async (fn, opts) => {
+      if (shedId != null && opts?.messageId === shedId) {
+        return SEND_GATE_SHED as never
+      }
+      return await fn()
+    }
+
+    const logs: string[] = []
+    const stream = createStreamController({
+      bot, chatId: '1', throttleMs: 250, retry, log: (m) => logs.push(m),
+    })
+    void stream.update(b1)
+    await flush()
+    const anchorId = stream.getMessageId() as number
+    shedId = anchorId + pieceCount - 1
+
+    const tailEdits = () =>
+      bot.api.editMessageText.mock.calls.filter(([, id]) => id === shedId)
+
+    void stream.update(b2)
+    await tick()
+    expect(tailEdits()).toHaveLength(0)
+    expect(logs.some((m) => m.includes('shed by send gate'))).toBe(true)
+
+    // The shed piece must NOT have been recorded as on screen: an
+    // argument-less finalize re-delivers the preserved snapshot.
+    shedId = null
+    await stream.finalize()
+    const landed = bot.api.editMessageText.mock.calls.filter(
+      ([, id]) => id === anchorId + pieceCount - 1,
+    )
+    expect(landed).toHaveLength(1)
+    const [, , tailBody] = landed[0]
+    expect(String(tailBody)).toContain('tail v2')
+  })
 })

package/telegram-plugin/tests/stream-render-golden.test.ts

@@ -39,6 +39,28 @@ import {
   TYPING_REFRESH_MS,
 } from '../typing-emitter.js'
 import type { CurrentTurn } 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'
 
@@ -251,7 +273,7 @@ function makeSendReplyDeps(dedup: OutboundDedupCache, sharedSupersede?: FlushedT
     assertSendable: () => {},
     statusKey: key,
     streamKey: key,
-    resolveReplyOwnerTurn: () => ({ turn: null, tier: 'none' as const }),
+    resolveReplyOwnerTurn: () => ownerRes(null, 'none'),
     getLastSubagentHandbackAt: () => null,
     findTurnByOriginId: () => null,
     findTurnByQuotedMessageId: () => null,
@@ -443,7 +465,7 @@ describe('F3 — flush record() → same-turn reworded reply collapse (end-to-en
     // The model's REAL reply lands late with a REWORDED version of the same
     // answer: no live turn, latest-ended tier, NO handback in flight (CASE A).
     const s = makeSendReplyDeps(new OutboundDedupCache(), supersede)
-    s.deps.resolveReplyOwnerTurn = () => ({ turn, tier: 'latest-ended' as const })
+    s.deps.resolveReplyOwnerTurn = () => ownerRes(turn, 'latest-ended')
     // (getLastSubagentHandbackAt returns null in the base deps → own answer.)
 
     const res = await sendReply(s.deps, req(REWORDED))
@@ -496,7 +518,7 @@ describe('F5 — take()-before-record() interleaving delivers exactly one messag
     ).toBe('no-record') // record genuinely not written yet
 
     const s = makeSendReplyDeps(new OutboundDedupCache(), supersede)
-    s.deps.resolveReplyOwnerTurn = () => ({ turn, tier: 'latest-ended' as const })
+    s.deps.resolveReplyOwnerTurn = () => ownerRes(turn, 'latest-ended')
     // The same answer landing again in the race window → latch backstop suppresses.
     const res = await sendReply(s.deps, req(ANSWER))
 

package/vendor/hindsight-memory/scripts/lib/config.py

@@ -29,21 +29,23 @@ DEFAULTS = {
     # formatting. Set to 0 (or any non-positive value) to disable the cap
     # and inject everything Hindsight returns.
     "recallMaxMemories": 12,
-    # Switchroom-local: minimum lexical (containment) overlap between the
-    # user's query terms and a memory's text terms. Memories below this
-    # threshold are dropped before formatting. 0.0 disables the gate
-    # (current behaviour: inject everything Hindsight returns up to the
-    # count cap). NOTE: Hindsight's HTTP recall API DOES return per-result
-    # relevance scores (`scores.final`, plus `.semantic`/`.keyword`/
-    # `.reranker`) — verified at runtime — and recall.py now reads and
-    # sorts the merged set by `scores.final`. This lexical gate is a
-    # separate quality filter layered on top — see #475. The metric is
-    # containment, `|Q n M| / |M|`, not Jaccard: dividing by the union made
-    # the score a function of prompt length rather than relevance — see
-    # #3541 and recall.py's design note. At the 0.10 fleet default this is
-    # close to a passthrough (a <=10-token memory clears it on one shared
-    # word); precision is the engine rerank's job, not this gate's.
-    "recallMinOverlap": 0.0,
+    # Switchroom-local: per-bank slot FLOORS inside `recallMaxMemories`. The
+    # merged multi-bank set is sorted globally by `scores.final` and then
+    # head-sliced, which is winner-take-all across banks: when both banks return
+    # more candidates than the cap, one bank's score distribution can fill every
+    # slot and the agent gets a dossier about its operator with none of its own
+    # working memory. These are FLOORS, not quotas: each side gets at most this
+    # many slots, only if it has that many results, and only up to HALF the cap
+    # between them — the other half is always awarded on pure global relevance,
+    # so composition still moves with the scores. 0 disables reservation for
+    # that side (the pure pre-fix head-slice). Env:
+    # HINDSIGHT_RECALL_OWN_BANK_MIN_SLOTS /
+    # HINDSIGHT_RECALL_ADDITIONAL_BANK_MIN_SLOTS. See recall.py's
+    # `_reserve_bank_slots` and `_reservable_slots`. Vendor default is 0/0
+    # (off); switchroom's scaffold opts in with 2 own / 1 additional against the
+    # cap of 6 its fleet actually deploys.
+    "recallOwnBankMinSlots": 0,
+    "recallAdditionalBankMinSlots": 0,
     "recallTypes": ["world", "experience"],
     # Switchroom-local: when True (default; Ken-approved ON) recall biases
     # toward synthesized `observation`-tier facts. Escape hatch: pin off via
@@ -91,6 +93,29 @@ DEFAULTS = {
     # by recallTranscriptTailBytes so the added per-turn read stays O(1).
     "recallContextTurns": 2,
     "recallMaxQueryChars": 800,
+    # Switchroom #3757 — BM25 term budget for the query put on the wire.
+    # `recallMaxQueryChars` bounds CHARACTERS; the server's keyword arm costs
+    # per DISTINCT TERM, because it OR-joins every token into one tsquery and
+    # Postgres native FTS ranks the entire matched set before the top-60
+    # heapsort. An 800-char composed query is ~96 distinct terms and matched
+    # 119,510 rows on the live `overlord` bank — 14.0s for the 3-arm UNION,
+    # and up to 94s under load, past the
+    # per-bank client timeout, so the agent got NOTHING on 96.8% of its
+    # own-bank recalls in the 7 days to 2026-07-27. 24 terms measures at
+    # 48,433 rows / 2.7s on the same bank while keeping the high-signal terms
+    # of the latest turn. Selection is recency-first (latest turn beats prior
+    # context), then by a selectivity proxy — see lib/content.shape_recall_query.
+    # 0 disables shaping entirely (rollback lever).
+    # Operator knob: `memory.recall.query_max_tokens` in switchroom.yaml.
+    "recallQueryMaxTokens": 24,
+    # Switchroom #3757 — extra terms to drop from the BM25 query on top of the
+    # built-in English stopword list. For BANK-SPECIFIC high-document-frequency
+    # words a generic stoplist cannot know about: on `overlord`, `switchroom`
+    # matches 27,090 of 135,443 rows (20%) and `agent` 26,496 (20%), purely
+    # because that is what the corpus is about. Empty by default — an operator
+    # sets it per-agent after reading `switchroom memory recall-log <agent>`.
+    # Operator knob: `memory.recall.query_stop_terms` in switchroom.yaml.
+    "recallQueryStopTerms": [],
     # Switchroom hindsight-leverage A2 (PR2) — latency bound for the multi-turn
     # composition. With recallContextTurns>1 now the default, EVERY recall reads
     # the transcript to slice the last N human turns. A long session's .jsonl can
@@ -204,6 +229,18 @@ DEFAULTS = {
     # can never push the hook past its ceiling. Slots still unfinished when the
     # deadline elapses are abandoned (daemon threads) and marked timed_out.
     "recallParallelDeadlineSeconds": 10,
+    # Switchroom #3757 — per-bank HTTP read timeout (seconds) for one recall
+    # request. Was a hardcoded `timeout=8` in recall.py, which made it BOTH the
+    # binding constraint on a slow bank AND un-tunable without hand-editing the
+    # installed plugin — and a hand-edit does not survive `switchroom apply`,
+    # which re-copies the plugin from `vendor/hindsight-memory` (that revert is
+    # exactly what put the 8s literal back on 2026-07-27). 12s matches the
+    # UserPromptSubmit hook ceiling in hooks.json; the shared
+    # `recallParallelDeadlineSeconds` (10s) is the tighter outer guard in the
+    # default configuration, so this is a per-request safety net rather than
+    # the primary bound. Non-positive values fall back to the default.
+    # Operator knob: `memory.recall.request_timeout_seconds` in switchroom.yaml.
+    "recallRequestTimeoutSeconds": 12,
     # Switchroom hindsight-leverage E1 / PR8 (#3369) — bounded transcript-grep
     # fallback. Boot reconciliation (reconcile_tail.py) closes the crash-loss
     # window at the NEXT SessionStart, but between an abrupt kill and that boot,
@@ -282,10 +319,11 @@ ENV_OVERRIDES = {
     # agents.<name>.memory.recall.max_memories (cascading through
     # defaults.memory.recall.max_memories) when present in switchroom.yaml.
     "HINDSIGHT_RECALL_MAX_MEMORIES": ("recallMaxMemories", int),
-    # Switchroom-local: lexical-overlap threshold (#475). Float in
-    # [0.0, 1.0]. Set by start.sh from agents.<name>.memory.recall.min_overlap
-    # (cascading through defaults). 0.0 = off (current behaviour).
-    "HINDSIGHT_RECALL_MIN_OVERLAP": ("recallMinOverlap", float),
+    # Switchroom-local: per-bank slot floors inside the count cap. Set by
+    # start.sh from agents.<name>.memory.recall.own_bank_min_slots /
+    # .additional_bank_min_slots (cascading through defaults). 0 = off.
+    "HINDSIGHT_RECALL_OWN_BANK_MIN_SLOTS": ("recallOwnBankMinSlots", int),
+    "HINDSIGHT_RECALL_ADDITIONAL_BANK_MIN_SLOTS": ("recallAdditionalBankMinSlots", int),
     # Switchroom-local: recall fact types (comma-separated). Set by start.sh
     # from agents.<name>.memory.recall.types only when the operator overrode
     # the switchroom default (world,experience,observation) — i.e. the
@@ -322,6 +360,10 @@ ENV_OVERRIDES = {
     "HINDSIGHT_RECALL_TRANSCRIPT_FALLBACK_MAX_CHARS": ("recallTranscriptFallbackMaxChars", int),
     "HINDSIGHT_RECALL_TRANSCRIPT_FALLBACK_DEADLINE_MS": ("recallTranscriptFallbackDeadlineMs", int),
     "HINDSIGHT_RECALL_MAX_QUERY_CHARS": ("recallMaxQueryChars", int),
+    # Switchroom #3757 — BM25 query shaping + per-request timeout.
+    "HINDSIGHT_RECALL_QUERY_MAX_TOKENS": ("recallQueryMaxTokens", int),
+    "HINDSIGHT_RECALL_QUERY_STOP_TERMS": ("recallQueryStopTerms", list),
+    "HINDSIGHT_RECALL_REQUEST_TIMEOUT_SECONDS": ("recallRequestTimeoutSeconds", int),
     "HINDSIGHT_RECALL_CONTEXT_TURNS": ("recallContextTurns", int),
     # Switchroom hindsight-leverage A2 — byte-tail bound for the multi-turn
     # transcript read (0 = read whole file / rollback lever).