switchroom 0.18.30 → 0.18.31

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.18.30", COMMIT_SHA = "7729c674";
+var VERSION = "0.18.31", COMMIT_SHA = "486b55f9";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -26179,7 +26179,10 @@ function webkiteDenyForAgent(agentConfig) {
 function resolveMainModel(model) {
   if (model === undefined || model === "default")
     return SWITCHROOM_DEFAULT_MAIN_MODEL;
-  return model;
+  return normalizeModelAlias(model);
+}
+function normalizeModelAlias(model) {
+  return model === "claude-fable-5" ? "fable" : model;
 }
 function dedupe2(items) {
   const seen = new Set;
@@ -66965,7 +66968,7 @@ function registerAgentCommand(program3) {
           name,
           status: status?.active ?? "unknown",
           uptime: formatUptime2(status?.uptime ?? null),
-          model: resolved.model ?? SWITCHROOM_DEFAULT_MAIN_MODEL,
+          model: resolveMainModel(resolved.model),
           thinking_effort: resolved.thinking_effort ?? SWITCHROOM_DEFAULT_THINKING_EFFORT,
           extends: agentConfig.extends ?? "default",
           topic_name: agentConfig.topic_name,
@@ -66999,6 +67002,16 @@ function registerAgentCommand(program3) {
     printTable(headers, rows, widths);
     console.log();
   }));
+  agent.command("effective-model <name>").description("Print the cascade-resolved model the agent's launcher boots with").action(withConfigError(async (name) => {
+    const config = getConfig(program3);
+    const agentConfig = config.agents[name];
+    if (!agentConfig) {
+      console.error(source_default.red(`Agent "${name}" is not defined in switchroom.yaml`));
+      process.exit(1);
+    }
+    const resolved = resolveAgentConfig(config.defaults, config.profiles, agentConfig);
+    console.log(resolveMainModel(resolved.model));
+  }));
   agent.command("status <name>").description("Show health status for a single agent (PID, polling, Hindsight, last messages)").option("--json", "Output as JSON").action(withConfigError(async (name, opts) => {
     const config = getConfig(program3);
     const agentsDir = resolveAgentsDir(config);

package/dist/host-control/main.js

@@ -26645,7 +26645,7 @@ import { existsSync as existsSync9, readFileSync as readFileSync7 } from "node:f
 import { dirname as dirname4, join as join7 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.18.30";
+var VERSION = "0.18.31";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.18.30",
+  "version": "0.18.31",
   "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/profiles/_base/start.sh.hbs

@@ -1170,15 +1170,92 @@ fi
 # which the gateway relays to the operator chat once at boot. The normal apply
 # path is silent here — the gateway already acked the `/model` in chat.
 #
+# --- Live configured-default resolution (Defect B / drift fix) ---
+#
+# The apply-time bake ({{{modelQ}}}) is only the LAST-DITCH fallback: editing
+# `model:` in switchroom.yaml and restarting must take effect WITHOUT a full
+# `switchroom apply`. The launcher asks the SAME resolver the gateway's
+# /status uses (`switchroom agent effective-model`, which applies
+# resolveMainModel server-side) against the live mounted yaml — one resolver,
+# never re-implemented in shell, so what-you-see and what-runs cannot split.
+#
+# Fallback chain, never silent past step 1:
+#   1. live read of $SWITCHROOM_CONFIG (one bounded retry — a host-side
+#      in-place rewrite can present a torn file for a moment);
+#   2. `.configured-default-model` — the last-known-good live value this
+#      launcher recorded on every prior boot (read BEFORE it is overwritten);
+#   3. the apply-time bake.
+# Steps 2/3 append to `.session-model-alert` so the gateway tells the
+# operator once at boot. No SWITCHROOM_CONFIG mount at all means there is
+# nothing to read live — the bake IS the truth there (stderr note only; an
+# operator alert every boot forever would be noise with no action).
+#
+# The yaml file bind mount re-resolves by PATH at container start, so a
+# host-side atomic-rename write is always picked up by the NEXT boot — the
+# path this block runs on. Only mid-life reads by long-running processes can
+# see a stale inode; that pre-existing edge is out of scope here (tracked as
+# a follow-up on the drift fix).
+#
 # NB {{{modelQ}}} is already shell-single-quoted by the scaffold (it renders as
 # a quoted token, e.g. 'claude-sonnet-5'), so it is assigned BARE here — never
 # inside additional double quotes, which would embed the literal quote chars in
 # the value and break `claude --model`.
-_EFFECTIVE_MODEL={{{modelQ}}}
+_BAKED_MODEL={{{modelQ}}}
+_LKG_MODEL="$(cat "{{agentDir}}/.configured-default-model" 2>/dev/null | tr -d '[:space:]' || true)"
+_EFFECTIVE_MODEL=""
+if [ -n "$SWITCHROOM_CONFIG" ] && [ -f "$SWITCHROOM_CONFIG" ] && command -v switchroom >/dev/null 2>&1; then
+  _lm_live=""
+  for _lm_try in 1 2; do
+    _lm_live="$(timeout 20 switchroom --config "$SWITCHROOM_CONFIG" agent effective-model "{{name}}" 2>/dev/null | tail -n 1 | tr -d '[:space:]')" || _lm_live=""
+    # Shape gate — same regex as the .session-model carrier below (byte-kept
+    # with MODEL_ARG_RE); the tr above already guarantees single-line.
+    if [ -n "$_lm_live" ] && printf '%s' "$_lm_live" | grep -Eq '^[A-Za-z0-9][]A-Za-z0-9._[/-]{0,99}$'; then
+      break
+    fi
+    _lm_live=""
+    if [ "$_lm_try" -eq 1 ]; then sleep 1; fi
+  done
+  if [ -n "$_lm_live" ]; then
+    # Routing class (Claude passthrough vs sr-* router root) is baked into
+    # compose at render time, so a Claude<->sr-* class flip CANNOT be applied
+    # by a bare restart — half-applying would run the new model against the
+    # old routing. Detect the flip, keep the baked model, and tell the
+    # operator to run a real apply.
+    case "$_BAKED_MODEL" in sr-*) _lm_baked_class=router ;; *) _lm_baked_class=claude ;; esac
+    case "$_lm_live" in sr-*) _lm_live_class=router ;; *) _lm_live_class=claude ;; esac
+    if [ "$_lm_live_class" != "$_lm_baked_class" ]; then
+      echo "session-model: configured model class changed ('$_BAKED_MODEL' -> '$_lm_live', $_lm_baked_class -> $_lm_live_class) — routing is render-time, NOT applying; run 'switchroom apply' then restart" >&2
+      printf 'The configured model changed from `%s` to `%s`, which switches routing class — a restart alone cannot apply that. The agent booted on `%s`. Run `switchroom apply` on the host, then restart this agent.\n' "$_BAKED_MODEL" "$_lm_live" "$_BAKED_MODEL" >> "{{agentDir}}/.session-model-alert" 2>/dev/null || true
+      _EFFECTIVE_MODEL="$_BAKED_MODEL"
+    else
+      _EFFECTIVE_MODEL="$_lm_live"
+      if [ "$_lm_live" != "$_BAKED_MODEL" ]; then
+        echo "session-model: live configured model '$_lm_live' differs from apply-time bake '$_BAKED_MODEL' — using the live value (switchroom.yaml is the source of truth)" >&2
+      fi
+    fi
+  elif [ -n "$_LKG_MODEL" ] && printf '%s' "$_LKG_MODEL" | grep -Eq '^[A-Za-z0-9][]A-Za-z0-9._[/-]{0,99}$'; then
+    # Live read failed (torn write mid-read, yaml schema error, CLI wedge).
+    # Last-known-good beats the bake: it was live truth on a prior boot,
+    # while the bake can predate any number of yaml edits. Loud either way —
+    # a silent fallback here would resurrect Defect B as an intermittent flap.
+    _EFFECTIVE_MODEL="$_LKG_MODEL"
+    echo "session-model: live config read FAILED — using last-known-good configured model '$_LKG_MODEL' (apply-time bake: '$_BAKED_MODEL')" >&2
+    printf 'switchroom.yaml could not be read at boot, so the agent booted on the last-known-good configured model `%s`. If you just changed `model:`, check the yaml for errors and restart the agent.\n' "$_LKG_MODEL" >> "{{agentDir}}/.session-model-alert" 2>/dev/null || true
+  else
+    _EFFECTIVE_MODEL="$_BAKED_MODEL"
+    echo "session-model: live config read FAILED and no last-known-good value — using apply-time baked model '$_BAKED_MODEL'" >&2
+    printf 'switchroom.yaml could not be read at boot and no prior boot recorded a model, so the agent booted on the apply-time default `%s`. If you just changed `model:`, check the yaml for errors and restart the agent.\n' "$_BAKED_MODEL" >> "{{agentDir}}/.session-model-alert" 2>/dev/null || true
+  fi
+  unset _lm_live _lm_try _lm_baked_class _lm_live_class
+else
+  _EFFECTIVE_MODEL="$_BAKED_MODEL"
+fi
+unset _BAKED_MODEL _LKG_MODEL
 # Record the RESOLVED configured default (raw, unquoted) every boot, before
 # override resolution. The gateway copies this into the carrier's
 # `configuredDefaultAtWrite`, so both sides of the invalidation compare below
-# come from the same resolver. Overwrite, not consumed.
+# come from the same resolver. Overwrite, not consumed — and doubling as the
+# last-known-good live value the fallback chain above reads on the NEXT boot.
 printf '%s\n' "$_EFFECTIVE_MODEL" > "{{agentDir}}/.configured-default-model" 2>/dev/null || true
 
 # Rev-4 hygiene (#3184 review LOW-2): remove the files retired with the
@@ -1304,6 +1381,26 @@ if [ -f "{{agentDir}}/.session-model" ]; then
   unset _smf _sm_model _sm_cfg _sm_attempts _SM_MAX_ATTEMPTS
 fi
 
+# Configured-default LiteLLM guard. A proxy-only *configured* model with
+# LiteLLM unreachable at boot would exec against the /anthropic passthrough,
+# where `fable`/`claude-fable-5` is a retired codename and EVERY call 4xxs —
+# a total outage. The carrier block above already drops proxy-only OVERRIDES
+# on a down proxy; this extends the same guard to the configured default,
+# which the live-config read above makes a mainline path (pinning `model:
+# fable` in yaml is now the normal way to run Fable). Claude agents have a
+# safe same-class fallback (opus); sr-* configured defaults keep today's
+# loud-degraded behavior — there is no Claude fallback for them and the
+# repoint case below already leaves their routing to self-heal.
+case "$_EFFECTIVE_MODEL" in
+  fable|claude-fable-5)
+    if [ -z "$_LITELLM_OK" ]; then
+      echo "session-model: configured model '$_EFFECTIVE_MODEL' is proxy-only but LiteLLM is unreachable at boot — booting 'opus' until the proxy recovers" >&2
+      printf 'LiteLLM was unreachable at boot, so the configured model `%s` (proxy-only) could not be used — the agent booted on `opus` instead. Restart the agent once the proxy is back to return to `%s`.\n' "$_EFFECTIVE_MODEL" "$_EFFECTIVE_MODEL" >> "{{agentDir}}/.session-model-alert" 2>/dev/null || true
+      _EFFECTIVE_MODEL="opus"
+    fi
+    ;;
+esac
+
 # --- Session effort resolution (consume-once .session-effort carrier, #3186) ---
 #
 # The `/effort` sibling of the block above, session-scoped like /model

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

