switchroom 0.20.11 → 0.20.13

package/telegram-plugin/silent-end.ts

@@ -82,6 +82,26 @@ export interface SilentEndState {
    * throw", which delivers exactly as before. It never suppresses.
    */
   replyToolThrewThisTurn?: boolean
+  /**
+   * #4490 — did the turn that produced `pendingText` originate from a
+   * self-improvement review inbound (`source="self_improve_review"`)?
+   *
+   * Stamped by the Stop hook's single-writer election
+   * (`silent-end-interrupt-stop.mjs` → `buildNextState`) from the SAME
+   * enqueue-envelope `source` tag `writeOutboxRecord` reads for the outbox
+   * capture path; the gateway's own `writeSilentEndState` never sets it.
+   * Consumed by `deliverCapturedProse` (`gateway/outbound-send-path.ts`),
+   * which is the ELECTED path's deliverer — it never writes an outbox record,
+   * so the sweep's audience gate / self-improvement framing can never reach
+   * this message, and this is the only way that machine can learn the
+   * provenance. Restores the #4141-style symmetry #4485 left one-sided (card
+   * gate + title framing applied at the sweep only).
+   *
+   * Optional and only ever `true`: absent means "no positive evidence of a
+   * review-origin turn", which delivers exactly as before. It never widens
+   * suppression on a normal user turn.
+   */
+  reviewOriginated?: boolean
 }
 
 export interface SilentEndDeps {
@@ -346,6 +366,15 @@ export interface CapturedProseDecision {
    * `true` only on positive evidence; never affects `deliver`.
    */
   replyToolThrewThisTurn?: boolean
+  /**
+   * #4490 — the persisted record says this turn originated from a
+   * self-improvement review inbound. Surfaced (not acted on) so
+   * `deliverCapturedProse` can apply the SAME card-gate / title-framing rules
+   * the outbox sweep applies. `true` only on positive evidence; never affects
+   * `deliver` here — the audience decision is made downstream, exactly as
+   * `replyToolThrewThisTurn`'s banner decision is.
+   */
+  reviewOriginated?: boolean
   /** Machine-readable reason (for logs / tests). */
   reason:
     | 'captured-prose'
@@ -426,17 +455,31 @@ export function decideCapturedProseDelivery(
     // AFTER every `deliver:false` gate above — the banner is a labelling
     // concern, and must never become an input to whether we deliver at all.
     ...(state.replyToolThrewThisTurn === true ? { replyToolThrewThisTurn: true } : {}),
+    // #4490: same discipline for the review-origin signal — placed after every
+    // `deliver:false` gate so it can never become an input to whether the
+    // (structurally different) "should we deliver at all" decision above
+    // fires. The caller decides suppression/framing from this raw flag.
+    ...(state.reviewOriginated === true ? { reviewOriginated: true } : {}),
   }
 }
 
 /**
  * Outcome of a captured-prose send attempt (Option A transcript-prose bridge).
- *   - `sent`         — the answer was delivered fresh this call.
- *   - `skipped-dedup`— the exact answer already went out (dedup hit); nothing
- *                      new was sent, but the answer IS with the user.
- *   - `failed`       — the send threw; the answer did NOT reach the user.
+ *   - `sent`               — the answer was delivered fresh this call.
+ *   - `skipped-dedup`      — the exact answer already went out (dedup hit);
+ *                            nothing new was sent, but the answer IS with the
+ *                            user.
+ *   - `failed`             — the send threw; the answer did NOT reach the
+ *                            user.
+ *   - `suppressed-internal`— #4490: the audience gate classified this prose
+ *                            as internal (a non-card self-improvement review
+ *                            turn) and it was never sent. Falls through the
+ *                            SAME close-obligation + clear-state bookkeeping
+ *                            as `sent` / `skipped-dedup` below — no operator
+ *                            is waiting on a message that was never meant to
+ *                            reach them, so there is nothing to recover.
  */
-export type CapturedProseSendOutcome = 'sent' | 'skipped-dedup' | 'failed'
+export type CapturedProseSendOutcome = 'sent' | 'skipped-dedup' | 'failed' | 'suppressed-internal'
 
 /**
  * The bookkeeping effects the gateway applies after a captured-prose send

package/telegram-plugin/status-pin.ts

@@ -210,12 +210,9 @@ export function isUnpinTerminalError(err: unknown): boolean {
  * Deliberately IN-MEMORY / per-boot only: pin rights may be granted later, and
  * Telegram surfaces the new permission to the bot only on a fresh chat-member
  * fetch — a gateway restart. Clearing the cache on restart is therefore the
- * correct re-enable trigger. An explicit `pin_message` tool success in a chat
- * also clears its entry (rights were granted mid-session).
+ * correct re-enable trigger.
  *
- * Scope: the AUTO status-pin path only. The explicit `pin_message` MCP tool
- * never consults this cache — it always attempts and surfaces the error to the
- * agent as a normal tool error.
+ * Scope: the AUTO status-pin path only (`pin_status_while_working`).
  */
 export class PinRightsCache {
   private readonly blocked = new Set<string>()

package/telegram-plugin/tests/backstop-exactly-once.test.ts

@@ -121,9 +121,9 @@ describe('selectBackstopDelivery — deterministic backstop coalescer (#3513 fol
 // ── isEphemeralTool — MF4 exact set ─────────────────────────────────────────
 
 describe('isEphemeralTool — the exact ephemeral surface set (MF4)', () => {
-  it('recognises exactly {react, send_typing, pin_message, delete_message, edit_message}, MCP-prefixed or bare', () => {
+  it('recognises exactly {react, send_typing, delete_message, edit_message}, MCP-prefixed or bare', () => {
     expect([...EPHEMERAL_TOOLS].sort()).toEqual(
-      ['delete_message', 'edit_message', 'pin_message', 'react', 'send_typing'].sort(),
+      ['delete_message', 'edit_message', 'react', 'send_typing'].sort(),
     )
     for (const t of EPHEMERAL_TOOLS) {
       expect(isEphemeralTool(t)).toBe(true)
@@ -132,6 +132,12 @@ describe('isEphemeralTool — the exact ephemeral surface set (MF4)', () => {
     }
   })
 
+  it('pin_message is NOT ephemeral — the pin_message MCP tool was retired (#4452)', () => {
+    expect(EPHEMERAL_TOOLS.has('pin_message')).toBe(false)
+    expect(isEphemeralTool('pin_message')).toBe(false)
+    expect(isEphemeralTool('mcp__switchroom-telegram__pin_message')).toBe(false)
+  })
+
   it('progress_update is NOT ephemeral (MF4 — dropped from the set)', () => {
     expect(isEphemeralTool('progress_update')).toBe(false)
     expect(isEphemeralTool('mcp__switchroom-telegram__progress_update')).toBe(false)

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

@@ -1,14 +1,4 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest'
-
-// The dispatcher's resume closure reaches for the durable outbound-text oracle
-// (history.hasOutboundWithText) to reconcile crash-idempotency. Mock it so these
-// stay pure vitest unit tests (no bun:sqlite / real DB) and we can control the
-// "did this chunk's text land durably?" answer per scenario.
-let mockOracle: (chatId: string, text: string, threadId: number | null, since: number) => boolean = () => false
-vi.mock('../history.js', () => ({
-  hasOutboundWithText: (chatId: string, text: string, threadId: number | null, since: number) =>
-    mockOracle(chatId, text, threadId, since),
-}))
+import { describe, expect, it, beforeEach } from 'vitest'
 
 import {
   BackstopDeliveryLedger,
@@ -36,7 +26,24 @@ import {
  *   (c) a fully-landed answer's represent sends NOTHING.
  * A test that would still pass if the resume re-sent a confirmed chunk is not a
  * test — every scenario asserts the exact `sendChunk` index set.
+ *
+ * The dispatcher's resume closure reaches for the durable outbound-text oracle
+ * (history.hasOutboundWithText) to reconcile crash-idempotency. `mockOracle`
+ * below is injected per-scenario via `createCapturedResumeDispatcher`'s
+ * `hasOutboundWithText` port (see `gateway/captured-answer-resume.ts`) — NOT
+ * via `vi.mock('../history.js', ...)`. That used to module-mock `history.js`,
+ * which looks file-scoped under vitest but under bun's vitest-compat layer
+ * `vi.mock` maps onto the process-global `mock.module`: `bun test` runs the
+ * whole `telegram-plugin/` surface in one process
+ * (`telegram-plugin/scripts/bun-test-ci.sh`), so the mock retroactively
+ * rebound `hasOutboundWithText` for every OTHER file in the same sweep —
+ * including `tests/history.test.ts`'s calls to the REAL implementation. That
+ * was the actual root cause of #4488/#4491: a row `history.test.ts` had
+ * genuinely just written to its own real bun:sqlite DB was reported "not
+ * found" because its `hasOutboundWithText` import had been silently rebound
+ * to this file's `() => false` default. See check-bun-module-mock-scope.mjs.
  */
+let mockOracle: (chatId: string, text: string, threadId: number | null, since: number) => boolean = () => false
 
 beforeEach(() => {
   mockOracle = () => false
@@ -192,6 +199,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
     oblLedger.noteCapturedDelivery('#t1', snapshot)
 
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: makeResumeDeliverAnswer(resumeLedger, sentIdx),
       obligationLedger: oblLedger,
       backstopDeliveryLedger: resumeLedger,
@@ -228,6 +236,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
     mockOracle = (_c, txt) => txt === 'c0'
 
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: makeResumeDeliverAnswer(resumeLedger, sentIdx),
       obligationLedger: oblLedger,
       backstopDeliveryLedger: resumeLedger,
@@ -258,6 +267,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
     oblLedger.noteCapturedDelivery('#t1', snapshot)
 
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: makeResumeDeliverAnswer(resumeLedger, sentIdx),
       obligationLedger: oblLedger,
       backstopDeliveryLedger: resumeLedger,
@@ -302,6 +312,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
 
     const lines: string[] = []
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: async (a) => {
         a.resume.hydrate(resumeLedger, a.turnId)
         const res = await runBackstopDelivery(
@@ -351,6 +362,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
 
     let probes = 0
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: async (a) => {
         a.resume.hydrate(resumeLedger, a.turnId)
         const res = await runBackstopDelivery(
@@ -388,6 +400,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
 
     // A resume whose tail send keeps throwing ⇒ not delivered ⇒ obligation stays OPEN.
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: async (a) => {
         a.resume.hydrate(resumeLedger, a.turnId)
         const res = await runBackstopDelivery(
@@ -423,6 +436,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
     oblLedger.noteCapturedDelivery('#t1', snapshot)
 
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: async (a) => {
         deliverCalls++
         a.resume.hydrate(resumeLedger, a.turnId)
@@ -448,6 +462,7 @@ describe('#3282 createCapturedResumeDispatcher — the represent RESUME outcome'
   it('no captured snapshot ⇒ dispatch is a no-op (caller falls through to fresh generation)', async () => {
     let delivered = false
     const dispatcher = createCapturedResumeDispatcher({
+      hasOutboundWithText: mockOracle,
       deliverAnswer: async () => { delivered = true; return { delivered: true, sentIds: [] } },
       obligationLedger: new ObligationLedger(2),
       backstopDeliveryLedger: new BackstopDeliveryLedger(),

package/telegram-plugin/tests/framework-fallback-duration-guard.test.ts

@@ -0,0 +1,125 @@
+/**
+ * M0 metric-corruption regression — the framework_fallback `turn_ended` emitter
+ * must never write an absolute Unix-epoch value as `duration_ms`.
+ *
+ * ROOT CAUSE (fixed by this change): the 300 s framework-fallback unwedge in
+ * `liveness-wiring.ts` read the turn's start from `activeTurnStartedAt.get(key)`
+ * and, guarded only by a `!= null` presence check, computed
+ * `Date.now() - turnStartedAt` inline. When the map held `0` (a bogus / not-yet
+ * stamped start — reproduced here exactly as the parked-turn fixture does with
+ * `activeTurnStartedAt.set(KEY, 0)`), it emitted `duration_ms = Date.now() - 0`,
+ * i.e. the current epoch-ms — a ~56,000-year "duration". The analysed dataset
+ * carried 110 such rows (`duration_ms === ts`, `ended_via: "framework_fallback"`),
+ * making every latency aggregate unusable.
+ *
+ * The two `stream-render.ts` turn_ended paths already guarded with
+ * `startedAt > 0 ? … : 0`; this path had drifted. The fix routes all emitters
+ * through the shared `computeTurnDurationMs`, which returns 0 for a non-positive
+ * start.
+ *
+ * This test drives the REAL `onFrameworkFallback` (via `buildSilencePokeOptions`,
+ * same standard as the other liveness-wiring tests) with a 0 start and asserts on
+ * the ACTUAL emitted `turn_ended` row (captured through the real runtime-metrics
+ * JSONL sink, pinned to a temp file). It asserts the OUTCOME — the emitted
+ * `duration_ms` — not a code path.
+ *
+ * Pre-fix: `duration_ms` ≈ `Date.now()` (~1.78e12). Post-fix: `duration_ms === 0`.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, readFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { buildSilencePokeOptions } from '../gateway/liveness-wiring.js'
+import {
+  __setRuntimeMetricsPathForTests,
+} from '../runtime-metrics.js'
+import { makeLivenessFixture, makeTurn, statusKeyForTests } from './helpers/liveness-wiring-fixture.js'
+
+const CHAT = '-100999'
+
+function readTurnEndedRows(path: string): Array<Record<string, unknown>> {
+  if (!existsSync(path)) return []
+  return readFileSync(path, 'utf-8')
+    .split('\n')
+    .filter((l) => l.trim() !== '')
+    .map((l) => JSON.parse(l) as Record<string, unknown>)
+    .filter((r) => r.kind === 'turn_ended')
+}
+
+describe('framework_fallback turn_ended never emits an epoch value as duration_ms', () => {
+  let metricsPath: string
+
+  beforeEach(() => {
+    const dir = mkdtempSync(join(tmpdir(), 'fallback-duration-'))
+    metricsPath = join(dir, 'runtime-metrics.jsonl')
+    __setRuntimeMetricsPathForTests(metricsPath)
+  })
+
+  afterEach(() => {
+    __setRuntimeMetricsPathForTests(null)
+  })
+
+  it('emits duration_ms === 0 for a zero/bogus start instead of Date.now()', async () => {
+    const KEY = statusKeyForTests(CHAT, null)
+    const fx = makeLivenessFixture()
+
+    // The wedged turn's start is 0 — the exact corruption trigger. Before the
+    // fix this made the fallback emit `Date.now() - 0`.
+    fx.activeTurnStartedAt.set(KEY, 0)
+    fx.setCurrentTurn(
+      makeTurn({ sessionChatId: CHAT, sessionThreadId: undefined, turnId: `${KEY}#42` }),
+    )
+
+    const opts = buildSilencePokeOptions(fx.deps)
+    await opts.onFrameworkFallback({
+      key: KEY,
+      chatId: CHAT,
+      threadId: null,
+      fallbackKind: 'working',
+      silenceMs: 302_000,
+      inFlightTools: [],
+    })
+
+    const rows = readTurnEndedRows(metricsPath)
+    const fallbackRow = rows.find((r) => r.ended_via === 'framework_fallback')
+    expect(fallbackRow, 'framework_fallback turn_ended row was emitted').toBeDefined()
+
+    const duration = fallbackRow!.duration_ms as number
+    // The falsifying assertion: pre-fix this is ~Date.now() (an epoch-ms value,
+    // ~1.78e12), and in particular equals the row's own `ts`. Post-fix it is 0.
+    expect(duration).toBe(0)
+    // Belt-and-braces: a duration can never be an absolute epoch stamp, and can
+    // never equal the emission timestamp.
+    expect(duration).not.toBe(fallbackRow!.ts as number)
+    expect(duration).toBeLessThan(365 * 24 * 60 * 60 * 1000) // < 1 year, sane bound
+  })
+
+  it('emits a real elapsed duration for a valid positive start', async () => {
+    const KEY = statusKeyForTests(CHAT, null)
+    const fx = makeLivenessFixture()
+
+    const startedAt = Date.now() - 302_000 // ~5 min ago
+    fx.activeTurnStartedAt.set(KEY, startedAt)
+    fx.setCurrentTurn(
+      makeTurn({ sessionChatId: CHAT, sessionThreadId: undefined, turnId: `${KEY}#43` }),
+    )
+
+    const opts = buildSilencePokeOptions(fx.deps)
+    await opts.onFrameworkFallback({
+      key: KEY,
+      chatId: CHAT,
+      threadId: null,
+      fallbackKind: 'working',
+      silenceMs: 302_000,
+      inFlightTools: [],
+    })
+
+    const fallbackRow = readTurnEndedRows(metricsPath).find(
+      (r) => r.ended_via === 'framework_fallback',
+    )
+    const duration = fallbackRow!.duration_ms as number
+    // Around 302 s, with generous slack for test-runtime jitter.
+    expect(duration).toBeGreaterThanOrEqual(302_000)
+    expect(duration).toBeLessThan(360_000)
+  })
+})

package/telegram-plugin/tests/hindsight-bank-preload.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  HINDSIGHT_BANK_GUARD_MARKER,
+  hindsightBankGuardTrips,
+  resetHindsightBankGuardTrips,
+} from '../../tests/vitest-setup/hindsight-bank-guard-core.mjs'
+
+/**
+ * Runtime alarm for the BUN half of the Hindsight bank hermeticity guard.
+ *
+ * vitest loads `tests/vitest-setup/hindsight-bank-guard.mjs` via
+ * `test.setupFiles`; `bun test` loads the same file via `[test] preload` in
+ * bunfig.toml (repo root) and telegram-plugin/bunfig.toml (CI's bun-test-run
+ * has `working-directory: telegram-plugin`, and bun reads the bunfig in its CWD
+ * only). Without the bun half, every bun-run test file can still reach the
+ * FLEET's Hindsight — which auto-creates a bank on miss, so one stray request
+ * mints a bank in the live instance. That is how eleven throwaway banks
+ * appeared there on 2026-07-30, one of them named `clerk`, colliding with a
+ * live agent and erasing the annotation that documented where that agent's
+ * memory actually lives.
+ *
+ * `npm run lint:hindsight-bank-hermeticity` pins the WIRING statically; this
+ * pins the EFFECT, so a bunfig that is present but no longer loading the guard
+ * (wrong relative path, bun config-discovery change) fails a test rather than
+ * silently un-protecting the runner.
+ *
+ * Imports the CORE, never the setup file — importing the setup file would
+ * INSTALL the guard and let this alarm heal itself. The replay target is
+ * 192.0.2.1 (TEST-NET-1, RFC 5737): unroutable, so an unwired run fails on the
+ * assertion rather than doing the thing the guard exists to prevent.
+ */
+describe('bun test runs with the fleet Hindsight blocked', () => {
+  it('rejects a bank request to a fleet Hindsight origin', async () => {
+    resetHindsightBankGuardTrips()
+    let err: unknown
+    try {
+      await fetch('http://192.0.2.1:18888/v1/default/banks/clerk/config', {
+        signal: AbortSignal.timeout(250),
+      })
+    } catch (e) {
+      err = e
+    }
+    expect(
+      String((err as Error | undefined)?.message ?? ''),
+      'bunfig.toml `[test] preload` did not install the Hindsight bank guard',
+    ).toContain(HINDSIGHT_BANK_GUARD_MARKER)
+    expect(hindsightBankGuardTrips()).toBe(1)
+  })
+})