switchroom 0.14.57 → 0.14.59

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

@@ -23874,7 +23874,7 @@ var init_schema = __esm(() => {
     tier: GoogleWorkspaceTierSchema.optional().describe("RFC G Phase 1: which upstream MCP tier to expose. " + "core (default) = ~16 tools (Drive+Docs+Sheets+Calendar). " + "extended = ~40 tools (+Slides, Forms, Tasks, Chat). " + "complete = ~60+ tools (+Gmail; not recommended yet \u2014 see RFC G \u00a75).")
   }).optional();
   MicrosoftWorkspaceConfigSchema = exports_external.object({
-    microsoft_client_id: exports_external.string().min(1).describe("Microsoft OAuth application (client) ID from Entra portal " + "(literal string or vault reference e.g. " + "'vault:microsoft-oauth-client-id')."),
+    microsoft_client_id: exports_external.string().min(1).optional().describe("Microsoft OAuth application (client) ID from Entra portal " + "(literal string or vault reference e.g. " + "'vault:microsoft-oauth-client-id'). OPTIONAL \u2014 omit it to use " + "switchroom's shipped default Microsoft app (zero-config). " + "Set it only to bring your own Entra app (BYO)."),
     microsoft_client_secret: exports_external.string().min(1).optional().describe("Microsoft OAuth client secret. Optional \u2014 public-client apps " + "(Mobile + Desktop platform with 'Allow public client flows' " + "enabled) work without a secret; confidential clients pass " + "one. Either literal or vault reference e.g. " + "'vault:microsoft-oauth-client-secret'."),
     authority: exports_external.string().url().optional().describe("Microsoft authority endpoint. Defaults to " + "'https://login.microsoftonline.com/common' which accepts both " + "personal MSA and work/school tenants. Override only for " + "single-tenant deployments."),
     org_mode: exports_external.boolean().optional().describe("Opt-in to Teams + SharePoint surfaces (RFC \u00a76.4). When true, " + "the v1 scope set adds Sites.ReadWrite.All AND the launcher " + "spawns softeria with --org-mode. Defaults to false \u2014 personal " + "MSA + standard work surfaces only. Flipping for an existing " + "consented account requires re-running 'auth microsoft account " + "add --replace' to consent the additional scope.")
@@ -32729,7 +32729,7 @@ var MIRROR_MAX_LINES = 6;
 function escapeFeedHtml(s) {
   return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
-function renderActivityFeed(lines, final = false) {
+function renderActivityFeed(lines, final = false, liveSuffix = "") {
   if (lines.length === 0)
     return null;
   const shown = lines.slice(-MIRROR_MAX_LINES);
@@ -32740,7 +32740,7 @@ function renderActivityFeed(lines, final = false) {
   const lastIdx = shown.length - 1;
   shown.forEach((l, i) => {
     const esc = escapeFeedHtml(l);
-    out.push(i === lastIdx && !final ? `<b>\u2192 ${esc}</b>` : `<i>\u2713 ${esc}</i>`);
+    out.push(i === lastIdx && !final ? `<b>\u2192 ${esc}${liveSuffix}</b>` : `<i>\u2713 ${esc}</i>`);
   });
   return out.join(`
 `);
@@ -32748,10 +32748,10 @@ function renderActivityFeed(lines, final = false) {
 var NESTED_MAX_LINES = 4;
 var NESTED_LINE_MAX = 90;
 var NESTED_PREFIX = "   \u21b3 ";
-function renderActivityFeedWithNested(lines, childLines, final = false) {
+function renderActivityFeedWithNested(lines, childLines, final = false, liveSuffix = "") {
   const children = childLines.map((s) => s.trim()).filter((s) => s.length > 0);
   if (children.length === 0)
-    return renderActivityFeed(lines, final);
+    return renderActivityFeed(lines, final, liveSuffix);
   const out = [];
   const shownParent = lines.slice(-MIRROR_MAX_LINES);
   const hiddenParent = lines.length - shownParent.length;
@@ -32767,7 +32767,7 @@ function renderActivityFeedWithNested(lines, childLines, final = false) {
   shownChild.forEach((l, i) => {
     const t = l.length > NESTED_LINE_MAX ? l.slice(0, NESTED_LINE_MAX - 1) + "\u2026" : l;
     const esc = escapeFeedHtml(t);
-    out.push(i === lastChildIdx && !final ? `${NESTED_PREFIX}<b>\u2192 ${esc}</b>` : `${NESTED_PREFIX}<i>${esc}</i>`);
+    out.push(i === lastChildIdx && !final ? `${NESTED_PREFIX}<b>\u2192 ${esc}${liveSuffix}</b>` : `${NESTED_PREFIX}<i>${esc}</i>`);
   });
   return out.length > 0 ? out.join(`
 `) : null;
@@ -39372,6 +39372,13 @@ function isFinalAnswerReply(input) {
     return true;
   return false;
 }
+function isSubstantiveFinalReply(input) {
+  if (input.done === true)
+    return true;
+  if (input.text.length >= FINAL_ANSWER_MIN_CHARS)
+    return true;
+  return false;
+}
 
 // turn-flush-safety.ts
 var SILENT_MARKERS = new Set(["NO_REPLY", "HEARTBEAT_OK"]);
@@ -47125,6 +47132,92 @@ function createPendingInboundBuffer(opts = {}) {
   };
 }
 
+// gateway/obligation-ledger.ts
+class ObligationLedger {
+  maxRepresents;
+  open = new Map;
+  constructor(maxRepresents = 2) {
+    this.maxRepresents = maxRepresents;
+  }
+  openIfAbsent(input) {
+    if (this.open.has(input.originTurnId))
+      return false;
+    this.open.set(input.originTurnId, { ...input, representCount: 0 });
+    return true;
+  }
+  close(originTurnId) {
+    if (originTurnId == null)
+      return false;
+    return this.open.delete(originTurnId);
+  }
+  isOpen(originTurnId) {
+    return this.open.has(originTurnId);
+  }
+  hasOpen() {
+    return this.open.size > 0;
+  }
+  size() {
+    return this.open.size;
+  }
+  list() {
+    return [...this.open.values()].sort((a, b) => a.openedAt - b.openedAt);
+  }
+  oldest() {
+    let best;
+    for (const o of this.open.values()) {
+      if (best === undefined || o.openedAt < best.openedAt)
+        best = o;
+    }
+    return best;
+  }
+  decideAtIdle() {
+    const o = this.oldest();
+    if (o === undefined)
+      return { action: "none" };
+    if (o.representCount >= this.maxRepresents)
+      return { action: "escalate", obligation: o };
+    return { action: "represent", obligation: o };
+  }
+  resolveCloseTarget(echoedTurnId, liveTurnId) {
+    if (echoedTurnId != null)
+      return echoedTurnId;
+    if (liveTurnId != null && this.open.size === 1 && this.open.has(liveTurnId))
+      return liveTurnId;
+    return null;
+  }
+  markRepresented(originTurnId) {
+    const o = this.open.get(originTurnId);
+    if (o === undefined)
+      return 0;
+    o.representCount += 1;
+    return o.representCount;
+  }
+}
+var REPRESENT_PREVIEW_MAX = 200;
+function buildObligationRepresentInbound(o, now) {
+  const preview = o.text.length > REPRESENT_PREVIEW_MAX ? o.text.slice(0, REPRESENT_PREVIEW_MAX - 1) + "\u2026" : o.text;
+  const topicClause = o.threadId != null ? " in this topic" : "";
+  return {
+    type: "inbound",
+    chatId: o.chatId,
+    ...o.threadId != null ? { threadId: o.threadId } : {},
+    messageId: o.messageId,
+    user: "switchroom",
+    userId: 0,
+    ts: now,
+    text: `You have an earlier message${topicClause} that you started but never actually ` + `answered (you may have set it aside mid-work): "${preview}". Answer it now via the ` + `reply tool \u2014 deliver the real answer, don't just acknowledge it. If you've lost the ` + `surrounding context, call get_recent_messages for this chat${topicClause} first. ` + `That quoted text may be only the first ~200 characters of the original.`,
+    meta: {
+      source: "obligation_represent",
+      origin_turn_id: o.originTurnId,
+      represent_count: String(o.representCount + 1)
+    }
+  };
+}
+function obligationEscalationText(o) {
+  const preview = o.text.length > REPRESENT_PREVIEW_MAX ? o.text.slice(0, REPRESENT_PREVIEW_MAX - 1) + "\u2026" : o.text;
+  return `\u26a0\ufe0f I may have missed an earlier message and I'm not sure I answered it: ` + `"${preview}". If you still need it, please re-send.`;
+}
+
 // gateway/inbound-spool.ts
 function spoolId(msg) {
   if (msg.meta?.source === "subagent_handback" && typeof msg.meta?.subagent_jsonl_id === "string" && msg.meta.subagent_jsonl_id.length > 0) {
@@ -47366,6 +47459,28 @@ function shouldArmNoReplyDrain(input) {
   return input.bufferedDepth > 0;
 }
 
+// gateway/feed-reopen-gate.ts
+function shouldReopenFeedAfterAck(input) {
+  if (!input.finalAnswerDelivered)
+    return false;
+  if (input.finalAnswerSubstantive)
+    return false;
+  return input.enabled === true;
+}
+function decideFeedReopen(input) {
+  if (!shouldReopenFeedAfterAck(input)) {
+    return { dropLabel: true };
+  }
+  return {
+    dropLabel: false,
+    reset: {
+      finalAnswerDelivered: false,
+      activityMessageId: null,
+      activityLastSentRender: null
+    }
+  };
+}
+
 // gateway/answer-thread-resolve.ts
 function resolveAnswerThreadId(input) {
   if (input.explicitThreadId != null)
@@ -52195,10 +52310,10 @@ function sweepStaleTurnActiveMarker(stateDir, opts) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.14.57";
-var COMMIT_SHA = "ddb0b353";
-var COMMIT_DATE = "2026-06-03T22:37:37Z";
-var LATEST_PR = 2140;
+var VERSION = "0.14.59";
+var COMMIT_SHA = "178c6d14";
+var COMMIT_DATE = "2026-06-04T07:31:45Z";
+var LATEST_PR = 2146;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -53396,6 +53511,10 @@ var _deliveryTimeoutParsed = _deliveryTimeoutRaw != null && _deliveryTimeoutRaw
 var DELIVERY_CONFIRM_TIMEOUT_MS = Number.isFinite(_deliveryTimeoutParsed) && _deliveryTimeoutParsed > 0 ? _deliveryTimeoutParsed : 15000;
 var DELIVERY_CONFIRM_SWEEP_MS = 5000;
 var deliveryQueue = createDeliveryQueue();
+var OBLIGATION_LEDGER_ENABLED = process.env.SWITCHROOM_OBLIGATION_LEDGER === "1";
+var OBLIGATION_REPRESENT_MAX = 2;
+var OBLIGATION_SWEEP_MS = 5000;
+var obligationLedger = new ObligationLedger(OBLIGATION_REPRESENT_MAX);
 var SERIALIZE_UNTIL_REPLIED_ENABLED = process.env.SWITCHROOM_SERIALIZE_UNTIL_REPLIED !== "0";
 var _noReplyDrainRaw = process.env.SWITCHROOM_SERIALIZE_NOREPLY_DRAIN_MS;
 var _noReplyDrainParsed = _noReplyDrainRaw != null && _noReplyDrainRaw !== "" ? Number(_noReplyDrainRaw) : 2500;
@@ -53403,6 +53522,17 @@ var SERIALIZE_NOREPLY_DRAIN_MS = Number.isFinite(_noReplyDrainParsed) && _noRepl
 var TURN_ORIGIN_ROUTING_ENABLED = process.env.SWITCHROOM_TURN_ORIGIN_ROUTING !== "0";
 var TOPIC_FRAMING_ENABLED = process.env.SWITCHROOM_TOPIC_FRAMING !== "0";
 var QUEUED_STATUS_UX_ENABLED = process.env.SWITCHROOM_QUEUED_STATUS_UX !== "0";
+var FEED_REOPEN_AFTER_ACK_ENABLED = process.env.SWITCHROOM_FEED_REOPEN_AFTER_ACK !== "0";
+var FEED_HEARTBEAT_ENABLED = process.env.SWITCHROOM_FEED_HEARTBEAT !== "0";
+var FEED_HEARTBEAT_TICK_MS = 6000;
+var FEED_HEARTBEAT_MIN_STALE_MS = 6000;
+function formatFeedElapsed(ms) {
+  const s = Math.floor(ms / 1000);
+  if (s < 60)
+    return `${s}s`;
+  const m = Math.floor(s / 60);
+  return `${m}m${(s % 60).toString().padStart(2, "0")}s`;
+}
 function turnInFlightForGate() {
   return isDeliveryCutoverEnabled() ? isMachineInTurn() : claudeBusyKeys.size > 0;
 }
@@ -53443,6 +53573,37 @@ function findTurnByOriginId(originTurnId) {
     return currentTurn;
   return recentTurnsById.get(originTurnId) ?? null;
 }
+function closeObligationOnSubstantiveReply(args, liveTurn) {
+  if (!OBLIGATION_LEDGER_ENABLED)
+    return;
+  const echoed = findTurnByOriginId(args.origin_turn_id);
+  const target = obligationLedger.resolveCloseTarget(echoed?.turnId, liveTurn?.turnId);
+  if (target != null)
+    obligationLedger.close(target);
+}
+function openObligationFromInbound(inboundMsg, gate) {
+  if (!OBLIGATION_LEDGER_ENABLED)
+    return;
+  if (!shouldTrackDelivery({
+    isSteering: gate.isSteering,
+    isInterrupt: gate.isInterrupt,
+    hasSource: inboundMsg.meta?.source != null,
+    effectiveText: gate.effectiveText
+  })) {
+    return;
+  }
+  const oid = deriveTurnId(inboundMsg.chatId, inboundMsg.threadId, inboundMsg.messageId);
+  if (oid == null)
+    return;
+  obligationLedger.openIfAbsent({
+    originTurnId: oid,
+    chatId: inboundMsg.chatId,
+    threadId: inboundMsg.threadId,
+    messageId: inboundMsg.messageId,
+    text: inboundMsg.text ?? "",
+    openedAt: Date.now()
+  });
+}
 function postQueuedStatus(chatId, bufferedThread, inFlightThread) {
   if (!QUEUED_STATUS_UX_ENABLED)
     return;
@@ -54718,6 +54879,40 @@ var inboundSpool = STATIC ? undefined : createInboundSpool({
   }
 });
 var pendingInboundBuffer = createPendingInboundBuffer({ spool: inboundSpool });
+function obligationSweep() {
+  if (!OBLIGATION_LEDGER_ENABLED)
+    return;
+  if (!obligationLedger.hasOpen())
+    return;
+  if (turnInFlightForGate())
+    return;
+  const agent = process.env.SWITCHROOM_AGENT_NAME ?? "";
+  if (pendingInboundBuffer.depth(agent) > 0)
+    return;
+  const decision = obligationLedger.decideAtIdle();
+  const o = decision.obligation;
+  if (decision.action === "none" || o == null)
+    return;
+  if (decision.action === "represent") {
+    pendingInboundBuffer.push(agent, buildObligationRepresentInbound(o, Date.now()));
+    const attempt = obligationLedger.markRepresented(o.originTurnId);
+    process.stderr.write(`telegram gateway: obligation re-presented origin=${o.originTurnId} attempt=${attempt}/${OBLIGATION_REPRESENT_MAX}
+`);
+    return;
+  }
+  obligationLedger.close(o.originTurnId);
+  process.stderr.write(`telegram gateway: obligation escalated (exhausted ${OBLIGATION_REPRESENT_MAX} re-presents) origin=${o.originTurnId}
+`);
+  robustApiCall(() => bot.api.sendMessage(o.chatId, obligationEscalationText(o), {
+    ...o.threadId != null ? { message_thread_id: o.threadId } : {}
+  }), { chat_id: o.chatId, ...o.threadId != null ? { threadId: o.threadId } : {}, verb: "obligation.escalate" }).catch((err) => {
+    process.stderr.write(`telegram gateway: obligation escalation send failed: ${err}
+`);
+  });
+}
+if (!STATIC && OBLIGATION_LEDGER_ENABLED) {
+  setInterval(obligationSweep, OBLIGATION_SWEEP_MS).unref();
+}
 if (bootResumeInbound != null) {
   if (inboundSpool != null) {
     inboundSpool.put(bootResumeInbound.agent, bootResumeInbound.msg);
@@ -55690,6 +55885,12 @@ ${url}`;
             disableNotification
           })) {
             turn2.finalAnswerDelivered = true;
+            turn2.finalAnswerSubstantive = isSubstantiveFinalReply({
+              text: decision.mergedText,
+              disableNotification
+            });
+            if (turn2.finalAnswerSubstantive)
+              closeObligationOnSubstantiveReply(args, turn2);
           }
           outboundDedup.record(chat_id, threadId, decision.mergedText, Date.now(), turn2?.registryKey ?? null);
           silentAnchorEditDone = true;
@@ -55889,7 +56090,10 @@ ${url}`;
     noteSignal(statusKey(chat_id, threadId), Date.now());
     if (turn != null && isFinalAnswerReply({ text: rawText, disableNotification })) {
       turn.finalAnswerDelivered = true;
+      turn.finalAnswerSubstantive = isSubstantiveFinalReply({ text: rawText, disableNotification });
       finalizeStatusReaction(chat_id, threadId, "done");
+      if (turn.finalAnswerSubstantive)
+        closeObligationOnSubstantiveReply(args, turn);
     }
     releaseTurnBufferGate(statusKey(chat_id, threadId), turn ?? undefined);
     if (turn?.finalAnswerDelivered === true) {
@@ -56055,6 +56259,13 @@ async function executeStreamReply(args) {
     done: args.done === true
   })) {
     turn.finalAnswerDelivered = true;
+    turn.finalAnswerSubstantive = isSubstantiveFinalReply({
+      text: args.text ?? "",
+      disableNotification: args.disable_notification === true,
+      done: args.done === true
+    });
+    if (turn.finalAnswerSubstantive)
+      closeObligationOnSubstantiveReply(args, turn);
     const streamThreadIdForClear = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     clearSilentEndState(statusKey(streamChatId, streamThreadIdForClear));
   }
@@ -57046,12 +57257,12 @@ function closeProgressLane(chatId, threadId) {
   }
 }
 var FOREGROUND_SUBAGENT_ACCUM_MAX = 12;
-function composeTurnActivity(turn, final = false) {
+function composeTurnActivity(turn, final = false, liveSuffix = "") {
   const childLines = [];
   for (const narrative of turn.foregroundSubAgents.values()) {
     childLines.push(...narrative);
   }
-  return renderActivityFeedWithNested(turn.mirrorLines, childLines, final);
+  return renderActivityFeedWithNested(turn.mirrorLines, childLines, final, liveSuffix);
 }
 async function drainActivitySummary(turn) {
   try {
@@ -57090,6 +57301,30 @@ async function drainActivitySummary(turn) {
     turn.activityInFlight = null;
   }
 }
+function feedHeartbeatTick() {
+  const turn = currentTurn;
+  if (turn == null)
+    return;
+  if (turn.activityMessageId == null)
+    return;
+  if (turn.finalAnswerDelivered)
+    return;
+  if (turn.lastToolLabelAt == null)
+    return;
+  const elapsed = Date.now() - turn.lastToolLabelAt;
+  if (elapsed < FEED_HEARTBEAT_MIN_STALE_MS)
+    return;
+  const rendered = composeTurnActivity(turn, false, ` \xB7 ${formatFeedElapsed(elapsed)}`);
+  if (rendered == null)
+    return;
+  turn.activityPendingRender = rendered;
+  if (turn.activityInFlight == null) {
+    turn.activityInFlight = drainActivitySummary(turn);
+  }
+}
+if (!STATIC && FEED_HEARTBEAT_ENABLED) {
+  setInterval(feedHeartbeatTick, FEED_HEARTBEAT_TICK_MS).unref();
+}
 function clearActivitySummary(turn, finalHtmlOverride) {
   const chat = turn.sessionChatId;
   const thread = turn.sessionThreadId;
@@ -57148,6 +57383,7 @@ function handleSessionEvent(ev) {
           gatewayReceiveAt: startedAt,
           replyCalled: false,
           finalAnswerDelivered: false,
+          finalAnswerSubstantive: false,
           firstPingAt: null,
           silentAnchorMessageId: null,
           silentAnchorText: "",
@@ -57259,10 +57495,21 @@ function handleSessionEvent(ev) {
         return;
       if (isTelegramSurfaceTool(ev.toolName))
         return;
-      if (turn.finalAnswerDelivered)
-        return;
+      if (turn.finalAnswerDelivered) {
+        const reopen = decideFeedReopen({
+          finalAnswerDelivered: turn.finalAnswerDelivered,
+          finalAnswerSubstantive: turn.finalAnswerSubstantive,
+          enabled: FEED_REOPEN_AFTER_ACK_ENABLED
+        });
+        if (reopen.dropLabel)
+          return;
+        turn.finalAnswerDelivered = reopen.reset.finalAnswerDelivered;
+        turn.activityMessageId = reopen.reset.activityMessageId;
+        turn.activityLastSentRender = reopen.reset.activityLastSentRender;
+      }
       const rendered = appendActivityLabel(turn.mirrorLines, ev.label);
       if (rendered != null) {
+        turn.lastToolLabelAt = Date.now();
         turn.activityPendingRender = composeTurnActivity(turn) ?? rendered;
         if (turn.activityInFlight == null) {
           turn.activityInFlight = drainActivitySummary(turn);
@@ -57412,6 +57659,7 @@ function handleSessionEvent(ev) {
           turn.answerStream = null;
           streamFinalizedAsAnswer = true;
           turn.finalAnswerDelivered = true;
+          turn.finalAnswerSubstantive = true;
           const oldStreamedMsgId = streamedMsgId;
           (async () => {
             let materializedId;
@@ -57538,6 +57786,7 @@ function handleSessionEvent(ev) {
           }
         }
         turn.finalAnswerDelivered = true;
+        turn.finalAnswerSubstantive = true;
         const cardTakeover = progressDriver?.takeOverCard({
           chatId: backstopChatId,
           threadId: backstopThreadId != null ? String(backstopThreadId) : undefined
@@ -58585,6 +58834,11 @@ ${preBlock(write.output)}`;
     }
     return;
   }
+  openObligationFromInbound(inboundMsg, {
+    isSteering,
+    isInterrupt: interrupt.isInterrupt,
+    effectiveText
+  });
   if (decideInboundDelivery({
     turnInFlight: turnInFlightAtReceipt,
     isSteering,

package/telegram-plugin/final-answer-detect.ts

@@ -81,3 +81,37 @@ export function isFinalAnswerReply(input: FinalAnswerReplyInput): boolean {
   if (input.text.length >= FINAL_ANSWER_MIN_CHARS) return true
   return false
 }
+
+/**
+ * Pure predicate: was this reply a *substantive* final answer (as opposed
+ * to a reply that is only "final" because it pinged)? `true` if EITHER:
+ *
+ *   - `done === true` — a `stream_reply` terminal call closing the stream.
+ *   - `text.length >= FINAL_ANSWER_MIN_CHARS` — a substantive-length answer.
+ *
+ * This is `isFinalAnswerReply` MINUS the notification-only path. The
+ * distinction matters for the feed-reopen-after-ack gate
+ * (`feed-reopen-gate.ts`): a *short pinging* reply ("on it, checking
+ * Brevo…") is classified final by `isFinalAnswerReply` (because it pings)
+ * yet is NOT substantive — it is an interim ACK. Only such an ack should
+ * cause the live activity feed to re-open when post-ack tool work arrives.
+ *
+ * A genuine final answer (long, or a stream `done: true`) followed by
+ * routine post-answer housekeeping (a memory write / TodoWrite / Bash —
+ * none of which are surface tools, so they reach the tool_label handler)
+ * must NOT re-open the feed and must NOT reset `finalAnswerDelivered`,
+ * otherwise the silent-end re-prompt would spuriously fire and the agent
+ * would re-deliver a duplicate / garbled answer.
+ *
+ * Residual: a reply that is genuinely the final answer yet is BOTH short
+ * (<200 chars) AND pinging (e.g. "Done!") is indistinguishable here from
+ * an ack, so post-answer housekeeping after it still re-opens the feed.
+ * That is much rarer than the housekeeping-after-long-answer case this
+ * predicate protects, and is kill-switchable via
+ * `SWITCHROOM_FEED_REOPEN_AFTER_ACK=0`.
+ */
+export function isSubstantiveFinalReply(input: FinalAnswerReplyInput): boolean {
+  if (input.done === true) return true
+  if (input.text.length >= FINAL_ANSWER_MIN_CHARS) return true
+  return false
+}

package/telegram-plugin/gateway/feed-reopen-gate.ts

@@ -0,0 +1,162 @@
+/**
+ * Feed-reopen-after-ack gate (ack-first live-activity visibility).
+ *
+ * Pure decision: a `tool_label` arrived (the model is calling a tool, i.e.
+ * still WORKING) for a turn that has already been classified as having
+ * delivered its final answer. Should the gateway *re-open* the live
+ * activity feed for the post-ack work?
+ *
+ * ## The bug this closes
+ *
+ * In a forum supergroup one agent owns the whole supergroup — a single
+ * sequential `claude` CLI with a singleton `currentTurn`. When the model
+ * ACKS FIRST ("on it, checking Brevo…") and then does the actual work,
+ * that ack reply is classified as the *final answer* by
+ * `isFinalAnswerReply` (final-answer-detect.ts) whenever it pings
+ * (`!disable_notification`) OR is ≥200 chars — both common for a natural
+ * human-feel ack. That sets `turn.finalAnswerDelivered = true`, and the
+ * `tool_label` handler's `if (turn.finalAnswerDelivered) return` then
+ * drops EVERY subsequent tool label → the live feed goes dark for the
+ * real work. The agent looks silent after "On it".
+ *
+ * ## The decision
+ *
+ * A new tool label after `finalAnswerDelivered` means the earlier "final"
+ * reply MIGHT have been an interim ACK — the turn has NOT delivered its
+ * final answer if it is still doing tool work. So reclassify: re-open the
+ * feed. The caller then resets `turn.finalAnswerDelivered = false` and
+ * `turn.activityMessageId = null` (so a FRESH feed message opens below the
+ * ack) and proceeds with the normal append + drain. When the model later
+ * sends its REAL final answer, `executeReply` / `stream_reply` re-set
+ * `finalAnswerDelivered = true` via `isFinalAnswerReply` and the feed gates
+ * off correctly again.
+ *
+ * ## ACK-ONLY refinement
+ *
+ * `finalAnswerDelivered` latches true for BOTH a short pinging ack AND a
+ * substantive final answer — `isFinalAnswerReply` treats any pinging reply
+ * as "final". So reopening unconditionally is HARMFUL after a *genuine*
+ * final answer: routine post-answer housekeeping (a memory write /
+ * TodoWrite / Bash — none of these are surface tools, so they reach the
+ * tool_label handler) fires a tool label → an unconditional reopen would
+ * reset `finalAnswerDelivered=false` → the turn-end silent-end re-prompt
+ * (`if (turn.finalAnswerDelivered === false)`, NOT gated on zero-outbound)
+ * would FIRE → the agent re-delivers a DUPLICATE / garbled answer. Agents
+ * routinely write memory after answering, so this would be frequent.
+ *
+ * The fix: reopen ONLY when the prior reply that set `finalAnswerDelivered`
+ * was a SHORT ACK, not a substantive answer. The caller tracks this on the
+ * turn as `finalAnswerSubstantive` (set via `isSubstantiveFinalReply` at
+ * every site that sets `finalAnswerDelivered = true`). Reopen iff
+ * `finalAnswerDelivered && !finalAnswerSubstantive`. When the prior final
+ * was substantive, drop the label (legacy gate) — no reopen, no reset — so
+ * the silent-end re-prompt and the #2137 drain both see the genuine final
+ * correctly.
+ *
+ * ## Interactions (the reset is correct for all three consumers)
+ *
+ *  1. #2137 deliver-before-drain gate (`mayDrainBufferedInbound`): reads the
+ *     ending turn's `finalAnswerDelivered` at turn-end. With the reset, an
+ *     ack-first turn that is still working keeps it false → the next topic
+ *     is correctly HELD (no mid-work cross-topic bleed); the bounded
+ *     no-reply drain timer (~2.5s) still releases the queue if the turn
+ *     truly ends without a final answer.
+ *  2. silent-end re-prompt: a turn that acks, works, then ends with NO real
+ *     final answer keeps `finalAnswerDelivered=false` → the re-prompt fires
+ *     (correct — the user got only an ack, no answer).
+ *  3. the feed gate itself — this module.
+ *
+ * ## Kill switch
+ *
+ * `SWITCHROOM_FEED_REOPEN_AFTER_ACK=0` reverts to the legacy behaviour: a
+ * tool label after `finalAnswerDelivered` is dropped (`return`), and the
+ * post-ack feed stays dark. The kill switch is read by the CALLER, which
+ * passes `enabled` here.
+ */
+
+export interface FeedReopenInput {
+  /** Whether the turn has already been classified as having delivered its
+   *  final answer (`turn.finalAnswerDelivered`). On an ack-first turn this
+   *  is set true by the ack reply (it pinged or was ≥200 chars), even
+   *  though the model is still working. */
+  finalAnswerDelivered: boolean
+  /** Whether the reply that set `finalAnswerDelivered` was a *substantive*
+   *  final answer (stream `done`, or ≥200 chars) as opposed to a short
+   *  pinging interim ACK (`turn.finalAnswerSubstantive`, set via
+   *  `isSubstantiveFinalReply`). Only a short ACK should re-open the feed:
+   *  reopening after a genuine final answer + post-answer housekeeping
+   *  would spuriously trip the silent-end re-prompt → duplicate answer. */
+  finalAnswerSubstantive: boolean
+  /** Kill-switch state. When false the reopen behaviour is OFF and a tool
+   *  label after `finalAnswerDelivered` is dropped (legacy). */
+  enabled: boolean
+}
+
+/**
+ * Pure. Given a tool label has just arrived (the model is calling a tool,
+ * so it is still working), returns true when the live activity feed should
+ * be RE-OPENED for the post-ack work.
+ *
+ * - !finalAnswerDelivered → false: the feed was never gated off; the normal
+ *   append/drain path applies (no reopen needed).
+ * - finalAnswerDelivered && finalAnswerSubstantive → false: the prior final
+ *   was a genuine answer (not an ack). Post-answer housekeeping tool work
+ *   must NOT reopen — keep the legacy gate so the silent-end re-prompt and
+ *   the #2137 drain see the delivered final correctly.
+ * - finalAnswerDelivered && !enabled (kill switch off) → false: legacy
+ *   behaviour, the label is dropped by the caller.
+ * - finalAnswerDelivered && !finalAnswerSubstantive && enabled → true: the
+ *   "final" reply was a short interim ack; re-open the feed.
+ */
+export function shouldReopenFeedAfterAck(input: FeedReopenInput): boolean {
+  if (!input.finalAnswerDelivered) return false
+  if (input.finalAnswerSubstantive) return false
+  return input.enabled === true
+}
+
+/** The feed-state fields the caller mutates on reopen. */
+export interface FeedReopenState {
+  finalAnswerDelivered: boolean
+  activityMessageId: number | null
+  activityLastSentRender: string | null
+}
+
+/** The branch outcome the tool_label handler takes for a finalAnswer-
+ *  delivered turn: either drop the label (legacy `return`) or reopen the
+ *  feed with the given reset state. */
+export interface FeedReopenOutcome {
+  /** True → the handler returns early (legacy: label dropped, feed dark). */
+  dropLabel: boolean
+  /** When dropLabel is false, the new feed-state fields to write on `turn`
+   *  before the normal append/drain proceeds. */
+  reset?: FeedReopenState
+}
+
+/**
+ * Pure. The complete tool_label decision for a turn already marked
+ * finalAnswerDelivered. Mirrors exactly what the gateway handler does:
+ *  - reopen disabled / substantive final / not applicable → drop the label
+ *    (legacy `return`); the genuine final answer's gate is preserved.
+ *  - reopen → reclassify the interim ack: finalAnswerDelivered back to
+ *    false (the turn has NOT delivered its final answer while still doing
+ *    tool work), activityMessageId cleared so a FRESH feed message opens
+ *    below the ack, and activityLastSentRender cleared so the drain loop's
+ *    `pending !== lastSent` guard never mistakes the fresh render for an
+ *    already-sent one.
+ *
+ * Returning the deltas (rather than mutating) keeps the decision unit-
+ * testable; the handler applies them to the live `turn` atom.
+ */
+export function decideFeedReopen(input: FeedReopenInput): FeedReopenOutcome {
+  if (!shouldReopenFeedAfterAck(input)) {
+    return { dropLabel: true }
+  }
+  return {
+    dropLabel: false,
+    reset: {
+      finalAnswerDelivered: false,
+      activityMessageId: null,
+      activityLastSentRender: null,
+    },
+  }
+}