switchroom 0.10.0 → 0.11.0

package/telegram-plugin/tests/silence-poke.test.ts

@@ -4,6 +4,9 @@ import {
   noteOutbound,
   noteSubagentDispatch,
   noteThinking,
+  noteToolStart,
+  noteToolEnd,
+  noteToolLabel,
   consumeArmedPoke,
   endTurn,
   silencePokeEnabled,
@@ -309,6 +312,240 @@ describe('silence-poke — abnormal turn-end invariants (CC-5 follow-up)', () =>
     ).toHaveLength(1) // unchanged: only the original soft
     expect(fx.fallbacks).toHaveLength(0)
   })
+
+  // #1289: the flush-backstop turn-end branch in the gateway (the path
+  // taken when the agent emits assistant text but never calls the reply
+  // tool) was retrofitted in #1067 to null `currentTurn` early but never
+  // had `silencePoke.endTurn` added — leaving state2 populated so the
+  // 300s framework fallback fired after the gateway already flushed the
+  // captured prose and considered the turn over. Pin the contract at
+  // the silence-poke level: a turn that records an outbound (the
+  // flushed message) and then calls endTurn must not later fire a
+  // fallback even if 300s elapses from the original turn start.
+  it('#1289: flush-backstop turn-end (outbound + endTurn) suppresses the 300s fallback', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    // Some time passes while the agent generates prose without calling
+    // the reply tool. No soft/firm armed yet.
+    __tickForTests(60_000)
+    // Gateway turn-flush fires: captured text is sent as an outbound,
+    // then the flush branch nulls currentTurn AND (post-fix) calls
+    // signalTracker.clear + silencePoke.endTurn.
+    noteOutbound('k', 60_000)
+    endTurn('k')
+    // 300s elapses from the original turn start. Pre-fix: the framework
+    // fallback fired here. Post-fix: the state is drained, no fallback.
+    __tickForTests(240_000)
+    expect(fx.fallbacks).toHaveLength(0)
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_fallback_sent'),
+    ).toHaveLength(0)
+  })
+})
+
+// #1292 — drive a deterministic, tool-aware fallback message from the
+// gateway's `tool_use` / `tool_result` event stream. The progress card
+// was retired in #1122 PR3 in favour of the conversational shape; the
+// remaining honesty gap was that the 300s framework fallback said
+// "still working… no update in 5 min" on turns where the agent was
+// clearly grinding through tool calls. These tests pin the behaviour:
+// the silence clock is NOT reset by tool churn (header invariant
+// preserved), but the fallback message body becomes tool-aware so the
+// user sees the actual observable.
+describe('silence-poke — #1292 tool-aware framework fallback', () => {
+  it('fallback context exposes in-flight tool snapshot with duration', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    noteToolStart('k', 'T1', 'Grep', 'foo', 30_000)
+    __tickForTests(75_000)
+    __tickForTests(180_000)
+    __tickForTests(305_000)
+    expect(fx.fallbacks).toHaveLength(1)
+    const ctx = fx.fallbacks[0]!
+    expect(ctx.inFlightTools).toHaveLength(1)
+    expect(ctx.inFlightTools[0]!.name).toBe('Grep')
+    expect(ctx.inFlightTools[0]!.label).toBe('foo')
+    expect(ctx.inFlightTools[0]!.durationMs).toBe(305_000 - 30_000)
+  })
+
+  it('formatFrameworkFallbackText names the longest-running tool with duration', () => {
+    const text = formatFrameworkFallbackText('working', 305_000, [
+      { name: 'Grep', label: '"foo"', durationMs: 275_000 },
+    ])
+    expect(text).toBe(
+      'running Grep "foo" for 5m (no update from agent in 5 min)',
+    )
+  })
+
+  it('multiple in-flight tools render as "+ N more"', () => {
+    const text = formatFrameworkFallbackText('working', 305_000, [
+      { name: 'Grep', label: '"foo"', durationMs: 275_000 },
+      { name: 'Read', label: 'config.ts', durationMs: 120_000 },
+      { name: 'Bash', label: null, durationMs: 60_000 },
+    ])
+    expect(text).toBe(
+      'running Grep "foo" + 2 more for 5m (no update from agent in 5 min)',
+    )
+  })
+
+  it('tool with no label renders the bare name', () => {
+    const text = formatFrameworkFallbackText('working', 305_000, [
+      { name: 'Bash', label: null, durationMs: 305_000 },
+    ])
+    expect(text).toBe(
+      'running Bash for 5m (no update from agent in 5 min)',
+    )
+  })
+
+  it('empty inFlightTools falls back to the base "still working" wording', () => {
+    expect(
+      formatFrameworkFallbackText('working', 305_000, []),
+    ).toBe('still working… (no update from agent in 5 min)')
+    expect(
+      formatFrameworkFallbackText('thinking', 305_000, []),
+    ).toBe('still thinking… (no update from agent in 5 min)')
+    // No third arg → same as empty array.
+    expect(
+      formatFrameworkFallbackText('working', 305_000),
+    ).toBe('still working… (no update from agent in 5 min)')
+  })
+
+  it('tool-aware wording wins over "thinking" — the actual observable beats the inferred kind', () => {
+    const text = formatFrameworkFallbackText('thinking', 305_000, [
+      { name: 'Grep', label: '"foo"', durationMs: 305_000 },
+    ])
+    expect(text.startsWith('running Grep')).toBe(true)
+    expect(text).not.toContain('still thinking')
+  })
+
+  it('tool completed before the fallback → empty snapshot → base wording', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    noteToolStart('k', 'T1', 'Grep', 'foo', 30_000)
+    noteToolEnd('k', 'T1', 200_000)
+    __tickForTests(75_000)
+    __tickForTests(180_000)
+    __tickForTests(305_000)
+    expect(fx.fallbacks).toHaveLength(1)
+    expect(fx.fallbacks[0]!.inFlightTools).toHaveLength(0)
+  })
+
+  it('late noteToolLabel updates the in-flight entry in place', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    noteToolStart('k', 'T1', 'Grep', null, 30_000)
+    noteToolLabel('k', 'T1', '"refined-from-sidecar"')
+    __tickForTests(75_000)
+    __tickForTests(180_000)
+    __tickForTests(305_000)
+    expect(fx.fallbacks[0]!.inFlightTools[0]!.label).toBe('"refined-from-sidecar"')
+  })
+
+  it('endTurn drains inFlightTools', () => {
+    setupDeps()
+    startTurn('k', 0)
+    noteToolStart('k', 'T1', 'Grep', 'foo', 30_000)
+    expect(__getStateForTests('k')!.inFlightTools.size).toBe(1)
+    endTurn('k')
+    // A fresh turn under the same key has an empty map.
+    startTurn('k', 1_000_000)
+    expect(__getStateForTests('k')!.inFlightTools.size).toBe(0)
+  })
+
+  it('parallel tools sort by startedAt ascending — longest-running rendered first', () => {
+    const fx = setupDeps()
+    startTurn('k', 0)
+    // Order intentionally NOT chronological to verify sort.
+    noteToolStart('k', 'T-late', 'Read', 'recent.ts', 250_000)
+    noteToolStart('k', 'T-early', 'Grep', '"oldest"', 20_000)
+    noteToolStart('k', 'T-mid', 'Bash', null, 100_000)
+    __tickForTests(75_000)
+    __tickForTests(180_000)
+    __tickForTests(305_000)
+    const snap = fx.fallbacks[0]!.inFlightTools
+    expect(snap.map(t => t.name)).toEqual(['Grep', 'Bash', 'Read'])
+  })
+
+  it('tool churn does NOT reset the silence clock (header invariant preserved)', () => {
+    // The whole point of #1292 (b) over (a) is that we enrich the
+    // fallback TEXT, never the timing. Tool activity must not delay
+    // or suppress the soft/firm/fallback escalation ladder.
+    const fx = setupDeps()
+    startTurn('k', 0)
+    // A constant stream of tool churn through the entire 5min window —
+    // each tool ends quickly so inFlightTools is empty by fallback.
+    for (let t = 5_000; t <= 295_000; t += 10_000) {
+      noteToolStart('k', `T-${t}`, 'Grep', 'foo', t)
+      noteToolEnd('k', `T-${t}`, t + 500)
+    }
+    __tickForTests(75_000) // soft
+    __tickForTests(180_000) // firm
+    __tickForTests(305_000) // fallback
+    expect(
+      fx.emitted.filter(e => e.kind === 'silence_poke_fired'),
+    ).toHaveLength(2)
+    expect(fx.fallbacks).toHaveLength(1)
+  })
+
+  it('Task tool sets subagentDispatchActive AND populates inFlightTools', () => {
+    // Two flags are independent: the soft-threshold extension still
+    // works for sub-agent waits (existing behaviour), AND the fallback
+    // message names the Task tool as the actual observable.
+    const fx = setupDeps()
+    startTurn('k', 0)
+    // Gateway calls both for a Task tool_use (mirrors the wiring at
+    // gateway.ts onSessionEvent).
+    noteSubagentDispatch('k')
+    noteToolStart('k', 'T1', 'Task', 'spinning up @researcher', 10_000)
+    // Soft threshold extends to 300s under subagent — so no soft poke
+    // fires at 75s and no firm fires at 180s (firm requires pokesFired===1,
+    // i.e. soft must fire first). Once we cross the 300s subagent-soft,
+    // soft fires; each tick fires one level via the `continue` in tick(),
+    // so we need three ticks to walk soft → firm → fallback.
+    __tickForTests(75_000)   // suppressed by subagent
+    __tickForTests(180_000)  // still suppressed
+    __tickForTests(305_000)  // soft fires (subagent soft = 300s)
+    __tickForTests(305_001)  // firm fires
+    __tickForTests(305_002)  // fallback fires
+    expect(fx.fallbacks).toHaveLength(1)
+    const snap = fx.fallbacks[0]!.inFlightTools
+    expect(snap[0]!.name).toBe('Task')
+    expect(snap[0]!.label).toBe('spinning up @researcher')
+  })
+
+  it('noteToolStart on an unknown key is a no-op (no crash, no state)', () => {
+    setupDeps()
+    // No startTurn first — silence-poke ignores the call.
+    noteToolStart('k-never-started', 'T1', 'Grep', 'foo', 30_000)
+    expect(__getStateForTests('k-never-started')).toBeUndefined()
+  })
+
+  it('noteToolEnd on an unknown id is a no-op', () => {
+    setupDeps()
+    startTurn('k', 0)
+    noteToolEnd('k', 'never-started', 100_000)
+    expect(__getStateForTests('k')!.inFlightTools.size).toBe(0)
+  })
+
+  it('formatFrameworkFallbackText sub-minute durations render as "Ns"', () => {
+    const text = formatFrameworkFallbackText('working', 305_000, [
+      { name: 'Grep', label: 'foo', durationMs: 12_000 },
+    ])
+    expect(text).toBe(
+      'running Grep foo for 12s (no update from agent in 5 min)',
+    )
+  })
+
+  it('formatFrameworkFallbackText truncates very long labels', () => {
+    const longLabel = '"' + 'x'.repeat(120) + '"'
+    const text = formatFrameworkFallbackText('working', 305_000, [
+      { name: 'Grep', label: longLabel, durationMs: 305_000 },
+    ])
+    // 60-char cap (with trailing ellipsis) — verify clipping without
+    // pinning exact bytes.
+    expect(text.length).toBeLessThan(120)
+    expect(text).toContain('…')
+  })
 })
 
 describe('silence-poke — consumeArmedPoke draining', () => {

package/telegram-plugin/tests/turn-flush-safety.test.ts

@@ -137,6 +137,118 @@ describe('decideTurnFlush', () => {
       }),
     ).toEqual({ kind: 'skip', reason: 'reply-called' })
   })
