switchroom 0.13.11 → 0.13.13

package/telegram-plugin/gateway/gateway.ts

@@ -76,7 +76,8 @@ import {
 import { emitRuntimeMetric } from '../runtime-metrics.js'
 import { classifyInbound } from '../inbound-classifier.js'
 import * as silencePoke from '../silence-poke.js'
-import { writeSilentEndState, clearSilentEndState, recordSilentTurnEnd } from '../silent-end.js'
+import { writeSilentEndState, clearSilentEndState, recordUndeliveredTurnEnd } from '../silent-end.js'
+import { isFinalAnswerReply } from '../final-answer-detect.js'
 import { createAnswerStream, type AnswerStreamHandle } from '../answer-stream.js'
 import { type SessionEvent } from '../session-tail.js'
 import {
@@ -1191,15 +1192,20 @@ type CurrentTurn = {
   startedAt: number
   gatewayReceiveAt: number
   replyCalled: boolean
+  // #1664 — whether the model has delivered its *final answer* this turn
+  // (as opposed to only an interim ack). `replyCalled` flips on the first
+  // reply / stream_reply tool_use and stays true for the rest of the turn,
+  // so it cannot tell "ack only" from "ack + real answer". This flag is the
+  // finer signal the silent-end re-prompt needs: it is set only when a reply
+  // actually lands AND `isFinalAnswerReply` (final-answer-detect.ts)
+  // classifies it as the final answer — notification-bearing, or long
+  // enough to be substantive, or a stream_reply done=true — OR when the
+  // turn-flush safety net legitimately emits the model's terminal text. A
+  // turn that ends with this still `false` triggers the silent-end re-prompt
+  // even though `replyCalled` is true — the #1664 case where the real answer
+  // ended up as plain transcript text rendered into an ephemeral draft.
+  finalAnswerDelivered: 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
@@ -4074,6 +4080,13 @@ async function executeUpdateChecklist(args: Record<string, unknown>): Promise<{
 }
 
 async function executeReply(args: Record<string, unknown>): Promise<{ content: Array<{ type: string; text: string }> }> {
+  // #1664 — pin the turn this reply belongs to at entry. The
+  // finalAnswerDelivered write near the end of this function runs after
+  // several awaits; turn-pinning (the #1067 pattern used across the
+  // gateway) keeps the write attributed to THIS turn rather than reading
+  // module-scope currentTurn, which a future refactor could let roll over
+  // mid-call.
+  const turn = currentTurn
   const chat_id = args.chat_id as string
   if (!chat_id) throw new Error('reply: chat_id is required')
   const rawText = args.text as string | undefined
@@ -4496,6 +4509,19 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
     } catch (err) {
       process.stderr.write(`telegram gateway: reply: endStatusReaction hook threw: ${err}\n`)
     }
+    // #1664 — mark the turn's final answer as delivered when this reply
+    // looks like the real answer rather than an interim ack. The
+    // classification (notification-bearing OR substantive length) lives
+    // in `isFinalAnswerReply`. Without this, a turn that ack'd then ended
+    // with the real answer as plain transcript text (#1664) would look
+    // "delivered" because replyCalled is true — and the silent-end
+    // re-prompt would never engage. `rawText` is the model's own answer
+    // text, measured before HTML conversion / Telegraph-link
+    // substitution. Writes `turn` (pinned at executeReply entry) so the
+    // flag always lands on the turn this reply belongs to.
+    if (turn != null && isFinalAnswerReply({ text: rawText, disableNotification })) {
+      turn.finalAnswerDelivered = true
+    }
   }
 
   process.stderr.write(`telegram channel: reply: finalized chatId=${chat_id} messageIds=[${sentIds.join(',')}] chunks=${chunks.length}\n`)
@@ -4509,6 +4535,8 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
 }
 
 async function executeStreamReply(args: Record<string, unknown>): Promise<unknown> {
+  // #1664 — pin the turn at entry; see executeReply for the rationale.
+  const turn = currentTurn
   if (!args.chat_id) throw new Error('stream_reply: chat_id is required')
   if (args.text == null || args.text === '') throw new Error('stream_reply: text is required and cannot be empty')
 
@@ -4688,6 +4716,23 @@ async function executeStreamReply(args: Record<string, unknown>): Promise<unknow
     const sThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
     outboundDedup.record(sChatId, sThreadId, args.text as string, Date.now())
   }
+  // #1664 — mark the turn's final answer as delivered. For stream_reply a
+  // call with done=true IS the final answer by definition (the model
+  // explicitly closed the stream). A non-terminal stream_reply chunk also
+  // counts when it carries the final-answer signals — notification-bearing
+  // OR substantive length — via the same `isFinalAnswerReply` predicate
+  // executeReply uses. See the CurrentTurn.finalAnswerDelivered doc-comment
+  // for why replyCalled is not a sufficient signal here.
+  if (
+    turn != null &&
+    isFinalAnswerReply({
+      text: (args.text as string | undefined) ?? '',
+      disableNotification: args.disable_notification === true,
+      done: args.done === true,
+    })
+  ) {
+    turn.finalAnswerDelivered = true
+  }
   return { content: [{ type: 'text', text: `${result.status} (id: ${result.messageId ?? 'pending'})` }] }
 }
 
