switchroom 0.13.11 → 0.13.12

package/dist/cli/switchroom.js

@@ -47314,8 +47314,8 @@ var {
 } = import__.default;
 
 // src/build-info.ts
-var VERSION = "0.13.11";
-var COMMIT_SHA = "5984798c";
+var VERSION = "0.13.12";
+var COMMIT_SHA = "18363dfb";
 
 // src/cli/agent.ts
 init_source();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.13.11",
+  "version": "0.13.12",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/gateway/gateway.js

@@ -40593,28 +40593,12 @@ function isSilentFlushMarker2(text) {
   }
   return SILENT_MARKERS2.has(trimmed.toUpperCase());
 }
-var REPLY_CALLED_TAIL_MIN_CHARS = 40;
 function decideTurnFlush(input) {
   const flushEnabled = input.flushEnabled !== false;
   if (!flushEnabled)
     return { kind: "skip", reason: "flag-disabled" };
-  if (input.replyCalled) {
-    const tailIdx = input.capturedTextLenAtLastReply ?? input.capturedText.length;
-    const tail = input.capturedText.slice(tailIdx).join(`
-`).trim();
-    const minChars = input.replyCalledTailMinChars ?? REPLY_CALLED_TAIL_MIN_CHARS;
-    if (tail.length === 0) {
-      return { kind: "skip", reason: "reply-called" };
-    }
-    if (tail.length < minChars) {
-      return { kind: "skip", reason: "reply-called-no-new-text" };
-    }
-    if (input.chatId == null)
-      return { kind: "skip", reason: "no-inbound-chat" };
-    if (isSilentFlushMarker2(tail))
-      return { kind: "skip", reason: "silent-marker" };
-    return { kind: "flush", text: tail };
-  }
+  if (input.replyCalled)
+    return { kind: "skip", reason: "reply-called" };
   if (input.chatId == null)
     return { kind: "skip", reason: "no-inbound-chat" };
   const joined = input.capturedText.join(`
@@ -46654,14 +46638,6 @@ function startSubagentWatcher(config) {
       return;
     if (entry.state === "done" && !entry.completionNotified) {
       entry.completionNotified = true;
-      const desc = escapeHtml8(truncate3(entry.description, 80));
-      const summary = entry.lastSummaryLine ? ` \u2014 ${escapeHtml8(truncate3(entry.lastSummaryLine, 120))}` : "";
-      const tools = entry.toolCount > 0 ? ` (${entry.toolCount} tools)` : "";
-      try {
-        config.sendNotification(`\u2713 Worker done: ${desc}${tools}${summary}`);
-      } catch (err) {
-        log?.(`subagent-watcher: completion notification error: ${err.message}`);
-      }
       if (config.onFinish) {
         try {
           config.onFinish({
@@ -48027,11 +48003,11 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.13.11";
-var COMMIT_SHA = "5984798c";
-var COMMIT_DATE = "2026-05-22T15:59:07+10:00";
+var VERSION = "0.13.12";
+var COMMIT_SHA = "18363dfb";
+var COMMIT_DATE = "2026-05-22T19:32:19+10:00";
 var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 3;
+var COMMITS_AHEAD_OF_TAG = 5;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -51594,7 +51570,6 @@ function handleSessionEvent(ev) {
           gatewayReceiveAt: startedAt,
           replyCalled: false,
           capturedText: [],
-          capturedTextLenAtLastReply: 0,
           orphanedReplyTimeoutId: null,
           registryKey: null,
           lastAssistantMsgId: null,
@@ -51659,7 +51634,6 @@ function handleSessionEvent(ev) {
       const name = ev.toolName;
       if (isTelegramReplyTool(name)) {
         turn.replyCalled = true;
-        turn.capturedTextLenAtLastReply = turn.capturedText.length;
         if (turn.orphanedReplyTimeoutId != null) {
           clearTimeout(turn.orphanedReplyTimeoutId);
           turn.orphanedReplyTimeoutId = null;
@@ -51822,13 +51796,8 @@ function handleSessionEvent(ev) {
         chatId: turn.sessionChatId,
         replyCalled: turn.replyCalled,
         capturedText: turn.capturedText,
-        capturedTextLenAtLastReply: turn.capturedTextLenAtLastReply,
         flushEnabled: TURN_FLUSH_SAFETY_ENABLED
       });
-      if (flushDecision.kind === "flush" && turn.replyCalled) {
-        process.stderr.write(`telegram gateway: WARN post-reply-tail flush (#1291) \u2014 model emitted ${flushDecision.text.length} chars after a prior reply call without a follow-up reply tool chat=${chatId} turnStartedAt=${turn.startedAt}
-`);
-      }
       if (flushDecision.kind === "skip" && flushDecision.reason !== "reply-called") {
         process.stderr.write(`telegram gateway: turn-flush skipped \u2014 reason=${flushDecision.reason}
 `);
@@ -57308,20 +57277,6 @@ var didOneTimeSetup = false;
               agentCwd: watcherAgentDir,
               db: turnsDb,
               parentStateDir: STATE_DIR,
-              sendNotification: (text) => {
-                const ownerChatId = loadAccess().allowFrom[0];
-                if (!ownerChatId)
-                  return;
-                swallowingApiCall(() => lockedBot.api.sendMessage(ownerChatId, text, {
-                  parse_mode: "HTML",
-                  link_preview_options: { is_disabled: true },
-                  ...TOPIC_ID != null ? { message_thread_id: TOPIC_ID } : {}
-                }), {
-                  chat_id: ownerChatId,
-                  verb: "subagent-watcher-notification",
-                  ...TOPIC_ID != null ? { threadId: TOPIC_ID } : {}
-                });
-              },
               log: (msg) => process.stderr.write(`telegram gateway: ${msg}
 `),
               onStall: (agentId, idleMs, description) => {

package/telegram-plugin/gateway/gateway.ts

@@ -1192,14 +1192,6 @@ type CurrentTurn = {
   gatewayReceiveAt: number
   replyCalled: boolean
   capturedText: string[]
-  // #1291: snapshot of capturedText.length at the moment of the most
-  // recent reply / stream_reply tool call. Used by decideTurnFlush to
-  // isolate the post-reply tail (e.g. a soft-commit reply followed by
-  // the real substantive answer in terminal text only) and flush it as
-  // a follow-up message. Pre-#1291 the existence of ANY reply call
-  // suppressed flush entirely — that lost long terminal-only answers
-  // after a "let me check" interim reply.
-  capturedTextLenAtLastReply: number
   orphanedReplyTimeoutId: ReturnType<typeof setTimeout> | null
   registryKey: string | null
   // Last assistant outbound message id for the current turn — populated
@@ -5706,7 +5698,6 @@ function handleSessionEvent(ev: SessionEvent): void {
           gatewayReceiveAt: startedAt,
           replyCalled: false,
           capturedText: [],
-          capturedTextLenAtLastReply: 0,
           orphanedReplyTimeoutId: null,
           registryKey: null,
           lastAssistantMsgId: null,
@@ -5807,12 +5798,6 @@ function handleSessionEvent(ev: SessionEvent): void {
       // placeholder-heartbeat label, which has been retired.
       if (isTelegramReplyTool(name)) {
         turn.replyCalled = true
-        // #1291: pin the captured-text index at the moment of this reply
-        // tool call. Anything pushed into capturedText after this point
-        // is the post-reply tail (e.g. the substantive answer composed
-        // in terminal text after a soft-commit "on it, back in a few").
-        // decideTurnFlush slices from this index to flush the tail.
-        turn.capturedTextLenAtLastReply = turn.capturedText.length
         if (turn.orphanedReplyTimeoutId != null) {
           clearTimeout(turn.orphanedReplyTimeoutId)
           turn.orphanedReplyTimeoutId = null
@@ -6072,20 +6057,8 @@ function handleSessionEvent(ev: SessionEvent): void {
         chatId: turn.sessionChatId,
         replyCalled: turn.replyCalled,
         capturedText: turn.capturedText,
-        capturedTextLenAtLastReply: turn.capturedTextLenAtLastReply,
         flushEnabled: TURN_FLUSH_SAFETY_ENABLED,
       })
-      // #1291: when the model emitted a soft-commit reply followed by a
-      // substantive terminal-only answer, decideTurnFlush returns
-      // kind:'flush' with the post-reply tail. Log WARN so this case is
-      // auditable — the model SHOULD have called reply for the tail, but
-      // didn't, and the framework is covering for it.
-      if (flushDecision.kind === 'flush' && turn.replyCalled) {
-        process.stderr.write(
-          `telegram gateway: WARN post-reply-tail flush (#1291) — model emitted ${flushDecision.text.length} chars after a prior reply call without a follow-up reply tool` +
-          ` chat=${chatId} turnStartedAt=${turn.startedAt}\n`,
-        )
-      }
       if (flushDecision.kind === 'skip' && flushDecision.reason !== 'reply-called') {
         process.stderr.write(
           `telegram gateway: turn-flush skipped — reason=${flushDecision.reason}\n`,
@@ -14983,26 +14956,11 @@ void (async () => {
               // inside the sub-agent. Belt-and-braces with PR #557's
               // multi-signal progress gate.
               parentStateDir: STATE_DIR,
-              sendNotification: (text: string) => {
-                const ownerChatId = loadAccess().allowFrom[0]
-                if (!ownerChatId) return
-                // #1075: thread-id-bearing — route through swallowingApiCall
-                // so a deleted TOPIC_ID forum thread doesn't crash the
-                // gateway. Notifications are best-effort.
-                void swallowingApiCall(
-                  () =>
-                    lockedBot.api.sendMessage(ownerChatId, text, {
-                      parse_mode: 'HTML',
-                      link_preview_options: { is_disabled: true },
-                      ...(TOPIC_ID != null ? { message_thread_id: TOPIC_ID } : {}),
-                    }),
-                  {
-                    chat_id: ownerChatId,
-                    verb: 'subagent-watcher-notification',
-                    ...(TOPIC_ID != null ? { threadId: TOPIC_ID } : {}),
-                  },
-                )
-              },
+              // No user-facing notification callback: the card-era
+              // "✓ Worker done" message was retired with the progress
+              // card (#1122). Sub-agent completion reaches the user as
+              // the model's own beat-4 handback reply; the watcher's
+              // role here is registry liveness + the `onFinish` cue.
               log: (msg) => process.stderr.write(`telegram gateway: ${msg}\n`),
               // Option C (#393): route stall detections into the progress-card
               // driver so the pinned card re-renders with a ⚠️ indicator even

package/telegram-plugin/subagent-watcher.ts

@@ -146,11 +146,6 @@ export interface SubagentWatcherConfig {
    * an agent's home pollutes the watcher with phantom registrations).
    */
   agentCwd?: string
-  /**
-   * Send a fresh (non-edit) Telegram message. For stall / completion
-   * state-transition notifications.
-   */
-  sendNotification: (text: string) => void
   /**
    * How often to re-scan for new subagent dirs (ms). Default 1000.
    */
@@ -862,21 +857,19 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
 
     if (entry.state === 'done' && !entry.completionNotified) {
       entry.completionNotified = true
-      const desc = escapeHtml(truncate(entry.description, 80))
-      const summary = entry.lastSummaryLine
-        ? ` — ${escapeHtml(truncate(entry.lastSummaryLine, 120))}`
-        : ''
-      const tools = entry.toolCount > 0 ? ` (${entry.toolCount} tools)` : ''
-      try {
-        config.sendNotification(`✓ Worker done: ${desc}${tools}${summary}`)
-      } catch (err) {
-        log?.(`subagent-watcher: completion notification error: ${(err as Error).message}`)
-      }
-      // Symmetric `sub_agent_finished` surface (#card-audit-log). Emit
-      // before the deferred cleanup runs so the callback always sees a
-      // live registry entry. Historical entries that already-completed at
-      // boot get their `completionNotified=true` shortcut in registerAgent
-      // and skip this path entirely — only post-boot transitions fire.
+      // Card retired (#1122): the watcher no longer sends a user-facing
+      // "✓ Worker done" message. A framework-authored status line is a
+      // conversational-pacing anti-pattern, and the heuristic that drove
+      // it (silent-stall synthesis) fired on a worker mid-`Bash` as
+      // readily as on a finished one. The user-facing handback is the
+      // model's own beat-4 reply, woken by Claude Code's native
+      // background-task notification. Completion is surfaced here only
+      // via the structured `onFinish` callback — emitted before the
+      // deferred cleanup runs so the callback always sees a live
+      // registry entry. Historical entries that already-completed at
+      // boot get their `completionNotified=true` shortcut in
+      // registerAgent and skip this path — only post-boot transitions
+      // fire.
       if (config.onFinish) {
         try {
           config.onFinish({

package/telegram-plugin/tests/fleet-state-watcher.test.ts

@@ -50,7 +50,6 @@ describe('subagent-watcher: WorkerEntry.lastTool', () => {
     const intervals: Array<{ fn: () => void }> = []
     const w = startSubagentWatcher({
       agentDir,
-      sendNotification: () => {},
       stallThresholdMs: 60_000,
       rescanMs: 500,
       now: () => Date.now(),

package/telegram-plugin/tests/subagent-registry-bugs.test.ts

@@ -148,7 +148,6 @@ function makeHarnessWithDb(opts: {
   } = opts
 
   let currentTime = 10_000
-  const notifications: string[] = []
   const logs: string[] = []
 
   const fileContents: Map<string, Buffer> = new Map()
@@ -217,7 +216,6 @@ function makeHarnessWithDb(opts: {
 
   const watcher = startSubagentWatcher({
     agentDir,
-    sendNotification: (text) => notifications.push(text),
     stallThresholdMs,
     // Mirror the active-loop threshold for fixtures with toolCount=0;
     // tests that need the silent-synthesis vs active-loop distinction
@@ -257,7 +255,7 @@ function makeHarnessWithDb(opts: {
     if (pollInterval) pollInterval.fn()
   }
 
-  return { notifications, logs, advance, poll, watcher, now: () => currentTime, mockFs, fileContents }
+  return { logs, advance, poll, watcher, now: () => currentTime, mockFs, fileContents }
 }
 
 // ─── Bug 1 — ID mismatch: watcher never bumps last_activity_at ───────────────

package/telegram-plugin/tests/subagent-watcher-env-thresholds.test.ts

@@ -84,7 +84,6 @@ function makeHarness(opts: {
     silentSynthesisStallThresholdMs: configStallThresholdMs,
     silentStallTerminalMs: configSilentStallTerminalMs,
     rescanMs: 500,
-    sendNotification: () => {},
     onStall: (_id, idleMs) => stallCalls.push({ idleMs }),
     onStallTerminal: (id) => stallTerminalCalls.push({ agentId: id }),
     onFinish: ({ outcome }) => finishCalls.push({ outcome }),

package/telegram-plugin/tests/subagent-watcher-parent-marker.test.ts

@@ -86,7 +86,6 @@ describe('subagent-watcher: parent turn-active marker refresh (#501)', () => {
     let nextRef = 1
     const watcher = startSubagentWatcher({
       agentDir: opts.agentDir,
-      sendNotification: () => { /* noop */ },
       stallThresholdMs: 60_000,
       rescanMs: 500,
       now: () => Date.now(),

package/telegram-plugin/tests/subagent-watcher-stall-notification.test.ts

@@ -26,7 +26,6 @@ function subAgentUserMsg(promptText: string) {
 // ─── Harness (mirrors subagent-watcher.test.ts pattern) ──────────────────────
 
 interface StallHarness {
-  notifications: string[]
   stallCalls: Array<{ agentId: string; idleMs: number; description: string }>
   unstallCalls: Array<{ agentId: string; description: string }>
   logs: string[]
@@ -55,7 +54,6 @@ function makeStallHarness(opts: {
   } = opts
 
   let currentTime = 1000
-  const notifications: string[] = []
   const stallCalls: Array<{ agentId: string; idleMs: number; description: string }> = []
   const unstallCalls: Array<{ agentId: string; description: string }> = []
   const logs: string[] = []
@@ -139,7 +137,6 @@ function makeStallHarness(opts: {
     // silent-synthesis vs active-loop split.
     silentSynthesisStallThresholdMs: silentSynthesisStallThresholdMs ?? stallThresholdMs,
     rescanMs,
-    sendNotification: (text) => notifications.push(text),
     onStall: (id, idle, desc) => stallCalls.push({ agentId: id, idleMs: idle, description: desc }),
     onUnstall: (id, desc) => unstallCalls.push({ agentId: id, description: desc }),
     now: () => currentTime,
@@ -168,7 +165,7 @@ function makeStallHarness(opts: {
     }
   }
 
-  return { notifications, stallCalls, unstallCalls, logs, advance, watcher, now: () => currentTime, fileContents, jsonlPath }
+  return { stallCalls, unstallCalls, logs, advance, watcher, now: () => currentTime, fileContents, jsonlPath }
 }
 
 // ─── Tests ────────────────────────────────────────────────────────────────────

package/telegram-plugin/tests/subagent-watcher-stall-terminal.test.ts

@@ -127,7 +127,6 @@ function makeHarness(opts: {
     silentSynthesisStallThresholdMs: stallThresholdMs,
     silentStallTerminalMs,
     rescanMs,
-    sendNotification: () => {},
     onStall: (id, idleMs) => stallCalls.push({ agentId: id, idleMs }),
     onUnstall: (id) => unstallCalls.push({ agentId: id }),
     onStallTerminal: (id, desc) => stallTerminalCalls.push({ agentId: id, description: desc }),

package/telegram-plugin/tests/subagent-watcher.test.ts

@@ -198,7 +198,10 @@ function makeHarness(opts: {
 
   const watcher = startSubagentWatcher({
     agentDir,
-    sendNotification: (text) => notifications.push(text),
+    // Card retired (#1122): completion surfaces via onFinish, not a
+    // user-facing message. Capture it so the completion assertions still
+    // verify the terminal-transition + de-dup behaviour.
+    onFinish: (info) => notifications.push(`✓ Worker done: ${info.description}`),
     stallThresholdMs,
     // Mirror the active-loop threshold so existing fixtures (which have
     // toolCount=0 and use the simple "advance past N" model) keep
@@ -382,8 +385,13 @@ describe('startSubagentWatcher', () => {
       let nextRef = 1
       const watcher = startSubagentWatcher({
         agentDir: opts.agentDir,
-        sendNotification: (text) => notifications.push(text),
-        ...(opts.onFinish ? { onFinish: opts.onFinish } : {}),
+        // Card retired (#1122): completion surfaces via onFinish. Capture
+        // it for the completion assertions and still delegate to any
+        // test-supplied onFinish.
+        onFinish: (info) => {
+          notifications.push(`✓ Worker done: ${info.description}`)
+          opts.onFinish?.(info)
+        },
         stallThresholdMs: 60_000,
         rescanMs: 500,
         now: () => Date.now(),
@@ -994,7 +1002,8 @@ describe('startSubagentWatcher', () => {
       const watcher = startSubagentWatcher({
         agentDir: opts.agentDir,
         ...(opts.agentCwd !== undefined ? { agentCwd: opts.agentCwd } : {}),
-        sendNotification: (text) => notifications.push(text),
+        // Card retired (#1122): completion surfaces via onFinish.
+        onFinish: (info) => notifications.push(`✓ Worker done: ${info.description}`),
         stallThresholdMs: 60_000,
         rescanMs: 500,
         now: () => Date.now(),
@@ -1133,7 +1142,8 @@ describe('startSubagentWatcher', () => {
       let nextRef = 1
       const watcher = startSubagentWatcher({
         agentDir,
-        sendNotification: (text) => notifications.push(text),
+        // Card retired (#1122): completion surfaces via onFinish.
+        onFinish: (info) => notifications.push(`✓ Worker done: ${info.description}`),
         stallThresholdMs: 60_000,
         rescanMs: 500,
         now: () => Date.now(),

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

@@ -138,112 +138,60 @@ 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', () => {
+  // The turn-flush safety net covers exactly one failure mode: a turn that
+  // ended with the model never having said anything. Once the model has
+  // called reply / stream_reply the turn is served — any assistant text it
+  // emits afterwards is its own end-of-turn wrap-up (a closing summary,
+  // narration to itself), NOT a message it chose to send. The framework
+  // must never promote that terminal text into a second Telegram bubble.
+  //
+  // Regression guard for the redundant-follow-up-message fix: this reverts
+  // the #1291 post-reply-tail flush, which posted a duplicate recap on
+  // essentially every turn because the model habitually writes a closing
+  // summary after its final reply. See reference/conversational-pacing.md
+  // — "the framework owns the beat; the model authors the words".
+  describe('reply-called turns never flush trailing terminal text', () => {
+    it('skips even when a long substantive tail follows the reply', () => {
       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.',
+          'Answered the Playwright question and acked the calendar ' +
+            'diagnosis is still in flight. Will surface the root cause ' +
+            'when the worker returns.',
         ],
-        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)', () => {
+    it('skips regardless of how many text blocks trail the reply', () => {
       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,
+        chatId: '701',
         replyCalled: true,
         capturedText: [
-          'pre',
-          'this tail would have been substantive enough to flush normally',
+          'a substantive paragraph the model wrote as terminal text',
+          'and another one, each well over any old length threshold',
+          'and a third closing summary block for good measure',
         ],
-        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', () => {
+    it('skips with reply-called when capturedText is empty', () => {
       const decision = decideTurnFlush({
-        chatId: '705',
+        chatId: '702',
         replyCalled: true,
-        capturedText: ['pre-reply', 'short but substantive in this test'],
-        capturedTextLenAtLastReply: 1,
-        replyCalledTailMinChars: 10,
+        capturedText: [],
       })
-      expect(decision.kind).toBe('flush')
+      expect(decision).toEqual({ kind: 'skip', reason: 'reply-called' })
     })
 
-    it('feature flag off still wins over post-reply tail flush', () => {
+    it('feature flag off still wins over a reply-called turn', () => {
       const decision = decideTurnFlush({
-        chatId: '706',
+        chatId: '703',
         replyCalled: true,
-        capturedText: [
-          'pre',
-          'a long substantive post-reply tail that would otherwise flush',
-        ],
-        capturedTextLenAtLastReply: 1,
+        capturedText: ['a long substantive tail that pre-fix would flush'],
         flushEnabled: false,
       })
       expect(decision).toEqual({ kind: 'skip', reason: 'flag-disabled' })

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

@@ -57,7 +57,6 @@ export type FlushDecision =
 export type FlushSkipReason =
   | 'flag-disabled'
   | 'reply-called'
-  | 'reply-called-no-new-text'
   | 'no-inbound-chat'
   | 'empty-text'
   | 'silent-marker'
@@ -70,35 +69,14 @@ export interface FlushDecisionInput {
    * this turn. */
   replyCalled: boolean
   /** Raw text content blocks accumulated from assistant events across the
-   * turn. Joined + trimmed internally. */
+   * turn. Joined + trimmed internally. Only consulted when `replyCalled`
+   * is false — once the model has called reply / stream_reply the turn is
+   * served and trailing terminal text is dropped (see `decideTurnFlush`). */
   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
@@ -107,39 +85,31 @@ export const REPLY_CALLED_TAIL_MIN_CHARS = 40
  * 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).
+ * The safety net has exactly one job: a turn that ended with the model
+ * having said *nothing* to the user. Once `replyCalled` is true the model
+ * has communicated through the proper channel and the decision is always
+ * `skip` — assistant text emitted after a reply is the model's own
+ * end-of-turn wrap-up (a closing summary, narration to itself), not a
+ * message it chose to send. Promoting that terminal text into a Telegram
+ * message second-guesses an explicit reply and posts a redundant duplicate
+ * on essentially every turn, because the model habitually writes a closing
+ * summary. The framework owns the *beat*; the model authors the *words*
+ * and emits them via reply (`reference/conversational-pacing.md`).
+ *
+ * (This reverts the #1291 post-reply-tail flush. Its intent — catch a
+ * soft-commit reply followed by the real answer in terminal text only —
+ * could not be told apart from the habitual wrap-up by length, so it
+ * misfired constantly. A model that soft-commits and never delivers is a
+ * pacing failure caught by the silence-poke ladder, not papered over here.)
  */
 export function decideTurnFlush(input: FlushDecisionInput): FlushDecision {
   const flushEnabled = input.flushEnabled !== false
   if (!flushEnabled) return { kind: 'skip', reason: 'flag-disabled' }
 
-  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 }
-  }
+  // The model communicated through the proper channel — trust it. Any
+  // assistant text it emitted as terminal text afterwards is its own
+  // end-of-turn wrap-up, never a second Telegram message.
+  if (input.replyCalled) return { kind: 'skip', reason: 'reply-called' }
 
   if (input.chatId == null) return { kind: 'skip', reason: 'no-inbound-chat' }
   const joined = input.capturedText.join('\n').trim()