+
+  // #1291 — when the model emits a soft-commit reply ("on it, back in a
+  // few") and then composes the real substantive answer in terminal text
+  // only, the pre-#1291 behaviour skipped flush entirely because
+  // replyCalled was true. The fix: track capturedTextLenAtLastReply and
+  // flush the post-reply tail when it meets the substantive threshold.
+  describe('#1291 — post-reply tail flush', () => {
+    it('flushes the post-reply tail when it meets the substantive threshold', () => {
+      const decision = decideTurnFlush({
+        chatId: '700',
+        replyCalled: true,
+        // Index 0 = the captured text BEFORE the reply tool was called
+        // (some thinking-as-text). Indices 1..2 are post-reply.
+        capturedText: [
+          'thinking out loud before the reply',
+          'Now here is the actual substantive answer the model composed ',
+          'in terminal text only after the interim reply call.',
+        ],
+        capturedTextLenAtLastReply: 1,
+      })
+      expect(decision).toEqual({
+        kind: 'flush',
+        text:
+          'Now here is the actual substantive answer the model composed ' +
+          '\nin terminal text only after the interim reply call.',
+      })
+    })
+
+    it('skips with reply-called-no-new-text when post-reply tail is below threshold', () => {
+      const decision = decideTurnFlush({
+        chatId: '701',
+        replyCalled: true,
+        capturedText: ['the pre-reply scratch', 'ok.'], // tail = "ok." (3 chars)
+        capturedTextLenAtLastReply: 1,
+      })
+      expect(decision).toEqual({
+        kind: 'skip',
+        reason: 'reply-called-no-new-text',
+      })
+    })
+
+    it('skips with reply-called when there is no post-reply text at all', () => {
+      const decision = decideTurnFlush({
+        chatId: '702',
+        replyCalled: true,
+        capturedText: ['everything-was-before-the-reply'],
+        capturedTextLenAtLastReply: 1, // tail slice is empty
+      })
+      expect(decision).toEqual({ kind: 'skip', reason: 'reply-called' })
+    })
+
+    it('post-reply tail honors a silent marker (skip)', () => {
+      const decision = decideTurnFlush({
+        chatId: '703',
+        replyCalled: true,
+        capturedText: ['real answer pre-reply', 'NO_REPLY'],
+        capturedTextLenAtLastReply: 1,
+        replyCalledTailMinChars: 1, // force the marker check
+      })
+      expect(decision).toEqual({ kind: 'skip', reason: 'silent-marker' })
+    })
+
+    it('post-reply tail with null chatId still skips (no-inbound-chat)', () => {
+      const decision = decideTurnFlush({
+        chatId: null,
+        replyCalled: true,
+        capturedText: [
+          'pre',
+          'this tail would have been substantive enough to flush normally',
+        ],
+        capturedTextLenAtLastReply: 1,
+      })
+      expect(decision).toEqual({ kind: 'skip', reason: 'no-inbound-chat' })
+    })
+
+    it('preserves pre-#1291 behaviour when capturedTextLenAtLastReply is omitted', () => {
+      // Legacy caller doesn't track the marker — defaults to
+      // capturedText.length, so the tail slice is empty and we skip
+      // with reason 'reply-called' (the original behaviour).
+      const decision = decideTurnFlush({
+        chatId: '704',
+        replyCalled: true,
+        capturedText: ['some answer the model emitted'],
+      })
+      expect(decision).toEqual({ kind: 'skip', reason: 'reply-called' })
+    })
+
+    it('respects a custom replyCalledTailMinChars threshold', () => {
+      const decision = decideTurnFlush({
+        chatId: '705',
+        replyCalled: true,
+        capturedText: ['pre-reply', 'short but substantive in this test'],
+        capturedTextLenAtLastReply: 1,
+        replyCalledTailMinChars: 10,
+      })
+      expect(decision.kind).toBe('flush')
+    })
+
+    it('feature flag off still wins over post-reply tail flush', () => {
+      const decision = decideTurnFlush({
+        chatId: '706',
+        replyCalled: true,
+        capturedText: [
+          'pre',
+          'a long substantive post-reply tail that would otherwise flush',
+        ],
+        capturedTextLenAtLastReply: 1,
+        flushEnabled: false,
+      })
+      expect(decision).toEqual({ kind: 'skip', reason: 'flag-disabled' })
+    })
+  })
 })
 
 describe('isSilentFlushMarker', () => {

package/telegram-plugin/turn-flush-safety.ts

@@ -57,6 +57,7 @@ export type FlushDecision =
 export type FlushSkipReason =
   | 'flag-disabled'
   | 'reply-called'
+  | 'reply-called-no-new-text'
   | 'no-inbound-chat'
   | 'empty-text'
   | 'silent-marker'
@@ -71,10 +72,33 @@ export interface FlushDecisionInput {
   /** Raw text content blocks accumulated from assistant events across the
    * turn. Joined + trimmed internally. */
   capturedText: string[]
+  /** Snapshot of `capturedText.length` at the moment of the most recent
+   * reply / stream_reply tool call in this turn. Indices `[capturedText
+   * length-at-last-reply, capturedText.length)` are the post-reply tail
+   * — substantive content the model emitted AFTER the reply (e.g. soft
+   * commit "on it, back in a few" followed by the real answer in
+   * terminal text only, the #1291 repro). When the tail meets
+   * `replyCalledTailMinChars` we flush it; otherwise we skip.
+   *
+   * Defaults to `capturedText.length` (treat all captured text as
+   * pre-reply, preserve the pre-#1291 behaviour where any reply tool
+   * call suppressed flush entirely) so callers that don't track the
+   * marker keep the old contract. */
+  capturedTextLenAtLastReply?: number
+  /** Minimum trimmed-tail length to qualify a post-reply tail flush.
+   * Defaults to `REPLY_CALLED_TAIL_MIN_CHARS` (40). Below this we skip
+   * with `reply-called-no-new-text` — typical for trailing markdown
+   * artifacts or a one-word afterthought. */
+  replyCalledTailMinChars?: number
   /** Feature flag — defaults to true. Pass `false` to force skip everywhere. */
   flushEnabled?: boolean
 }
 
+/** Default minimum trimmed length for the post-reply tail to be flushed
+ * as a follow-up message. Below this we treat the tail as noise / artifact
+ * and skip silently. */
+export const REPLY_CALLED_TAIL_MIN_CHARS = 40
+
 /**
  * Pure decision: should the gateway deterministically send the model's
  * captured assistant text at turn_end? Returns `{kind: 'flush', text}` with
@@ -82,11 +106,41 @@ export interface FlushDecisionInput {
  *
  * Ordering of checks is deliberate: cheapest/strongest first so logs
  * attribute a skip to the most specific cause.
+ *
+ * #1291 — when `replyCalled` is true we no longer suppress unconditionally.
+ * The model may have emitted a soft-commit reply ("on it, back in a few")
+ * followed by the real substantive answer in terminal text only. Using
+ * `capturedTextLenAtLastReply` we isolate the post-reply tail and flush
+ * it if it's substantive enough; otherwise we skip with
+ * `reply-called-no-new-text` (logged) or `reply-called` (silent, no tail).
  */
 export function decideTurnFlush(input: FlushDecisionInput): FlushDecision {
   const flushEnabled = input.flushEnabled !== false
   if (!flushEnabled) return { kind: 'skip', reason: 'flag-disabled' }
-  if (input.replyCalled) return { kind: 'skip', reason: 'reply-called' }
+
+  if (input.replyCalled) {
+    const tailIdx = input.capturedTextLenAtLastReply ?? input.capturedText.length
+    const tail = input.capturedText.slice(tailIdx).join('\n').trim()
+    const minChars = input.replyCalledTailMinChars ?? REPLY_CALLED_TAIL_MIN_CHARS
+    if (tail.length === 0) {
+      // The reply tool was called and nothing of substance came after —
+      // the turn is fully served by the reply. Skip silently (the gateway
+      // WARN gate excludes this reason from logs).
+      return { kind: 'skip', reason: 'reply-called' }
+    }
+    if (tail.length < minChars) {
+      // Post-reply tail exists but is below the substantive-content
+      // threshold — typically trailing markdown artifacts or a one-word
+      // afterthought. Skip but with a distinct reason so this case IS
+      // logged (auditable for #1291 regressions, vs the silent
+      // 'reply-called' which is the expected steady state).
+      return { kind: 'skip', reason: 'reply-called-no-new-text' }
+    }
+    if (input.chatId == null) return { kind: 'skip', reason: 'no-inbound-chat' }
+    if (isSilentFlushMarker(tail)) return { kind: 'skip', reason: 'silent-marker' }
+    return { kind: 'flush', text: tail }
+  }
+
   if (input.chatId == null) return { kind: 'skip', reason: 'no-inbound-chat' }
   const joined = input.capturedText.join('\n').trim()
   if (joined.length === 0) return { kind: 'skip', reason: 'empty-text' }

package/telegram-plugin/uat/SETUP.md

@@ -297,18 +297,22 @@ as a long-lived secret.
 When all three are checked, the env block above + `bun run test:uat`
 is safe to run.
 
-## 8. CI gate — `:robot: UAT fuzz` Buildkite step
-
-Since the buildkite gate landed, the fuzz subset of scenarios
-(`fuzz-random-prompts-dm.test.ts`, `fuzz-extended-dm.test.ts`,
-`fuzz-human-style-dm.test.ts`) runs automatically on every PR that
-touches `telegram-plugin/`, `src/agents/`, or `telegram-plugin/uat/`.
-
-The step runs on a self-hosted Buildkite agent tagged
-`queue=uat-host` that lives on the same box as the `test-harness`
-agent. Secrets come from the Buildkite cluster secret store, not
-from local vault. See `.buildkite/README.md` § "UAT fuzz step" for
-agent setup + secret rotation.
+## 8. CI gate — `ci-uat` GitHub Actions workflow
+
+Since the GHA gate landed (replacing the original Buildkite gate),
+the fuzz subset of scenarios (`fuzz-random-prompts-dm.test.ts`,
+`fuzz-extended-dm.test.ts`, `fuzz-human-style-dm.test.ts`) runs
+automatically on every PR that touches `telegram-plugin/`,
+`src/agents/`, or `telegram-plugin/uat/`.
+
+The workflow (`.github/workflows/ci-uat.yml`) runs on a self-hosted
+GHA runner labelled `[self-hosted, uat-host]` that lives on the
+same box as the `test-harness` agent. Gating: the `UAT_GATE_ENABLED`
+repository variable must be `true` AND the four Telegram secrets
+(`TELEGRAM_API_ID`, `TELEGRAM_API_HASH`, `TELEGRAM_UAT_DRIVER_SESSION`,
+`TELEGRAM_TEST_BOT_USERNAME`) must be present as GitHub Actions
+secrets. The workflow's header docstring covers agent setup + secret
+rotation.
 
 **Scope (CI):**
 

package/telegram-plugin/auto-fallback-dispatcher.ts

@@ -1,68 +0,0 @@
-/**
- * Side-effecting half of the auto-fallback flow (#11 / #420 / #421).
- *
- * `auto-fallback.ts` returns a pure `FallbackPlan`. This module
- * dispatches the user-visible Telegram notification for that plan
- * to the owner chat. Extracted from gateway.ts so the dispatch is
- * testable end-to-end via `tests/fake-bot-api.ts` instead of through
- * the full gateway boot path.
- *
- * Error-handling contract: API failures are reported via `onError`
- * but never throw. The gateway logs to stderr; tests assert via the
- * callback. A failed notification does not block the agent restart
- * downstream — the user being unaware of the swap is a worse failure
- * than burning a slot, but neither failure should kill the gateway.
- */
-
-import type { FallbackPlan } from './auto-fallback.js';
-
-/** Minimal subset of grammy's `bot.api` we depend on. */
-export interface FallbackBotApi {
-  sendMessage(
-    chat_id: string | number,
-    text: string,
-    opts?: Record<string, unknown>,
-  ): Promise<{ message_id: number }>;
-}
-
-export interface FallbackBot {
-  api: FallbackBotApi;
-}
-
-export interface DispatchFallbackArgs {
-  bot: FallbackBot;
-  /** Owner chat (`access.allowFrom[0]`). When null/empty, dispatch
-   *  becomes a noop — no chat to notify. */
-  ownerChatId: string | null | undefined;
-  plan: FallbackPlan;
-  onError?: (err: unknown) => void;
-}
-
-export type DispatchOutcome =
-  | { kind: 'sent'; messageId: number }
-  | { kind: 'no-chat' }
-  | { kind: 'error' };
-
-/**
- * Send the plan's `notificationHtml` to the owner chat. Idempotent
- * within a plan (caller decides when to invoke). Always resolves.
- */
-export async function dispatchFallbackNotification(
-  args: DispatchFallbackArgs,
-): Promise<DispatchOutcome> {
-  if (!args.ownerChatId) return { kind: 'no-chat' };
-  try {
-    const sent = await args.bot.api.sendMessage(
-      args.ownerChatId,
-      args.plan.notificationHtml,
-      {
-        parse_mode: 'HTML',
-        link_preview_options: { is_disabled: true },
-      },
-    );
-    return { kind: 'sent', messageId: sent.message_id };
-  } catch (err) {
-    args.onError?.(err);
-    return { kind: 'error' };
-  }
-}