@@ -5705,8 +5750,8 @@ function handleSessionEvent(ev: SessionEvent): void {
           startedAt,
           gatewayReceiveAt: startedAt,
           replyCalled: false,
+          finalAnswerDelivered: false,
           capturedText: [],
-          capturedTextLenAtLastReply: 0,
           orphanedReplyTimeoutId: null,
           registryKey: null,
           lastAssistantMsgId: null,
@@ -5807,12 +5852,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
@@ -5830,6 +5869,22 @@ function handleSessionEvent(ev: SessionEvent): void {
       // #1067: snapshot at entry. The answer-stream creation closures
       // below also read `turn` instead of currentTurn so they pin to
       // this turn's chat for the stream's lifetime.
+      //
+      // #1664 ordering note: a `text` event can arrive AFTER turn_end has
+      // nulled currentTurn (the issue observed `answer_lane_update
+      // transport:"draft"` firing post-turn_end). Such a late event is
+      // dropped here by the `turn != null` guard — it is NOT folded back
+      // into the just-ended turn. That is deliberate and safe: by the
+      // time this fires, the turn atom has been handed to
+      // endCurrentTurnAtomic and turn_end has already run its flush /
+      // silent-end decision; re-opening a closed turn (re-creating an
+      // answer stream, re-evaluating decideTurnFlush) would be a large,
+      // race-prone change. The #1664 safety net does not depend on
+      // catching the late text: a turn whose real answer lost the race
+      // ends with finalAnswerDelivered=false, so recordUndeliveredTurnEnd
+      // engages the Stop-hook re-prompt and the model re-delivers the
+      // answer through the reply tool. The dropped draft text is
+      // recovered by re-prompt, not by post-hoc materialization.
       const turn = currentTurn
       if (turn != null) {
         turn.capturedText.push(ev.text)
@@ -6072,20 +6127,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`,
@@ -6208,6 +6251,18 @@ function handleSessionEvent(ev: SessionEvent): void {
         const backstopThreadId = threadId
         const backstopCtrl = ctrl
 
+        // #1664 — turn-flush only fires when !replyCalled (decideTurnFlush
+        // returns 'reply-called' otherwise). It legitimately delivers the
+        // model's terminal text as the answer, so the turn IS answered.
+        // Mark it now so the early-return below skips the silent-end
+        // re-prompt for a turn whose answer is genuinely on its way out.
+        // (The IIFE that actually sends runs after this branch's `return`;
+        // since the silent-end block is on the sibling reply-called path
+        // that this branch never reaches, this set is belt-and-braces —
+        // it keeps the captured `turn` atom internally consistent for any
+        // future reader.)
+        turn.finalAnswerDelivered = true
+
         // #654 deterministic double-message fix. Hand off the pinned
         // progress card BEFORE state reset so the driver doesn't keep
         // editing it while turn-flush is rewriting it with the answer.
@@ -6440,17 +6495,31 @@ function handleSessionEvent(ev: SessionEvent): void {
           longest_silent_gap_ms: outboundMetrics.longestOutboundGapMs,
           ended_via: outboundMetrics.outboundCount > 0 ? 'reply' : 'silent',
         })
-        // #1122 PR4 / #1161: deterministic silent-end handling (see the
-        // silent-marker path above for the rationale).
-        //   - first silent-end → recordSilentTurnEnd writes the state
-        //     file so the Stop hook (silent-end-interrupt-stop.mjs)
-        //     blocks the session-end and re-prompts the agent to reply.
+        // #1122 PR4 / #1161 / #1664: deterministic undelivered-turn
+        // handling (see the silent-marker path above for the rationale).
+        //   - first undelivered turn-end → recordSilentTurnEnd writes the
+        //     state file so the Stop hook (silent-end-interrupt-stop.mjs)
+        //     blocks the session-end and re-prompts the agent to deliver.
         //   - the Stop-hook re-prompt is already spent and the agent is
-        //     STILL silent → recordSilentTurnEnd returns exhausted:true;
-        //     deliver a user-facing fallback so the turn never just
-        //     vanishes (the user otherwise only sees the card disappear).
-        if (outboundMetrics.outboundCount === 0) {
-          const silentEnd = recordSilentTurnEnd({
+        //     STILL undelivered → recordSilentTurnEnd returns
+        //     exhausted:true; deliver a user-facing fallback so the turn
+        //     never just vanishes (the user otherwise only sees the card
+        //     disappear).
+        //
+        // #1664 — the trigger is "no final answer delivered", not "zero
+        // outbound". `outboundCount === 0` is now just the special case
+        // where nothing landed at all. The added case: the model sent an
+        // interim ack via reply/stream_reply (outboundCount > 0,
+        // replyCalled = true) but ended the turn with its real answer as
+        // plain transcript text — rendered into an ephemeral answer-lane
+        // draft and retracted at turn_end, never finalized. finalAnswer-
+        // Delivered stays false there, so the re-prompt engages and the
+        // model re-delivers the answer through the reply tool. NO_REPLY /
+        // HEARTBEAT_OK silent-marker turns return earlier and never reach
+        // this path. The turn-flush 'flush' branch also returns earlier
+        // (and sets finalAnswerDelivered=true defensively).
+        if (turn.finalAnswerDelivered === false) {
+          const silentEnd = recordUndeliveredTurnEnd({
             chatId,
             threadId: threadId ?? null,
             turnKey: tKey,
@@ -14983,26 +15052,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/hooks/silent-end-interrupt-stop.mjs

@@ -2,12 +2,20 @@
 /**
  * Stop hook — auto-interrupt for silent-end turns.
  *
- * When a Claude Code session ends without the agent having called reply or
- * stream_reply (a "silent-end"), the Telegram gateway writes a state file at
+ * When a Claude Code session ends without the agent delivering a final
+ * answer to the user, the Telegram gateway writes a state file at
  * $TELEGRAM_STATE_DIR/silent-end-pending.json. This hook reads that file and,
  * if a first-time silent-end is detected (retryCount === 0), returns a
  * decision:block to re-prompt the agent instead of letting the session close.
  *
+ * #1664 — "no final answer delivered" covers two cases: (a) the turn ended
+ * with zero outbound (the original case), and (b) the model sent only an
+ * interim ack via reply/stream_reply but left its real answer as plain
+ * transcript text, which the gateway renders into an ephemeral draft and
+ * never finalizes. The re-prompt below tells the model to send its answer
+ * through the reply tool, or reply NO_REPLY if it genuinely has nothing to
+ * add / already delivered.
+ *
  * On the second silent-end (retryCount >= MAX_RETRIES), the hook allows the
  * stop. The gateway's turn-end path (recordSilentTurnEnd in silent-end.ts)
  * detects the exhausted re-prompt and delivers a user-facing fallback
@@ -104,9 +112,13 @@ function main() {
     JSON.stringify({
       decision: 'block',
       reason:
-        'You ran tools but never sent a reply to the user. ' +
-        'Call mcp__switchroom-telegram__reply or mcp__switchroom-telegram__stream_reply (with done=true) ' +
-        'to send your final answer now.',
+        'This turn is ending without your final answer reaching the user. ' +
+        'If you wrote an answer as plain text (not via a tool), the user ' +
+        'cannot see it — only text sent through the reply tool is delivered. ' +
+        'Send your final answer now by calling mcp__switchroom-telegram__reply ' +
+        '(or mcp__switchroom-telegram__stream_reply with done=true). ' +
+        'If your final answer has already reached the user, or you ' +
+        'intentionally have nothing to add, reply with exactly NO_REPLY.',
     }),
   )
   process.exit(0)

package/telegram-plugin/silent-end.ts

@@ -182,22 +182,39 @@ export function readSilentEndState(deps?: SilentEndDeps): SilentEndState | null
 }
 
 /**
- * Record a user-message turn that ended with zero outbound messages and
- * report whether the deterministic re-prompt has been exhausted. This is
- * the gateway's single entry point for the main turn-end path.
+ * Record a user-message turn that ended WITHOUT the model delivering a
+ * final answer, and report whether the deterministic re-prompt has been
+ * exhausted. This is the gateway's single entry point for the main
+ * turn-end path.
  *
- *   - First silent-end of a turn (no prior state, or prior `retryCount`
+ * #1664 — the trigger generalized from "zero outbound" to "no final
+ * answer delivered". Two cases reach here now:
+ *   1. Zero outbound — the turn ended with nothing sent at all (the
+ *      original #1122/#1161 silent-end case).
+ *   2. Interim-ack only — the model sent an ack via reply/stream_reply
+ *      but ended the turn with its real answer as plain transcript text
+ *      (rendered into an ephemeral answer-lane draft that gets retracted
+ *      at turn_end, never finalized). The gateway tracks this via
+ *      `CurrentTurn.finalAnswerDelivered`; case 1 is just the subset
+ *      where that flag is false because nothing landed.
+ * In both cases the model still owes the user an answer, so the same
+ * re-prompt safety net applies — the framework re-prompts; the model
+ * re-delivers via the reply tool (never the framework materializing a
+ * message from the draft — see `reference/principles.md`).
+ *
+ *   - First undelivered turn-end (no prior state, or prior `retryCount`
  *     still below `SILENT_END_MAX_RETRIES`) → writes the state file via
  *     `writeSilentEndState`, so `silent-end-interrupt-stop.mjs` blocks
  *     the stop and re-prompts the agent. Returns `{ exhausted: false }`.
  *
- *   - A silent-end where the prior state for the SAME turn already shows
- *     `retryCount >= SILENT_END_MAX_RETRIES` → the Stop hook already
- *     spent its re-prompt and the agent is STILL silent. Recovery has
- *     failed. Clears the state file (so the Stop hook on this final turn
- *     finds nothing pending and allows the stop cleanly) and returns
- *     `{ exhausted: true }` — the caller MUST then deliver a user-facing
- *     fallback so the turn never just vanishes (#1161).
+ *   - An undelivered turn-end where the prior state for the SAME turn
+ *     already shows `retryCount >= SILENT_END_MAX_RETRIES` → the Stop
+ *     hook already spent its re-prompt and the agent is STILL
+ *     undelivered. Recovery has failed. Clears the state file (so the
+ *     Stop hook on this final turn finds nothing pending and allows the
+ *     stop cleanly) and returns `{ exhausted: true }` — the caller MUST
+ *     then deliver a user-facing fallback so the turn never just
+ *     vanishes (#1161).
  *
  * Chat-less autonomous wakeup turns never reach here: the gateway only
  * creates a `currentTurn` (and therefore only runs a turn-end handler)
@@ -228,3 +245,12 @@ export function recordSilentTurnEnd(
   writeSilentEndState(args, deps)
   return { exhausted: false }
 }
+
+/**
+ * #1664 — semantic alias for `recordSilentTurnEnd`. The trigger is now
+ * "no final answer delivered", of which "zero outbound" is one case; new
+ * callsites should prefer this name so the intent reads correctly. The
+ * behaviour, retry semantics, and `{exhausted}` contract are identical —
+ * `recordSilentTurnEnd` is kept for the existing callers and tests.
+ */
+export const recordUndeliveredTurnEnd = recordSilentTurnEnd

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/final-answer-detect.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Unit coverage for the #1664 final-answer detection predicate.
+ *
+ * `isFinalAnswerReply` is the finer signal the silent-end re-prompt needs:
+ * the gateway's `replyCalled` flag flips on the first reply / stream_reply
+ * tool use and cannot tell an interim ack from the real answer. This
+ * predicate classifies each reply so a turn whose every reply was "interim"
+ * (and whose real answer ended up as plain transcript text) ends with
+ * `finalAnswerDelivered === false` and triggers the re-prompt — the #1664
+ * bug (streamed answers rendered to a draft, retracted at turn_end, lost).
+ *
+ * These tests pin the pure predicate. The gateway wires it into
+ * executeReply / executeStreamReply (covered by the gateway integration
+ * surface); pinning the policy here keeps it auditable without importing
+ * the multi-thousand-line gateway module.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { isFinalAnswerReply, FINAL_ANSWER_MIN_CHARS } from '../final-answer-detect.js'
+
+describe('isFinalAnswerReply — #1664 final-answer classification', () => {
+  it('classifies a notification-bearing reply as the final answer', () => {
+    // disable_notification:false is the pacing contract's "final answer"
+    // signal — interim updates pass disable_notification:true.
+    expect(
+      isFinalAnswerReply({ text: 'short answer', disableNotification: false }),
+    ).toBe(true)
+  })
+
+  it('classifies a short interim ack (disable_notification:true) as NOT final', () => {
+    expect(
+      isFinalAnswerReply({ text: 'on it…', disableNotification: true }),
+    ).toBe(false)
+  })
+
+  it('length backstop: a long reply mis-marked interim still counts as final', () => {
+    const longText = 'x'.repeat(FINAL_ANSWER_MIN_CHARS)
+    expect(
+      isFinalAnswerReply({ text: longText, disableNotification: true }),
+    ).toBe(true)
+  })
+
+  it('length backstop is inclusive at exactly FINAL_ANSWER_MIN_CHARS', () => {
+    expect(
+      isFinalAnswerReply({
+        text: 'x'.repeat(FINAL_ANSWER_MIN_CHARS),
+        disableNotification: true,
+      }),
+    ).toBe(true)
+    // One char under the threshold and marked interim → still interim.
+    expect(
+      isFinalAnswerReply({
+        text: 'x'.repeat(FINAL_ANSWER_MIN_CHARS - 1),
+        disableNotification: true,
+      }),
+    ).toBe(false)
+  })
+
+  it('stream_reply done=true is always the final answer, even short + interim', () => {
+    // A done=true call explicitly closes the stream — it IS the answer,
+    // regardless of length or the notification flag.
+    expect(
+      isFinalAnswerReply({ text: 'ok', disableNotification: true, done: true }),
+    ).toBe(true)
+  })
+
+  it('a non-terminal stream_reply chunk (done=false) is classified like a plain reply', () => {
+    // Short interim chunk → not final.
+    expect(
+      isFinalAnswerReply({ text: 'thinking…', disableNotification: true, done: false }),
+    ).toBe(false)
+    // Notification-bearing chunk → final.
+    expect(
+      isFinalAnswerReply({ text: 'here it is', disableNotification: false, done: false }),
+    ).toBe(true)
+  })
+
+  it('an empty reply marked interim is NOT the final answer', () => {
+    expect(
+      isFinalAnswerReply({ text: '', disableNotification: true }),
+    ).toBe(false)
+  })
+
+  it('FINAL_ANSWER_MIN_CHARS is the documented 200-char backstop', () => {
+    // Guards the constant against silent drift — the value is referenced
+    // in the CurrentTurn doc-comment and the Stop-hook rationale.
+    expect(FINAL_ANSWER_MIN_CHARS).toBe(200)
+  })
+})

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/silent-end.test.ts

@@ -8,8 +8,10 @@ import {
   clearSilentEndState,
   readSilentEndState,
   recordSilentTurnEnd,
+  recordUndeliveredTurnEnd,
   SILENT_END_MAX_RETRIES,
 } from '../silent-end.js'
+import { isFinalAnswerReply } from '../final-answer-detect.js'
 
 let stateDir: string
 const ORIG_ENV = process.env.TELEGRAM_STATE_DIR
@@ -187,6 +189,118 @@ describe('recordSilentTurnEnd — #1161 exhaustion detection', () => {
   })
 })
 
+describe('recordUndeliveredTurnEnd — #1664 extended trigger', () => {
+  it('is the same function as recordSilentTurnEnd (semantic alias)', () => {
+    expect(recordUndeliveredTurnEnd).toBe(recordSilentTurnEnd)
+  })
+
+  // The gateway computes `finalAnswerDelivered` by OR-ing isFinalAnswerReply
+  // across every reply landed this turn, then engages the re-prompt iff the
+  // flag is still false at turn_end. These tests reproduce that exact
+  // decision: classify the turn's replies, then call recordUndeliveredTurnEnd
+  // only when no reply qualified.
+  function simulateTurnEnd(
+    replies: Array<{ text: string; disableNotification: boolean; done?: boolean }>,
+    turnKey: string,
+  ): { finalAnswerDelivered: boolean; rePromptEngaged: boolean } {
+    const finalAnswerDelivered = replies.some((r) =>
+      isFinalAnswerReply(r),
+    )
+    let rePromptEngaged = false
+    if (finalAnswerDelivered === false) {
+      recordUndeliveredTurnEnd({ chatId: 'c', threadId: null, turnKey })
+      rePromptEngaged = true
+    }
+    return { finalAnswerDelivered, rePromptEngaged }
+  }
+
+  it('#1664 regression: ack reply + answer-as-transcript → re-prompt fires', () => {
+    // The exact #1664 shape: the model sent a short interim ack via the
+    // reply tool (disable_notification:true), then ended the turn with its
+    // real answer as plain transcript text — which the gateway renders into
+    // an ephemeral draft and retracts at turn_end, never finalized. No
+    // reply qualified as the final answer, so the turn is undelivered.
+    const r = simulateTurnEnd(
+      [{ text: 'On it — give me a moment.', disableNotification: true }],
+      'c:1664',
+    )
+    expect(r.finalAnswerDelivered).toBe(false)
+    expect(r.rePromptEngaged).toBe(true)
+    // State file written so silent-end-interrupt-stop.mjs blocks the stop.
+    expect(readSilentEndState()).toMatchObject({ turnKey: 'c:1664', retryCount: 0 })
+  })
+
+  it('a turn with a final-answer reply (notification-bearing) → re-prompt NOT engaged', () => {
+    const r = simulateTurnEnd(
+      [{ text: 'Here is the answer.', disableNotification: false }],
+      'c:final',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('a long reply mis-marked interim → re-prompt NOT engaged (length backstop)', () => {
+    const r = simulateTurnEnd(
+      [{ text: 'x'.repeat(500), disableNotification: true }],
+      'c:long',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('zero-outbound turn → re-prompt still engaged (regression of the original case)', () => {
+    // No replies at all — the original #1122 silent-end case is now just
+    // the subset of "no final answer delivered" where nothing landed.
+    const r = simulateTurnEnd([], 'c:zero')
+    expect(r.finalAnswerDelivered).toBe(false)
+    expect(r.rePromptEngaged).toBe(true)
+    expect(readSilentEndState()).toMatchObject({ turnKey: 'c:zero', retryCount: 0 })
+  })
+
+  it('interim ack followed by a final-answer reply in the same turn → NOT engaged', () => {
+    // The model ack'd first then properly delivered — finalAnswerDelivered
+    // latches true on the second reply; the turn is answered.
+    const r = simulateTurnEnd(
+      [
+        { text: 'Looking into it…', disableNotification: true },
+        { text: 'Done — the result is 42.', disableNotification: false },
+      ],
+      'c:ack-then-final',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('stream_reply done=true counts as the final answer → NOT engaged', () => {
+    const r = simulateTurnEnd(
+      [{ text: 'ok', disableNotification: true, done: true }],
+      'c:stream-done',
+    )
+    expect(r.finalAnswerDelivered).toBe(true)
+    expect(r.rePromptEngaged).toBe(false)
+    expect(readSilentEndState()).toBeNull()
+  })
+
+  it('exhaustion still applies on the #1664 path after the Stop-hook re-prompt', () => {
+    // First undelivered turn-end writes state.
+    expect(simulateTurnEnd(
+      [{ text: 'one sec', disableNotification: true }],
+      'c:exhaust',
+    ).rePromptEngaged).toBe(true)
+    // Stop hook blocks once and bumps retryCount (simulated).
+    const path = join(stateDir, 'silent-end-pending.json')
+    const s = readSilentEndState()!
+    writeFileSync(path, JSON.stringify({ ...s, retryCount: s.retryCount + 1 }))
+    // Re-prompted turn STILL ends with only an interim ack → exhausted.
+    const second = recordUndeliveredTurnEnd({ chatId: 'c', threadId: null, turnKey: 'c:exhaust' })
+    expect(second.exhausted).toBe(true)
+    expect(readSilentEndState()).toBeNull()
+  })
+})
+
 describe('silent-end-interrupt-stop hook — integration', () => {
   const hookPath = join(__dirname, '..', 'hooks', 'silent-end-interrupt-stop.mjs')
 
@@ -222,6 +336,10 @@ describe('silent-end-interrupt-stop hook — integration', () => {
     const out = JSON.parse(r.stdout.trim())
     expect(out.decision).toBe('block')
     expect(out.reason).toContain('reply')
+    // #1664 — the re-prompt must offer the NO_REPLY escape hatch so a
+    // model that already delivered (or intentionally has nothing to add)
+    // can end the turn cleanly instead of being forced to re-send.
+    expect(out.reason).toContain('NO_REPLY')
     // retryCount must have been incremented to 1
     expect(readSilentEndState()!.retryCount).toBe(1)
   })