@@ -37467,6 +37467,26 @@ var init_config_approval_handler = __esm(() => {
   pending = new Map;
 });
 
+// final-answer-detect.ts
+var FINAL_ANSWER_MIN_CHARS2 = 200;
+
+// gateway/turn-flush-suppression.ts
+var exports_turn_flush_suppression = {};
+__export(exports_turn_flush_suppression, {
+  shouldSuppressTurnFlush: () => shouldSuppressTurnFlush,
+  FLUSH_SUPPRESSION_WINDOW_MS: () => FLUSH_SUPPRESSION_WINDOW_MS
+});
+function shouldSuppressTurnFlush(deps, args) {
+  const minChars = Math.max(1, Math.min(FINAL_ANSWER_MIN_CHARS2, args.answerLength));
+  try {
+    return deps.hasSubstantiveOutbound(args.chatId, args.nowMs - FLUSH_SUPPRESSION_WINDOW_MS, args.threadId, minChars);
+  } catch {
+    return false;
+  }
+}
+var FLUSH_SUPPRESSION_WINDOW_MS = 2000;
+var init_turn_flush_suppression = () => {};
+
 // ../src/vault/approvals/client.ts
 function resolveKernelSocketPath2(opts) {
   if (opts?.socket)
@@ -72647,7 +72667,10 @@ var SWITCHROOM_DEFAULT_THINKING_EFFORT = "low";
 function resolveMainModel(model) {
   if (model === undefined || model === "default")
     return SWITCHROOM_DEFAULT_MAIN_MODEL;
-  return model;
+  return normalizeModelAlias(model);
+}
+function normalizeModelAlias(model) {
+  return model === "claude-fable-5" ? "fable" : model;
 }
 var CLAUDE_MD_YOURS_PLACEHOLDER = "This space is yours. Add per-agent rules, exceptions, or context the " + "Switchroom template doesn't capture. Everything above the marker line is " + "regenerated on every apply; this section is preserved.";
 var SWITCHROOM_OWNED_SETTINGS_KEYS = new Set([
@@ -84570,10 +84593,10 @@ function effectiveTurnAgeMs(markerAgeMs, turnStartedAt, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.18.30";
-var COMMIT_SHA = "7729c674";
-var COMMIT_DATE = "2026-07-17T10:52:43+10:00";
-var LATEST_PR = 3293;
+var VERSION = "0.18.31";
+var COMMIT_SHA = "486b55f9";
+var COMMIT_DATE = "2026-07-17T07:36:42Z";
+var LATEST_PR = 3302;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -87157,8 +87180,9 @@ async function deliverAnswer(args) {
     }
   };
   let liveThreadId = args.threadId;
-  const sendChunk = async (_chunkIndex, text5) => {
+  const sendChunk = async (chunkIndex, text5) => {
     const chunkIds = [];
+    const anchor = chunkIndex === 0 && args.replyToMessageId != null ? { reply_parameters: { message_id: args.replyToMessageId, allow_sending_without_reply: true } } : {};
     const res = await sendReplyChunks(deps, {
       chatId,
       chunks: [text5],
@@ -87168,6 +87192,7 @@ async function deliverAnswer(args) {
       previewMessageId: null,
       sentIds: chunkIds,
       buildSendOpts: (_i, _isLast, tid) => ({
+        ...anchor,
         ...tid != null ? { message_thread_id: tid } : {},
         link_preview_options: { is_disabled: true }
       }),
@@ -94408,6 +94433,7 @@ function handleSessionEvent(ev) {
       const turn = currentTurn;
       if (turn == null)
         return;
+      resetAnswerReadyFlushTimeout();
       const ctrl = activeStatusReactions.get(statusKey(turn.sessionChatId, turn.sessionThreadId));
       if (ctrl)
         ctrl.setThinking();
@@ -94812,15 +94838,21 @@ function handleSessionEvent(ev) {
             await new Promise((resolve11) => setTimeout(resolve11, 500));
             if (HISTORY_ENABLED) {
               try {
-                const { getRecentOutboundCount: getRecentOutboundCount2 } = await Promise.resolve().then(() => (init_history(), exports_history));
-                const recentCount = getRecentOutboundCount2(backstopChatId, 2);
-                if (recentCount > 0) {
-                  process.stderr.write(`telegram gateway: turn-flush suppressed \u2014 reply tool sent ${recentCount} message(s) within 2s
+                const { hasOutboundDeliveredSince: hasOutboundDeliveredSince2 } = await Promise.resolve().then(() => (init_history(), exports_history));
+                const { shouldSuppressTurnFlush: shouldSuppressTurnFlush2 } = await Promise.resolve().then(() => (init_turn_flush_suppression(), exports_turn_flush_suppression));
+                const suppress = shouldSuppressTurnFlush2({ hasSubstantiveOutbound: hasOutboundDeliveredSince2 }, {
+                  chatId: backstopChatId,
+                  threadId: backstopThreadId ?? null,
+                  answerLength: capturedText.length,
+                  nowMs: Date.now()
+                });
+                if (suppress) {
+                  process.stderr.write(`telegram gateway: turn-flush suppressed \u2014 a substantive same-thread outbound landed within 2s
 `);
                   if (backstopTurnEndedAt != null) {
                     turn.deliveryOutcome = "suppressed";
                     if (OBLIGATION_LEDGER_ENABLED)
-                      obligationLedger.close(turn.turnId);
+                      obligationLedger.noteTurnEnded(turn.turnId, Date.now());
                     emitTurnRecord(turn, backstopTurnEndedAt);
                   }
                   return;
@@ -94843,7 +94875,8 @@ function handleSessionEvent(ev) {
                 threadId: backstopThreadId,
                 text: capturedText,
                 turnId: turn.turnId,
-                cardMessageId: backstopCardMessageId
+                cardMessageId: backstopCardMessageId,
+                replyToMessageId: turn.sourceMessageId
               });
               sentIds = delivery.sentIds;
               chunkCount = delivery.chunkCount;

package/telegram-plugin/gateway/gateway.ts

@@ -2399,6 +2399,13 @@ async function deliverAnswer(args: {
   text: string
   turnId: string
   cardMessageId: number | null
+  /** S4 (fable red-team 2026-07-17) — the inbound message this turn answers
+   *  (`turn.sourceMessageId`). When present, the FIRST chunk is sent as a
+   *  native quote-reply so the flushed answer anchors to the user's question,
+   *  matching `executeReply`'s default. `allow_sending_without_reply` keeps
+   *  the send alive if the user deleted their message. Null for synthesized
+   *  turns (cron/handback) — those send bare, as before. */
+  replyToMessageId: number | null
 }): Promise<{ sentIds: number[]; chunkCount: number; delivered: boolean; exhausted: boolean }> {
   const { chatId, turnId } = args
   // Inject visible blank-line spacers into `\n\n` gaps, then split — exactly as
@@ -2447,8 +2454,17 @@ async function deliverAnswer(args: {
   // landed message id(s) (a length-resplit chunk may land >1); throws on an
   // unrecoverable send failure so the retry orchestrator can resume.
   let liveThreadId = args.threadId
-  const sendChunk = async (_chunkIndex: number, text: string): Promise<number[]> => {
+  const sendChunk = async (chunkIndex: number, text: string): Promise<number[]> => {
     const chunkIds: number[] = []
+    // S4 — quote-anchor the FIRST chunk only (chunkIndex is the OVERALL chunk
+    // index across the retry orchestrator; each sendReplyChunks call here
+    // carries exactly one chunk, so the inner index is always 0). Mirrors
+    // executeReply's first-chunk-only default. The ledger resumes retries at
+    // the first UNSENT chunk, so chunk 0 keeps its anchor across retries.
+    const anchor =
+      chunkIndex === 0 && args.replyToMessageId != null
+        ? { reply_parameters: { message_id: args.replyToMessageId, allow_sending_without_reply: true } }
+        : {}
     const res = await sendReplyChunks(deps, {
       chatId,
       chunks: [text],
@@ -2458,6 +2474,7 @@ async function deliverAnswer(args: {
       previewMessageId: null,
       sentIds: chunkIds,
       buildSendOpts: (_i, _isLast, tid) => ({
+        ...anchor,
         ...(tid != null ? { message_thread_id: tid } : {}),
         link_preview_options: { is_disabled: true },
       }),
@@ -18097,6 +18114,16 @@ function handleSessionEvent(ev: SessionEvent): void {
       // — read `turn` once, don't re-read currentTurn after any await.
       const turn = currentTurn
       if (turn == null) return
+      // S2 fix (fable red-team 2026-07-17) — a thinking block means the model
+      // is still working, not quiescent. Without this, "prose → >1s thinking
+      // pause → trailing NO_REPLY" let the answer-ready quiescence timer fire
+      // mid-pause and deliver a turn the model was about to mark silent
+      // (#2053 in miniature). Re-arm (not just clear): `reset()` re-verifies
+      // via `decideTurnFlush` and pushes the debounce out by a fresh window,
+      // so the trailing sentinel gets to land before any fire; if no further
+      // text arrives, the flush still fires one window after the LAST
+      // thinking event — the fast path is deferred, never lost.
+      resetAnswerReadyFlushTimeout()
       const ctrl = activeStatusReactions.get(statusKey(turn.sessionChatId, turn.sessionThreadId))
       if (ctrl) ctrl.setThinking()
       return
@@ -19208,10 +19235,28 @@ function handleSessionEvent(ev: SessionEvent): void {
           await new Promise<void>(resolve => setTimeout(resolve, 500))
           if (HISTORY_ENABLED) {
             try {
-              const { getRecentOutboundCount } = await import('../history.js')
-              const recentCount = getRecentOutboundCount(backstopChatId, 2)
-              if (recentCount > 0) {
-                process.stderr.write(`telegram gateway: turn-flush suppressed — reply tool sent ${recentCount} message(s) within 2s\n`)
+              // S1 fix (fable red-team 2026-07-17) — the old predicate here,
+              // `getRecentOutboundCount(chatId, 2) > 0`, counted ANY assistant
+              // row in the WHOLE chat: a worker `progress_update`, a command
+              // ack / restart notice, or a reply in a DIFFERENT forum topic all
+              // suppressed the flush and (worse) CLOSED the obligation below —
+              // silently dropping the user's real answer. The scoped predicate
+              // (same thread, length ≥ min(answerLength, 200)) lives in
+              // `turn-flush-suppression.ts`; `hasOutboundDeliveredSince` is the
+              // durable oracle whose thread/length semantics history tests pin.
+              const { hasOutboundDeliveredSince } = await import('../history.js')
+              const { shouldSuppressTurnFlush } = await import('./turn-flush-suppression.js')
+              const suppress = shouldSuppressTurnFlush(
+                { hasSubstantiveOutbound: hasOutboundDeliveredSince },
+                {
+                  chatId: backstopChatId,
+                  threadId: backstopThreadId ?? null,
+                  answerLength: capturedText.length,
+                  nowMs: Date.now(),
+                },
+              )
+              if (suppress) {
+                process.stderr.write(`telegram gateway: turn-flush suppressed — a substantive same-thread outbound landed within 2s\n`)
                 // Do NOT finalize the status reaction here. As of #1713
                 // the reaction is only finalized by the `turn_end` IPC
                 // handler — mid-turn delivery proofs (local history,
@@ -19223,19 +19268,23 @@ function handleSessionEvent(ev: SessionEvent): void {
                 // here re-fired on an already-cleared key WITHOUT `endingTurn`,
                 // emitting an inconsistent shadow trace. Removed.
                 //
-                // PR B — the reply tool already delivered this turn's answer, so
-                // the flush was legitimately suppressed. Emit the deferred record
-                // as 'suppressed' (→ `complete`, since the reply path set
-                // finalAnswerDelivered). Not a failure.
+                // PR B — a substantive same-thread outbound just delivered this
+                // turn's answer, so the flush was legitimately suppressed. Emit
+                // the deferred record as 'suppressed'. Not a failure.
                 if (backstopTurnEndedAt != null) {
                   turn.deliveryOutcome = 'suppressed'
-                  // #3276 finding 1 — obligation close was DEFERRED out of
-                  // endCurrentTurnAtomic. The reply tool already delivered this
-                  // turn's answer (recentCount>0), so resolve it as satisfied
-                  // here (idempotent with the reply path's own close). Without
-                  // this the deferred obligation would linger OPEN and spuriously
-                  // re-present a turn that WAS answered.
-                  if (OBLIGATION_LEDGER_ENABLED) obligationLedger.close(turn.turnId)
+                  // S1 fix — do NOT close the obligation here. When the recent
+                  // outbound is genuinely this turn's answer (a raced reply /
+                  // stream materialization), the reply path closes its own
+                  // obligation idempotently; when the suppression is a false
+                  // positive (a long same-thread non-answer inside the 2s
+                  // window — the residual the scoped predicate can't
+                  // discriminate), closing here made the drop PERMANENT.
+                  // Leaving it open lets the obligation sweep arbitrate: it
+                  // stands down silently if a substantive outbound answered
+                  // the user, and re-presents otherwise. `noteTurnEnded` arms
+                  // the liveness floor exactly as the send-failed path does.
+                  if (OBLIGATION_LEDGER_ENABLED) obligationLedger.noteTurnEnded(turn.turnId, Date.now())
                   emitTurnRecord(turn, backstopTurnEndedAt)
                 }
                 return
@@ -19283,6 +19332,9 @@ function handleSessionEvent(ev: SessionEvent): void {
               text: capturedText,
               turnId: turn.turnId,
               cardMessageId: backstopCardMessageId,
+              // S4 — anchor the flushed answer to the inbound it answers
+              // (null for synthesized turns, which send bare as before).
+              replyToMessageId: turn.sourceMessageId,
             })
             sentIds = delivery.sentIds
             chunkCount = delivery.chunkCount

package/telegram-plugin/gateway/turn-flush-suppression.ts

@@ -0,0 +1,82 @@
+/**
+ * Turn-flush pre-delivery suppression decision (S1 fix, fable red-team
+ * 2026-07-17 — `~klanker/work/fable-redteam-delivery-20260717/REDTEAM.md`).
+ *
+ * Before the turn-flush backstop posts the captured terminal answer, it asks:
+ * "did a reply already land for this turn in the last ~2s?" (a race guard for
+ * a reply whose IPC signal hadn't registered when `decideTurnFlush` ran, and
+ * for answer-stream materializations that already delivered the answer text).
+ *
+ * The OLD predicate — `getRecentOutboundCount(chatId, 2) > 0` — counted ANY
+ * assistant row in the WHOLE chat: a background worker's `progress_update`, a
+ * command ack / restart notice, or a reply in a DIFFERENT forum topic all
+ * suppressed the flush, and the branch then CLOSED the delivery obligation —
+ * the user's real answer was dropped with no re-present. This module scopes
+ * the predicate to a SUBSTANTIVE (≥ `FINAL_ANSWER_MIN_CHARS`) outbound in the
+ * SAME thread, via the injected `hasSubstantiveOutbound` (the gateway wires
+ * `hasOutboundDeliveredSince`, whose thread/length semantics are pinned by
+ * `history.test.ts`).
+ *
+ * Residual (documented, accepted): a ≥200-char same-thread non-answer outbound
+ * (e.g. an unusually long progress update) inside the 2s window still
+ * suppresses — the history schema has no message-kind column to discriminate
+ * further. That residual is why the CALLER must NOT close the obligation on
+ * suppression: a genuine reply closes its own obligation idempotently, while a
+ * false-positive suppression leaves it open for the liveness floor / sweep.
+ */
+
+import { FINAL_ANSWER_MIN_CHARS } from '../final-answer-detect.js'
+
+/** How far back a just-landed reply can be and still suppress the flush. */
+export const FLUSH_SUPPRESSION_WINDOW_MS = 2000
+
+export interface FlushSuppressionDeps {
+  /** Durable substantive-outbound oracle — the gateway passes
+   *  `hasOutboundDeliveredSince` (thread-scoped, length-floored). */
+  hasSubstantiveOutbound(
+    chatId: string,
+    sinceMs: number,
+    threadId: number | null,
+    minChars: number,
+  ): boolean
+}
+
+export interface FlushSuppressionArgs {
+  chatId: string
+  /** The turn's origin thread. `null` = chat root / DM (matches the
+   *  `hasOutboundDeliveredSince` explicit-null semantics — never pass
+   *  `undefined`, which would match ANY thread and re-open the
+   *  cross-topic false positive this module exists to close). */
+  threadId: number | null
+  /** Length of the captured answer the flush is about to deliver. The
+   *  length floor is `min(FINAL_ANSWER_MIN_CHARS, answerLength)`: a row
+   *  can only suppress the flush if it is at least as long as the answer
+   *  itself (up to the 200-char substantive cap). A TERSE captured answer
+   *  ("Yes — done.") is therefore still suppressible by its own short
+   *  answer-stream materialization (avoiding a duplicate bubble), while a
+   *  short progress ping can never suppress a LONG composed answer. */
+  answerLength: number
+  nowMs: number
+}
+
+/**
+ * True iff the flush should be suppressed: a substantive same-thread outbound
+ * landed within the suppression window. Fails open (no suppression) on oracle
+ * errors — delivering a possible duplicate beats dropping the only copy.
+ */
+export function shouldSuppressTurnFlush(
+  deps: FlushSuppressionDeps,
+  args: FlushSuppressionArgs,
+): boolean {
+  const minChars = Math.max(1, Math.min(FINAL_ANSWER_MIN_CHARS, args.answerLength))
+  try {
+    return deps.hasSubstantiveOutbound(
+      args.chatId,
+      args.nowMs - FLUSH_SUPPRESSION_WINDOW_MS,
+      args.threadId,
+      minChars,
+    )
+  } catch {
+    return false
+  }
+}

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

@@ -0,0 +1,90 @@
+/**
+ * S1 fix (fable red-team 2026-07-17) — turn-flush pre-delivery suppression.
+ *
+ * The old gateway predicate (`getRecentOutboundCount(chatId, 2) > 0`) counted
+ * ANY assistant row in the WHOLE chat, so a worker progress ping, a command
+ * ack, or a reply in a different forum topic suppressed the flush and closed
+ * the obligation — silently dropping the user's real answer. These tests pin
+ * the scoped replacement: the oracle must be asked for a SAME-THREAD row of
+ * substantive length within the 2s window, and oracle failures fail OPEN
+ * (deliver, don't drop). The oracle's own thread/length SQL semantics are
+ * pinned separately in `history.test.ts` (`hasOutboundDeliveredSince`).
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  shouldSuppressTurnFlush,
+  FLUSH_SUPPRESSION_WINDOW_MS,
+} from '../gateway/turn-flush-suppression.js'
+import { FINAL_ANSWER_MIN_CHARS } from '../final-answer-detect.js'
+
+type OracleCall = { chatId: string; sinceMs: number; threadId: number | null; minChars: number }
+
+function capture(result: boolean) {
+  const calls: OracleCall[] = []
+  const deps = {
+    hasSubstantiveOutbound: (chatId: string, sinceMs: number, threadId: number | null, minChars: number) => {
+      calls.push({ chatId, sinceMs, threadId, minChars })
+      return result
+    },
+  }
+  return { calls, deps }
+}
+
+describe('shouldSuppressTurnFlush', () => {
+  it('suppresses iff the oracle finds a substantive same-thread outbound', () => {
+    const yes = capture(true)
+    expect(
+      shouldSuppressTurnFlush(yes.deps, { chatId: '-100', threadId: 7, answerLength: 500, nowMs: 10_000 }),
+    ).toBe(true)
+    const no = capture(false)
+    expect(
+      shouldSuppressTurnFlush(no.deps, { chatId: '-100', threadId: 7, answerLength: 500, nowMs: 10_000 }),
+    ).toBe(false)
+  })
+
+  it('scopes the oracle query to the turn thread and the 2s window', () => {
+    const { calls, deps } = capture(true)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: 7, answerLength: 500, nowMs: 10_000 })
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.chatId).toBe('-100')
+    // Explicit thread id — never `undefined` (undefined would match rows in
+    // ANY topic and re-open the cross-topic false positive).
+    expect(calls[0]!.threadId).toBe(7)
+    expect(calls[0]!.sinceMs).toBe(10_000 - FLUSH_SUPPRESSION_WINDOW_MS)
+  })
+
+  it('passes an explicit null thread for DM / chat-root turns', () => {
+    const { calls, deps } = capture(false)
+    shouldSuppressTurnFlush(deps, { chatId: '55', threadId: null, answerLength: 300, nowMs: 5_000 })
+    expect(calls[0]!.threadId).toBeNull()
+  })
+
+  it('caps the length floor at FINAL_ANSWER_MIN_CHARS for long answers (a short ping can never suppress a long answer)', () => {
+    const { calls, deps } = capture(false)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 5_000, nowMs: 10_000 })
+    expect(calls[0]!.minChars).toBe(FINAL_ANSWER_MIN_CHARS)
+  })
+
+  it('lowers the floor to the answer length for terse answers (their own stream materialization still suppresses a duplicate)', () => {
+    const { calls, deps } = capture(true)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 12, nowMs: 10_000 })
+    expect(calls[0]!.minChars).toBe(12)
+  })
+
+  it('clamps the floor to >= 1 for a degenerate empty answer', () => {
+    const { calls, deps } = capture(false)
+    shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 0, nowMs: 10_000 })
+    expect(calls[0]!.minChars).toBe(1)
+  })
+
+  it('fails open (no suppression) when the oracle throws — deliver beats drop', () => {
+    const deps = {
+      hasSubstantiveOutbound: () => {
+        throw new Error('sqlite unavailable')
+      },
+    }
+    expect(
+      shouldSuppressTurnFlush(deps, { chatId: '-100', threadId: null, answerLength: 300, nowMs: 10_000 }),
+    ).toBe(false)
+  })
+})