switchroom 0.18.25 → 0.18.27

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

@@ -7525,9 +7525,329 @@ var init_approval_card = __esm(() => {
   import_grammy3 = __toESM(require_mod2(), 1);
 });
 
+// render/code-segments.ts
+function findClosingBackticks(text, from, runLen) {
+  let i = from;
+  while (i < text.length) {
+    if (text[i] === "`") {
+      let j = i;
+      while (j < text.length && text[j] === "`")
+        j++;
+      if (j - i === runLen)
+        return j;
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  return -1;
+}
+function splitCodeSegments(text) {
+  const out = [];
+  let i = 0;
+  let plainStart = 0;
+  while (i < text.length) {
+    if (text[i] === "`") {
+      let j = i;
+      while (j < text.length && text[j] === "`")
+        j++;
+      const runLen = j - i;
+      const close = findClosingBackticks(text, j, runLen);
+      if (close !== -1) {
+        if (plainStart < i)
+          out.push({ code: false, text: text.slice(plainStart, i) });
+        out.push({ code: true, text: text.slice(i, close) });
+        i = close;
+        plainStart = close;
+        continue;
+      }
+    }
+    i++;
+  }
+  if (plainStart < text.length)
+    out.push({ code: false, text: text.slice(plainStart) });
+  return out;
+}
+function isTableDelimiterRow(line) {
+  const t = line.trim();
+  return t.length > 0 && /^[\s|:-]+$/.test(t) && t.includes("-") && t.includes("|");
+}
+function isTableCandidateLine(line) {
+  return /^\s*\|/.test(line);
+}
+function findTableRanges(text) {
+  const ranges = [];
+  const lines = text.split(`
+`);
+  let offset = 0;
+  let runStart = -1;
+  let runEnd = -1;
+  let runHasDelim = false;
+  let runLineCount = 0;
+  const flush = () => {
+    if (runStart !== -1 && runLineCount >= 2 && runHasDelim) {
+      ranges.push([runStart, runEnd]);
+    }
+    runStart = -1;
+    runEnd = -1;
+    runHasDelim = false;
+    runLineCount = 0;
+  };
+  for (let k = 0;k < lines.length; k++) {
+    const line = lines[k];
+    const lineLen = line.length + (k < lines.length - 1 ? 1 : 0);
+    if (isTableCandidateLine(line)) {
+      if (runStart === -1)
+        runStart = offset;
+      runEnd = offset + lineLen;
+      runLineCount += 1;
+      if (isTableDelimiterRow(line))
+        runHasDelim = true;
+    } else {
+      flush();
+    }
+    offset += lineLen;
+  }
+  flush();
+  return ranges;
+}
+function splitProseProtected(text) {
+  const out = [];
+  const tables = findTableRanges(text);
+  let tIdx = 0;
+  let i = 0;
+  let plainStart = 0;
+  const pushProtected = (from, to) => {
+    if (plainStart < from)
+      out.push({ code: false, text: text.slice(plainStart, from) });
+    out.push({ code: true, text: text.slice(from, to) });
+    plainStart = to;
+  };
+  while (i < text.length) {
+    while (tIdx < tables.length && tables[tIdx][1] <= i)
+      tIdx++;
+    if (tIdx < tables.length && tables[tIdx][0] === i) {
+      const [, end] = tables[tIdx];
+      pushProtected(i, end);
+      i = end;
+      continue;
+    }
+    const ch = text[i];
+    if (ch === "[") {
+      const close = text.indexOf("]", i + 1);
+      if (close !== -1 && text[close + 1] === "(") {
+        const destClose = text.indexOf(")", close + 2);
+        if (destClose !== -1) {
+          pushProtected(close + 1, destClose + 1);
+          i = destClose + 1;
+          continue;
+        }
+      }
+      i++;
+      continue;
+    }
+    if ((ch === "h" || ch === "w") && (i === 0 || !/[A-Za-z0-9]/.test(text[i - 1]))) {
+      const m = /^(?:https?:\/\/|www\.)[^\s<>()\[\]]+/.exec(text.slice(i));
+      if (m) {
+        const end = i + m[0].length;
+        pushProtected(i, end);
+        i = end;
+        continue;
+      }
+    }
+    i++;
+  }
+  if (plainStart < text.length)
+    out.push({ code: false, text: text.slice(plainStart) });
+  return out;
+}
+function splitProtectedSegments(text) {
+  const out = [];
+  for (const seg of splitCodeSegments(text)) {
+    if (seg.code) {
+      out.push(seg);
+      continue;
+    }
+    for (const sub of splitProseProtected(seg.text))
+      out.push(sub);
+  }
+  return out;
+}
+
+// render/dollar-math-guard.ts
+function guardDollarMath(text) {
+  if (!text.includes("$"))
+    return text;
+  const segments = splitProtectedSegments(text);
+  let total = 0;
+  let hasCurrencySignal = false;
+  for (const seg of segments) {
+    if (seg.code)
+      continue;
+    total += seg.text.match(ANY_DOLLAR)?.length ?? 0;
+    if (!hasCurrencySignal && CURRENCY_SIGNAL.test(seg.text))
+      hasCurrencySignal = true;
+  }
+  if (total < 2 || !hasCurrencySignal)
+    return text;
+  return segments.map((seg) => seg.code ? seg.text : seg.text.replace(UNESCAPED_DOLLAR, () => "\\$")).join("");
+}
+var ANY_DOLLAR, CURRENCY_SIGNAL, UNESCAPED_DOLLAR;
+var init_dollar_math_guard = __esm(() => {
+  ANY_DOLLAR = /\$/g;
+  CURRENCY_SIGNAL = /\$\.?\d|\d\s?\$/;
+  UNESCAPED_DOLLAR = /(?<!\\)\$/g;
+});
+
+// render/emphasis-guard.ts
+function guardAccidentalEmphasis(text) {
+  if (!text.includes("_") && !text.includes("*"))
+    return text;
+  const segments = splitProtectedSegments(text);
+  let hasIntraUnderscore = false;
+  let hasIntraAsterisk = false;
+  let underscoreCount = 0;
+  let asteriskCount = 0;
+  for (const seg of segments) {
+    if (seg.code)
+      continue;
+    if (INTRA_WORD_UNDERSCORE.test(seg.text))
+      hasIntraUnderscore = true;
+    if (INTRA_WORD_ASTERISK.test(seg.text))
+      hasIntraAsterisk = true;
+    underscoreCount += seg.text.match(ANY_UNDERSCORE)?.length ?? 0;
+    asteriskCount += seg.text.match(ANY_ASTERISK)?.length ?? 0;
+  }
+  INTRA_WORD_UNDERSCORE.lastIndex = 0;
+  INTRA_WORD_ASTERISK.lastIndex = 0;
+  const armUnderscore = hasIntraUnderscore && underscoreCount >= 2;
+  const armAsterisk = hasIntraAsterisk && asteriskCount >= 2;
+  if (!armUnderscore && !armAsterisk)
+    return text;
+  return segments.map((seg) => {
+    if (seg.code)
+      return seg.text;
+    let out = seg.text;
+    if (armUnderscore)
+      out = out.replace(INTRA_WORD_UNDERSCORE, "\\_");
+    if (armAsterisk)
+      out = out.replace(INTRA_WORD_ASTERISK, "\\*");
+    return out;
+  }).join("");
+}
+var INTRA_WORD_UNDERSCORE, INTRA_WORD_ASTERISK, ANY_UNDERSCORE, ANY_ASTERISK;
+var init_emphasis_guard = __esm(() => {
+  INTRA_WORD_UNDERSCORE = /(?<=[A-Za-z0-9])_(?=[A-Za-z0-9])/g;
+  INTRA_WORD_ASTERISK = /(?<=[A-Za-z0-9])\*(?=[A-Za-z0-9])/g;
+  ANY_UNDERSCORE = /(?<!\\)_/g;
+  ANY_ASTERISK = /(?<!\\)\*/g;
+});
+
+// render/line-start-guard.ts
+function escapeAccidentalLineStart(line) {
+  const indent = /^ */.exec(line)[0];
+  if (indent.length >= 4)
+    return line;
+  const rest = line.slice(indent.length);
+  if (ACCIDENTAL_BLOCKQUOTE.test(rest)) {
+    return indent + "\\" + rest;
+  }
+  const ol = ACCIDENTAL_ORDERED_LIST.exec(rest);
+  if (ol) {
+    const digits = ol[1];
+    const delim = ol[2];
+    return indent + digits + "\\" + delim + rest.slice(digits.length + 1);
+  }
+  return line;
+}
+function guardAccidentalBlockConstructs(text) {
+  if (!text.includes(">") && !/\d{4,}[.)]/.test(text))
+    return text;
+  const segments = splitProtectedSegments(text);
+  let out = "";
+  let atLineStart = true;
+  for (const seg of segments) {
+    if (seg.code) {
+      out += seg.text;
+      atLineStart = seg.text.endsWith(`
+`);
+      continue;
+    }
+    const lines = seg.text.split(`
+`);
+    for (let k = 0;k < lines.length; k++) {
+      const lineIsAtStart = k === 0 ? atLineStart : true;
+      const processed = lineIsAtStart ? escapeAccidentalLineStart(lines[k]) : lines[k];
+      out += processed;
+      if (k < lines.length - 1)
+        out += `
+`;
+    }
+    atLineStart = seg.text.endsWith(`
+`);
+  }
+  return out;
+}
+var ACCIDENTAL_BLOCKQUOTE, ACCIDENTAL_ORDERED_LIST;
+var init_line_start_guard = __esm(() => {
+  ACCIDENTAL_BLOCKQUOTE = /^>[0-9=]/;
+  ACCIDENTAL_ORDERED_LIST = /^(\d{4,})([.)])(\s|$)/;
+});
+
+// render/inline-pairs-guard.ts
+function countMatches(text, re) {
+  return text.match(re)?.length ?? 0;
+}
+function guardAccidentalInlinePairs(text) {
+  if (!/[~=|]/.test(text))
+    return text;
+  const segments = splitProtectedSegments(text);
+  let tildes = 0;
+  let marks = 0;
+  let spoilers = 0;
+  for (const seg of segments) {
+    if (seg.code)
+      continue;
+    tildes += countMatches(seg.text, TILDE_APPROX);
+    marks += countMatches(seg.text, MARK_OP);
+    spoilers += countMatches(seg.text, SPOILER_OP);
+  }
+  const armTilde = tildes >= 2;
+  const armMark = marks >= 2;
+  const armSpoiler = spoilers >= 2;
+  if (!armTilde && !armMark && !armSpoiler)
+    return text;
+  return segments.map((seg) => {
+    if (seg.code)
+      return seg.text;
+    let out = seg.text;
+    if (armTilde)
+      out = out.replace(TILDE_APPROX, () => "\\~");
+    if (armMark)
+      out = out.replace(MARK_OP, () => "\\=\\=");
+    if (armSpoiler)
+      out = out.replace(SPOILER_OP, () => "\\|\\|");
+    return out;
+  }).join("");
+}
+var TILDE_APPROX, MARK_OP, SPOILER_OP;
+var init_inline_pairs_guard = __esm(() => {
+  TILDE_APPROX = /(?<!\\)~(?=\$?\.?\d)/g;
+  MARK_OP = /(?<=\w)==(?=\w)/g;
+  SPOILER_OP = /(?<=\w)\|\|(?=\w)/g;
+});
+
 // rich-send.ts
+function guardAccidentalFormatting(markdown) {
+  let out = markdown;
+  out = guardAccidentalEmphasis(out);
+  out = guardAccidentalBlockConstructs(out);
+  out = guardAccidentalInlinePairs(out);
+  out = guardDollarMath(out);
+  return out;
+}
 function richMessage(markdown) {
-  return { markdown };
+  return { markdown: guardAccidentalFormatting(markdown) };
 }
 function isParseEntitiesError(err) {
   if (!(err instanceof import_grammy4.GrammyError) || err.error_code !== 400)
@@ -7545,6 +7865,10 @@ function isLengthError(err) {
 }
 var import_grammy4;
 var init_rich_send = __esm(() => {
+  init_dollar_math_guard();
+  init_emphasis_guard();
+  init_line_start_guard();
+  init_inline_pairs_guard();
   import_grammy4 = __toESM(require_mod2(), 1);
 });
 
@@ -39346,6 +39670,13 @@ function decideSupersede(record, args) {
   }
   return { supersede: true, deleteMessageIds: [...record.messageIds], reason: "supersede" };
 }
+function decideSupersedeCorrection(input) {
+  const eligible = input.flushMessageIds.length === 1 && input.chunkCount === 1 && !input.hasFiles && !input.suppressText && !input.hasOpenPreview;
+  if (eligible) {
+    return { mode: "edit-in-place", editMessageId: input.flushMessageIds[0], deleteMessageIds: [] };
+  }
+  return { mode: "delete-resend", deleteMessageIds: [...input.flushMessageIds] };
+}
 var NULL_TURN_KEY = "<<null-turn>>";
 function turnKey(turnId) {
   return turnId == null ? NULL_TURN_KEY : turnId;
@@ -40638,6 +40969,7 @@ function createWorkerActivityFeed(opts) {
   const nowFn = opts.now ?? Date.now;
   const floodWaitRemainingMs = opts.floodWaitRemainingMs ?? (() => 0);
   const minEditInterval = opts.minEditIntervalMs ?? 2500;
+  const elapsedRefreshMs = Math.max(minEditInterval, Math.floor(opts.elapsedRefreshMs ?? 15000));
   const firstPaintMin = opts.firstPaintMinMs ?? 8000;
   const heartbeatTickMs = opts.heartbeatTickMs ?? 6000;
   const maxRows = Math.max(1, Math.floor(opts.maxRows ?? 8));
@@ -40752,6 +41084,35 @@ function createWorkerActivityFeed(opts) {
     });
     return renderCombinedWorkerFeed(rows, { maxRows });
   }
+  function groupSubstanceKey(g, terminalRecap) {
+    const FS = "\x00";
+    const RS = "\x1E";
+    if (terminalRecap != null) {
+      return [
+        "T",
+        terminalRecap.state,
+        terminalRecap.description,
+        terminalRecap.toolCount,
+        terminalRecap.totalTokens ?? "",
+        terminalRecap.latestSummary,
+        ...terminalRecap.narrativeLines ?? []
+      ].join(FS);
+    }
+    const running = runningRows(g);
+    if (running.length === 0)
+      return "EMPTY";
+    return running.map((r) => {
+      const v = r.lastView;
+      return [
+        r.agentId,
+        v.state,
+        v.description,
+        v.toolCount,
+        v.totalTokens ?? "",
+        ...r.narrative
+      ].join(FS);
+    }).join(RS);
+  }
   function removeWorker(g, agentId) {
     g.workers.delete(agentId);
     agentIndex.delete(agentId);
@@ -40801,6 +41162,7 @@ function createWorkerActivityFeed(opts) {
       return;
     }
     const body = renderGroupBody(g, now, opts2.terminalRecap ?? null, opts2.heartbeat ?? false);
+    const substanceKey = groupSubstanceKey(g, opts2.terminalRecap ?? null);
     if (body == null) {
       if (isTerminal)
         clearStaged();
@@ -40824,6 +41186,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = sent.message_id;
         g.messageCreatedAtMs = now;
         g.lastBody = body;
+        g.lastSubstanceKey = substanceKey;
         g.lastEditAt = now;
         g.terminalPainted = false;
         syncPin(g);
@@ -40839,8 +41202,13 @@ function createWorkerActivityFeed(opts) {
         clearStaged();
       return;
     }
-    if (!opts2.force && now - g.lastEditAt < minEditInterval)
-      return;
+    if (!opts2.force && !isTerminal) {
+      if (now - g.lastEditAt < minEditInterval)
+        return;
+      const substanceChanged = substanceKey !== g.lastSubstanceKey;
+      if (!substanceChanged && now - g.lastEditAt < elapsedRefreshMs)
+        return;
+    }
     try {
       const res = await opts.bot.editMessageText(g.chatId, g.messageId, body, sendOptsFor(g));
       if (isSendGateShed(res)) {
@@ -40848,6 +41216,7 @@ function createWorkerActivityFeed(opts) {
         return;
       }
       g.lastBody = body;
+      g.lastSubstanceKey = substanceKey;
       g.lastEditAt = now;
       if (isTerminal) {
         log(`worker-feed: finish feed=${g.feedKey} chat=${g.chatId} thread=${g.threadId ?? "-"} ` + `msgId=${g.messageId} agent=${finishingAgentId ?? "-"} ` + `state=${opts2.terminalRecap?.state ?? "done"} bytes=${body.length}`);
@@ -40865,6 +41234,7 @@ function createWorkerActivityFeed(opts) {
       }
       if (outcome === "not_modified") {
         g.lastBody = body;
+        g.lastSubstanceKey = substanceKey;
         g.lastEditAt = now;
         if (isTerminal)
           clearStaged();
@@ -40874,6 +41244,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = null;
         g.messageCreatedAtMs = 0;
         g.lastBody = null;
+        g.lastSubstanceKey = null;
         if (isTerminal)
           clearStaged();
         else
@@ -40983,6 +41354,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = null;
         g.messageCreatedAtMs = 0;
         g.lastBody = null;
+        g.lastSubstanceKey = null;
         syncPin(g);
         opts.bot.editMessageText(g.chatId, retiredId, WORKER_CARD_SUPERSEDED_BODY, sendOptsFor(g)).catch(() => {});
       }
@@ -41042,6 +41414,7 @@ function createWorkerActivityFeed(opts) {
           messageId: null,
           messageCreatedAtMs: 0,
           lastBody: null,
+          lastSubstanceKey: null,
           lastEditAt: 0,
           cooldownUntil: 0,
           chain: Promise.resolve(),
@@ -41055,6 +41428,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = null;
         g.messageCreatedAtMs = 0;
         g.lastBody = null;
+        g.lastSubstanceKey = null;
         g.pendingFinalize.clear();
         g.terminalPainted = false;
         syncPin(g);
@@ -45869,6 +46243,207 @@ function createTurnTypingLoop(deps) {
   };
 }
 
+// gateway/handback-preturn-signal.ts
+var PRETURN_TURNKEY_PREFIX = "preturn:";
+function isHandbackInbound(msg) {
+  return msg.type === "inbound" && msg.meta?.source === "subagent_handback";
+}
+function createHandbackPreturnSignal(deps) {
+  const now = deps.now ?? (() => Date.now());
+  const debounceMs = deps.debounceMs ?? 700;
+  const adoptTimeoutMs = deps.adoptTimeoutMs ?? 30000;
+  const setTimer = deps.setTimer ?? ((fn, ms) => {
+    const t = setTimeout(fn, ms);
+    t.unref?.();
+    return t;
+  });
+  const clearTimer = deps.clearTimer ?? ((h) => clearTimeout(h));
+  const log = deps.log ?? ((l) => process.stderr.write(l));
+  const byKey = new Map;
+  const bySyntheticKey = new Map;
+  function clearTimers(entry) {
+    if (entry.debounceTimer != null) {
+      clearTimer(entry.debounceTimer);
+      entry.debounceTimer = null;
+    }
+    if (entry.reapTimer != null) {
+      clearTimer(entry.reapTimer);
+      entry.reapTimer = null;
+    }
+  }
+  function dropEntry(entry) {
+    clearTimers(entry);
+    byKey.delete(entry.statusKey);
+    bySyntheticKey.delete(entry.syntheticTurnKey);
+  }
+  function emit(entry) {
+    entry.debounceTimer = null;
+    if (entry.consumed)
+      return;
+    if (deps.isTurnSettled?.(entry.statusKey)) {
+      dropEntry(entry);
+      return;
+    }
+    deps.startTypingLoop(entry.chatId, entry.threadId);
+    entry.emitted = true;
+    entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs);
+    Promise.resolve().then(() => deps.openCard(entry.chatId, entry.threadId)).then((messageId) => {
+      if (messageId == null)
+        return;
+      if (entry.consumed) {
+        deps.finalizeCard({
+          turnKey: entry.syntheticTurnKey,
+          chatId: entry.chatId,
+          threadId: entry.threadId,
+          activityMessageId: messageId,
+          startedAt: entry.startedAt,
+          pinned: entry.pinned
+        });
+        return;
+      }
+      entry.activityMessageId = messageId;
+      const record = {
+        turnKey: entry.syntheticTurnKey,
+        chatId: entry.chatId,
+        threadId: entry.threadId,
+        activityMessageId: messageId,
+        startedAt: entry.startedAt,
+        pinned: entry.pinned
+      };
+      deps.writeCardRecord(record);
+    }).catch((err) => {
+      log(`handback-preturn-signal: openCard failed key=${entry.statusKey}: ` + `${err instanceof Error ? err.message : String(err)}
+`);
+    });
+  }
+  function reap(entry) {
+    entry.reapTimer = null;
+    if (entry.consumed)
+      return;
+    entry.consumed = true;
+    deps.stopTypingLoop(entry.chatId, entry.threadId);
+    if (entry.activityMessageId != null) {
+      const record = {
+        turnKey: entry.syntheticTurnKey,
+        chatId: entry.chatId,
+        threadId: entry.threadId,
+        activityMessageId: entry.activityMessageId,
+        startedAt: entry.startedAt,
+        pinned: entry.pinned
+      };
+      deps.clearCardRecord(entry.syntheticTurnKey, entry.activityMessageId);
+      Promise.resolve(deps.finalizeCard(record)).catch((err) => {
+        log(`handback-preturn-signal: orphan finalize failed key=${entry.statusKey}: ` + `${err instanceof Error ? err.message : String(err)}
+`);
+      });
+    }
+    dropEntry(entry);
+  }
+  return {
+    noteHandbackRelease(inbound) {
+      if (!isHandbackInbound(inbound))
+        return;
+      const chatId = inbound.chatId;
+      if (chatId == null || chatId === "")
+        return;
+      const threadId = inbound.threadId ?? null;
+      const adoptTurnId = deps.deriveTurnId(chatId, threadId, inbound.messageId);
+      if (adoptTurnId == null)
+        return;
+      const statusKey = deps.chatKey(chatId, threadId);
+      if (byKey.has(statusKey))
+        return;
+      const startedAt = now();
+      const syntheticTurnKey = `${PRETURN_TURNKEY_PREFIX}${statusKey}:${startedAt}`;
+      const entry = {
+        statusKey,
+        chatId,
+        threadId,
+        adoptTurnId,
+        syntheticTurnKey,
+        startedAt,
+        pinned: false,
+        debounceTimer: null,
+        reapTimer: null,
+        activityMessageId: null,
+        emitted: false,
+        consumed: false
+      };
+      byKey.set(statusKey, entry);
+      bySyntheticKey.set(syntheticTurnKey, statusKey);
+      entry.debounceTimer = setTimer(() => emit(entry), debounceMs);
+    },
+    tryAdopt(turnId) {
+      let entry;
+      for (const e of byKey.values()) {
+        if (e.adoptTurnId === turnId && !e.consumed) {
+          entry = e;
+          break;
+        }
+      }
+      if (entry == null)
+        return null;
+      entry.consumed = true;
+      clearTimers(entry);
+      const adoption = {
+        statusKey: entry.statusKey,
+        chatId: entry.chatId,
+        threadId: entry.threadId,
+        activityMessageId: entry.activityMessageId,
+        startedAt: entry.startedAt,
+        pinned: entry.pinned
+      };
+      if (entry.activityMessageId != null) {
+        deps.clearCardRecord(entry.syntheticTurnKey, entry.activityMessageId);
+        deps.writeCardRecord({
+          turnKey: entry.statusKey,
+          chatId: entry.chatId,
+          threadId: entry.threadId,
+          activityMessageId: entry.activityMessageId,
+          startedAt: entry.startedAt,
+          pinned: entry.pinned
+        });
+      }
+      dropEntry(entry);
+      return adoption;
+    },
+    isPreTurnRecord(turnKey2) {
+      return turnKey2.startsWith(PRETURN_TURNKEY_PREFIX);
+    },
+    handleReaped(turnKey2) {
+      const statusKey = bySyntheticKey.get(turnKey2);
+      if (statusKey == null)
+        return;
+      const entry = byKey.get(statusKey);
+      if (entry == null)
+        return;
+      entry.consumed = true;
+      deps.stopTypingLoop(entry.chatId, entry.threadId);
+      dropEntry(entry);
+    },
+    pendingCount() {
+      let n = 0;
+      for (const e of byKey.values())
+        if (!e.consumed)
+          n++;
+      return n;
+    },
+    stopAll() {
+      for (const e of [...byKey.values()])
+        clearTimers(e);
+      byKey.clear();
+      bySyntheticKey.clear();
+    }
+  };
+}
+
+// gateway/derive-turn-id.ts
+function deriveTurnId(chatId, threadId, messageId) {
+  if (messageId == null || messageId === "" || String(messageId) === "0")
+    return null;
+  return `${chatKey(chatId, threadId ?? null)}#${messageId}`;
+}
+
 // typing-emitter.ts
 var TYPING_REFRESH_MS = 4000;
 var TYPING_FLOOR_MS = 3500;
@@ -56064,7 +56639,9 @@ var SEND_GATE_DEFAULTS = {
   perChatBurst: 3,
   perGroupPerMin: 18,
   perGroupBurst: 2,
-  editFloorMs: 1500
+  editFloorMs: 1500,
+  perMessageEditWindowMs: 300000,
+  perMessageEditMaxPerWindow: 150
 };
 function createSendGate(config) {
   const enabled2 = config.enabled;
@@ -56076,6 +56653,8 @@ function createSendGate(config) {
   const perGroupPerMin = config.perGroupPerMin ?? SEND_GATE_DEFAULTS.perGroupPerMin;
   const perGroupBurst = config.perGroupBurst ?? SEND_GATE_DEFAULTS.perGroupBurst;
   const editFloorMs = config.editFloorMs ?? SEND_GATE_DEFAULTS.editFloorMs;
+  const perMessageEditWindowMs = Math.max(1, Math.floor(config.perMessageEditWindowMs ?? SEND_GATE_DEFAULTS.perMessageEditWindowMs));
+  const perMessageEditMaxPerWindow = Math.max(0, Math.floor(config.perMessageEditMaxPerWindow ?? SEND_GATE_DEFAULTS.perMessageEditMaxPerWindow));
   const messageStateTtlMs = config.messageStateTtlMs ?? 60000;
   const maxMessageStates = config.maxMessageStates ?? 5000;
   const usefulTtlMs = config.usefulTtlMs ?? 120000;
@@ -56091,7 +56670,8 @@ function createSendGate(config) {
     dropped: 0,
     shed: 0,
     expired: 0,
-    failedFast: 0
+    failedFast: 0,
+    budgetDeferred: 0
   };
   const bootStart = clock.now();
   const globalRamp = config.bootRamp ? {
@@ -56130,7 +56710,8 @@ function createSendGate(config) {
         lastHash: undefined,
         pending: null,
         running: false,
-        suppressedUntilMs: 0
+        suppressedUntilMs: 0,
+        editWindowTs: []
       };
       perMessage.set(key, state);
     }
@@ -56317,7 +56898,20 @@ function createSendGate(config) {
     try {
       while (state.pending) {
         const now = clock.now();
-        const readyAt = Math.max(state.lastSentMs + editFloorMs, state.suppressedUntilMs);
+        let readyAt = Math.max(state.lastSentMs + editFloorMs, state.suppressedUntilMs);
+        if (perMessageEditMaxPerWindow > 0 && state.pending.priorityClass === "cosmetic") {
+          const windowStart = now - perMessageEditWindowMs;
+          while (state.editWindowTs.length > 0 && state.editWindowTs[0] <= windowStart) {
+            state.editWindowTs.shift();
+          }
+          if (state.editWindowTs.length >= perMessageEditMaxPerWindow) {
+            const budgetReadyAt = state.editWindowTs[0] + perMessageEditWindowMs;
+            if (budgetReadyAt > readyAt) {
+              readyAt = budgetReadyAt;
+              counters.budgetDeferred++;
+            }
+          }
+        }
         const waitMs = readyAt - now;
         if (waitMs > 0) {
           await clock.sleep(waitMs);
@@ -56343,6 +56937,12 @@ function createSendGate(config) {
           await admit(bucketsFor(opts));
         }
         state.lastSentMs = clock.now();
+        if (perMessageEditMaxPerWindow > 0 && p.priorityClass === "cosmetic") {
+          state.editWindowTs.push(state.lastSentMs);
+          const overflow = state.editWindowTs.length - (perMessageEditMaxPerWindow + 1);
+          if (overflow > 0)
+            state.editWindowTs.splice(0, overflow);
+        }
         try {
           const res = await p.fn();
           state.lastHash = p.hash;
@@ -56530,6 +57130,12 @@ function sendGateConfigFromEnv(env = process.env) {
   const editFloorMs = parseNonNegativeInt(env.SWITCHROOM_TG_SEND_GATE_EDIT_FLOOR_MS);
   if (editFloorMs !== undefined)
     out.editFloorMs = editFloorMs;
+  const perMsgWindowMs = parsePositiveInt(env.SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_WINDOW_MS);
+  if (perMsgWindowMs !== undefined)
+    out.perMessageEditWindowMs = perMsgWindowMs;
+  const perMsgMax = parseNonNegativeInt(env.SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_MAX);
+  if (perMsgMax !== undefined)
+    out.perMessageEditMaxPerWindow = perMsgMax;
   const conservativeGlobal = parseBoolFlag(env.SWITCHROOM_TG_SEND_GATE_CONSERVATIVE_GLOBAL);
   if (conservativeGlobal !== undefined)
     out.conservativeGlobalFloodScope = conservativeGlobal;
@@ -67710,9 +68316,21 @@ function backOffOpenInline2(text4, cut) {
 }
 
 // rich-send.ts
+init_dollar_math_guard();
+init_emphasis_guard();
+init_line_start_guard();
+init_inline_pairs_guard();
 var import_grammy8 = __toESM(require_mod2(), 1);
+function guardAccidentalFormatting2(markdown) {
+  let out = markdown;
+  out = guardAccidentalEmphasis(out);
+  out = guardAccidentalBlockConstructs(out);
+  out = guardAccidentalInlinePairs(out);
+  out = guardDollarMath(out);
+  return out;
+}
 function richMessage2(markdown) {
-  return { markdown };
+  return { markdown: guardAccidentalFormatting2(markdown) };
 }
 
 // gateway/redelivery-decision.ts
@@ -70565,6 +71183,15 @@ function parseModelCommand(text4) {
 function isModelCommandBusy(ctx) {
   return ctx.currentTurnActive || ctx.turnInFlight;
 }
+function resolveStaleAwareBusy(input) {
+  const turnStale = input.currentTurnActive && input.turnAgeMs !== null && input.turnAgeMs > input.hardTtlMs;
+  const approvalLive = input.oldestPendingApprovalAgeMs !== null && input.oldestPendingApprovalAgeMs <= input.hardTtlMs;
+  return {
+    currentTurnActive: input.currentTurnActive && !turnStale,
+    turnInFlight: input.machineInTurn || approvalLive,
+    clearStaleTurn: turnStale
+  };
+}
 function planModelCommand(parsed, ctx) {
   if (parsed.kind === "show" && ctx.menuEnabled)
     return { kind: "menu" };
@@ -75187,10 +75814,34 @@ function validateMs365Preview(input) {
     out.sizeBytesBefore = o.sizeBytesBefore;
   if (typeof o.sizeBytesAfter === "number")
     out.sizeBytesAfter = o.sizeBytesAfter;
+  if (typeof o.eventWhen === "string")
+    out.eventWhen = o.eventWhen;
+  const changes = sanitizeChanges(o.changes);
+  if (changes)
+    out.changes = changes;
   if (typeof o.agentRationale === "string")
     out.agentRationale = o.agentRationale;
   return out;
 }
+function sanitizeChanges(input) {
+  if (!Array.isArray(input))
+    return;
+  const out = [];
+  for (const raw of input) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const c = raw;
+    if (typeof c.field !== "string" || c.field.length === 0)
+      continue;
+    const entry = { field: c.field };
+    if (typeof c.before === "string")
+      entry.before = c.before;
+    if (typeof c.after === "string")
+      entry.after = c.after;
+    out.push(entry);
+  }
+  return out.length > 0 ? out : undefined;
+}
 var DEFAULT_TTL_MS2 = 5 * 60 * 1000;
 var MAX_TTL_MS2 = 30 * 60 * 1000;
 var MIN_TTL_MS2 = 30 * 1000;
@@ -75215,6 +75866,9 @@ function buildMs365CardText(p) {
     lines.push(`ID:   ${truncate3(p.itemId, 96)}`);
   }
   lines.push(`Account: ${truncate3(p.accountEmail, 96)}`);
+  if (p.eventWhen) {
+    lines.push(`When: ${truncate3(p.eventWhen, 96)}`);
+  }
   if (typeof p.sizeBytesBefore === "number" || typeof p.sizeBytesAfter === "number") {
     const before = p.sizeBytesBefore ?? 0;
     const after = p.sizeBytesAfter ?? 0;
@@ -75225,19 +75879,29 @@ function buildMs365CardText(p) {
   if (p.deepLink) {
     lines.push(`Link: ${truncate3(p.deepLink, 256)}`);
   }
+  if (p.changes && p.changes.length > 0) {
+    lines.push("");
+    lines.push("Changes:");
+    for (const c of p.changes.slice(0, 8)) {
+      const before = c.before !== undefined ? truncate3(c.before, 96) : "(none)";
+      const after = c.after !== undefined ? truncate3(c.after, 96) : "(cleared)";
+      lines.push(`\u2022 ${c.field}: ${before} \u2192 ${after}`);
+    }
+  }
   if (p.agentRationale) {
     lines.push("");
     lines.push(`\uD83D\uDCAC ${truncate3(p.agentRationale, 512)}`);
   }
   lines.push("");
-  lines.push("\u26a0\ufe0f Weak attestation (RFC \u00a78 v1): operator should click through to verify the actual change before approving. Structural diff coming v1.5.");
+  lines.push(p.changes && p.changes.length > 0 ? "\u26a0\ufe0f Attestation (RFC \u00a78 v1.5): the diff above is derived from live Graph state + the mutation payload. Verify before approving." : "\u26a0\ufe0f Weak attestation (RFC \u00a78 v1): operator should click through to verify the actual change before approving. Structural diff coming v1.5.");
   return hardenCardBreaks(lines.join(`
 `));
 }
 function truncate3(s, n) {
-  if (s.length <= n)
-    return s;
-  return s.slice(0, n - 1) + "\u2026";
+  const oneLine = s.replace(/[\r\n\t]+/g, " ");
+  if (oneLine.length <= n)
+    return oneLine;
+  return oneLine.slice(0, n - 1) + "\u2026";
 }
 function humanBytes(bytes) {
   const abs = Math.abs(bytes);
@@ -77828,6 +78492,7 @@ ${result}
     meta: {
       source: "subagent_handback",
       outcome: opts.ctx.outcome,
+      message_id: String(ts),
       ...opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {},
       ...opts.ctx.jsonlAgentId ? { subagent_jsonl_id: opts.ctx.jsonlAgentId } : {}
     }
@@ -79666,6 +80331,7 @@ import {
 } from "node:fs";
 import { join as join39 } from "node:path";
 var TURN_ACTIVE_MARKER_FILE = "turn-active.json";
+var TURN_ACTIVE_HARD_TTL_MS = 10 * 60000;
 function touchTurnActiveMarker(stateDir) {
   const path2 = join39(stateDir, TURN_ACTIVE_MARKER_FILE);
   if (!existsSync34(path2))
@@ -83392,6 +84058,8 @@ import {
 } from "node:fs";
 import { join as join52 } from "node:path";
 var TURN_ACTIVE_MARKER_FILE2 = "turn-active.json";
+var TURN_ACTIVE_HARD_TTL_MS2 = 10 * 60000;
+var TURN_ACTIVE_IDLE_SWEEP_MS = 60000;
 function writeTurnActiveMarker(stateDir, marker) {
   try {
     mkdirSync37(stateDir, { recursive: true });
@@ -83458,12 +84126,15 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
     return null;
   }
 }
+function effectiveTurnAgeMs(markerAgeMs, turnStartedAt, now) {
+  return markerAgeMs ?? now - turnStartedAt;
+}
 
 // ../src/build-info.ts
-var VERSION = "0.18.25";
-var COMMIT_SHA = "01803cff";
-var COMMIT_DATE = "2026-07-15T16:26:26+10:00";
-var LATEST_PR = 3254;
+var VERSION = "0.18.27";
+var COMMIT_SHA = "93871829";
+var COMMIT_DATE = "2026-07-16T01:31:20Z";
+var LATEST_PR = 3273;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -86143,9 +86814,43 @@ var FEED_LIVENESS_OPEN_MS = (() => {
 var POST_ANSWER_LIVENESS_STALE_MS = parsePostAnswerLivenessMs(process.env.SWITCHROOM_POST_ANSWER_LIVENESS_STALE_MS) || 30000;
 function turnInFlightForGate() {
   const hasPendingApproval = pendingPermissions.size > 0;
+  return turnInFlightMachineOnly() || hasPendingApproval;
+}
+function turnInFlightMachineOnly() {
   if (!isDeliveryCutoverEnabled())
-    return claudeBusyKeys.size > 0 || hasPendingApproval;
-  return probeGateParity(isMachineInTurn(), claudeBusyKeys.size) || hasPendingApproval;
+    return claudeBusyKeys.size > 0;
+  return probeGateParity(isMachineInTurn(), claudeBusyKeys.size);
+}
+function liveTurnAgeMs(now) {
+  if (currentTurn === null)
+    return null;
+  return effectiveTurnAgeMs(readTurnActiveMarkerAgeMs(STATE_DIR, now), currentTurn.startedAt, now);
+}
+function oldestPendingApprovalAgeMs(now) {
+  let oldest = null;
+  for (const p of pendingPermissions.values()) {
+    const age = now - p.startedAt;
+    if (oldest === null || age > oldest)
+      oldest = age;
+  }
+  return oldest;
+}
+function resolveModelEffortBusy(now = Date.now()) {
+  const turnAgeMs = liveTurnAgeMs(now);
+  const resolved = resolveStaleAwareBusy({
+    currentTurnActive: currentTurn !== null,
+    turnAgeMs,
+    machineInTurn: turnInFlightMachineOnly(),
+    oldestPendingApprovalAgeMs: oldestPendingApprovalAgeMs(now),
+    hardTtlMs: TURN_ACTIVE_HARD_TTL_MS2
+  });
+  if (resolved.clearStaleTurn && currentTurn !== null) {
+    const ageSec = Math.round((turnAgeMs ?? 0) / 1000);
+    process.stderr.write(`telegram gateway: [phantomturn] cleared stale currentTurn atom age=${ageSec}s ttl=${Math.round(TURN_ACTIVE_HARD_TTL_MS2 / 1000)}s for /model|/effort busy-check agent=${getMyAgentName()}
+`);
+    clearAllCurrentTurns();
+  }
+  return { currentTurnActive: resolved.currentTurnActive, turnInFlight: resolved.turnInFlight };
 }
 function deliverResumeSyntheticOrBuffer(agent, inbound) {
   const decision = decideInboundDelivery({
@@ -86313,11 +87018,6 @@ function findTurnByQuotedMessageId(chatId, replyTo) {
     return null;
   return turn;
 }
-function deriveTurnId(chatId, threadId, messageId) {
-  if (messageId == null || messageId === "" || String(messageId) === "0")
-    return null;
-  return `${chatKey2(chatId, threadId ?? null)}#${messageId}`;
-}
 function findTurnByOriginId(originTurnId) {
   if (originTurnId == null || originTurnId === "")
     return null;
@@ -88143,8 +88843,8 @@ var pendingStateReaper = setInterval(() => {
   try {
     sweepStaleTurnActiveMarker(STATE_DIR, {
       turnInFlight: currentTurn?.registryKey != null,
-      idleSweepMs: 60000,
-      hardTtlMs: 600000,
+      idleSweepMs: TURN_ACTIVE_IDLE_SWEEP_MS,
+      hardTtlMs: TURN_ACTIVE_HARD_TTL_MS2,
       now,
       onRemove: ({ ageMs, reason, payload }) => {
         const agent = getMyAgentName();
@@ -88591,11 +89291,16 @@ async function runMidSessionCardReaper() {
         isLive: (record2) => topicKeys.has(record2.turnKey),
         ttlMs: MID_SESSION_CARD_REAPER_TTL_MS,
         now,
-        finalizeCard: (record2) => robustApiCall(() => lockedBot.api.editMessageText(record2.chatId, record2.activityMessageId, richMessage2(restartOrphanCardFinalizeText(record2.startedAt)), {}), {
-          chat_id: record2.chatId,
-          ...record2.threadId != null ? { threadId: record2.threadId } : {},
-          verb: "activity-card.mid-session-reap-finalize"
-        }),
+        finalizeCard: (record2) => {
+          if (handbackPreturnSignal.isPreTurnRecord(record2.turnKey)) {
+            handbackPreturnSignal.handleReaped(record2.turnKey);
+          }
+          return robustApiCall(() => lockedBot.api.editMessageText(record2.chatId, record2.activityMessageId, richMessage2(restartOrphanCardFinalizeText(record2.startedAt)), {}), {
+            chat_id: record2.chatId,
+            ...record2.threadId != null ? { threadId: record2.threadId } : {},
+            verb: "activity-card.mid-session-reap-finalize"
+          });
+        },
         unpinCard: async (record2) => {
           const pinKey = `fg:${record2.turnKey}`;
           if (statusPinState.has(pinKey)) {
@@ -89075,6 +89780,8 @@ var _deliveryMachineTick = setInterval(() => {
 }, DELIVERY_MACHINE_TICK_MS);
 _deliveryMachineTick.unref?.();
 function trackRedeliveredInbound(merged) {
+  if (HANDBACK_PRETURN_ENABLED)
+    handbackPreturnSignal.noteHandbackRelease(merged);
   if (!DELIVERY_CONFIRM_ENABLED)
     return;
   const isTrackableResume = isTrackableResumeSynthetic(merged.meta);
@@ -90754,6 +91461,7 @@ async function executeReply(args) {
       return { content: [{ type: "text", text: "sent (deduped \u2014 same content sent via earlier path)" }] };
     }
   }
+  let supersedeFlushIds = [];
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     const ownerTurn = resolveReplyOwnerTurn(turn, chat_id, args);
@@ -90762,9 +91470,9 @@ async function executeReply(args) {
     if (decision.supersede) {
       process.stderr.write(`telegram gateway: reply: superseding flushed turn message(s) chatId=${chat_id} ids=${JSON.stringify(decision.deleteMessageIds)}
 `);
-      for (const id of decision.deleteMessageIds) {
-        await swallowingApiCall(() => lockedBot.api.deleteMessage(chat_id, id), { chat_id, verb: "reply.supersedeFlushed" });
-      }
+      supersedeFlushIds = decision.deleteMessageIds;
+      if (ownerTurn != null)
+        ownerTurn.answerDelivered = true;
     } else {
       const replySubstantive = isSubstantiveFinalReply({
         text: rawText,
@@ -90992,6 +91700,25 @@ ${url}`;
       });
     }
   }
+  if (supersedeFlushIds.length > 0) {
+    const correction = decideSupersedeCorrection({
+      flushMessageIds: supersedeFlushIds,
+      chunkCount: chunks.length,
+      hasFiles: files.length > 0,
+      suppressText,
+      hasOpenPreview: previewMessageId != null
+    });
+    if (correction.mode === "edit-in-place") {
+      previewMessageId = correction.editMessageId;
+      reply_to = undefined;
+      process.stderr.write(`telegram gateway: reply: superseding flushed message via edit-in-place chatId=${chat_id} id=${correction.editMessageId}
+`);
+    } else {
+      for (const id of correction.deleteMessageIds) {
+        await swallowingApiCall(() => lockedBot.api.deleteMessage(chat_id, id), { chat_id, verb: "reply.supersedeFlushed" });
+      }
+    }
+  }
   if (previewMessageId != null && reply_to != null && replyMode !== "off") {
     await deleteStalePreview(previewMessageId);
     previewMessageId = null;
@@ -91000,7 +91727,7 @@ ${url}`;
   let silentAnchorEditDone = false;
   {
     const turn2 = currentTurn;
-    if (turn2 != null && chunks.length === 1) {
+    if (turn2 != null && chunks.length === 1 && supersedeFlushIds.length === 0) {
       const decision = decideSilentReplyAnchor({
         effectivelySilent: disableNotification,
         anchorMessageId: turn2.silentAnchorMessageId,
@@ -92815,6 +93542,61 @@ function clearActivitySummary(turn, finalHtmlOverride) {
     }
   });
 }
+var HANDBACK_PRETURN_ENABLED = !STATIC && process.env.SWITCHROOM_HANDBACK_PRETURN !== "0";
+var HANDBACK_PRETURN_HTML = "\uD83E\uDD1D Reading the worker\u2019s results\u2026";
+var HANDBACK_PRETURN_ORPHAN_HTML = "\uD83E\uDD1D A background worker finished, but the handback never started \u2014 it may need a nudge.";
+async function openHandbackPreTurnCard(chatId, threadId) {
+  if (STATIC)
+    return null;
+  try {
+    const sent = await robustApiCall(() => bot.api.sendRichMessage(chatId, richMessage2(HANDBACK_PRETURN_HTML), {
+      ...threadId != null ? { message_thread_id: threadId } : {},
+      disable_notification: true
+    }), {
+      chat_id: chatId,
+      ...threadId != null ? { threadId } : {},
+      verb: "handback-preturn.send"
+    });
+    return sent?.message_id ?? null;
+  } catch (err) {
+    process.stderr.write(`telegram gateway: handback pre-turn card send failed: ${err.message}
+`);
+    return null;
+  }
+}
+function finalizeHandbackPreTurnCard(record2) {
+  return robustApiCall(() => bot.api.editMessageText(record2.chatId, record2.activityMessageId, richMessage2(HANDBACK_PRETURN_ORPHAN_HTML), {}), {
+    chat_id: record2.chatId,
+    ...record2.threadId != null ? { threadId: record2.threadId } : {},
+    verb: "handback-preturn.orphan-finalize"
+  }).then(() => {
+    return;
+  }).catch(() => {
+    return;
+  });
+}
+var handbackPreturnSignal = createHandbackPreturnSignal({
+  chatKey: (chatId, threadId) => chatKey2(chatId, threadId),
+  deriveTurnId: (chatId, threadId, messageId) => deriveTurnId(chatId, threadId, messageId),
+  startTypingLoop: (chatId, threadId) => startTurnTypingLoop(chatId, threadId),
+  stopTypingLoop: (chatId, threadId) => stopTurnTypingLoop(chatId, threadId),
+  openCard: openHandbackPreTurnCard,
+  finalizeCard: finalizeHandbackPreTurnCard,
+  writeCardRecord: (record2) => {
+    if (!activityCardPersistEnabled)
+      return;
+    writeActivityCardRecord(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs, record2);
+  },
+  clearCardRecord: (turnKey2, activityMessageId) => {
+    if (!activityCardPersistEnabled)
+      return;
+    clearActivityCardRecord(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs, turnKey2, activityMessageId);
+  },
+  isTurnSettled: (key) => {
+    const live = currentTurnMap.get(key);
+    return live != null && (live.finalAnswerDelivered || live.endedAt != null);
+  }
+});
 var memoryLegibilityStager = new MemoryLegibilityStager;
 function sendMemoryLegibilityLine(event, chatId, threadId) {
   const line = renderMemoryLegibilityLine(event);
@@ -92968,6 +93750,16 @@ function handleSessionEvent(ev) {
           emissionAuthority: new EmissionAuthority(statusKey(ev.chatId, enqThreadIdNum))
         };
         next.narrativeGate = makeNarrativeGate(next);
+        if (HANDBACK_PRETURN_ENABLED) {
+          const handbackAdoption = handbackPreturnSignal.tryAdopt(turnId);
+          if (handbackAdoption != null) {
+            if (handbackAdoption.activityMessageId != null) {
+              next.activityMessageId = handbackAdoption.activityMessageId;
+              next.activityEverOpened = true;
+            }
+            startTurnTypingLoop(ev.chatId, enqThreadIdNum ?? null);
+          }
+        }
         setCurrentTurn(next, statusKey(ev.chatId, enqThreadIdNum));
         scheduleEarlyLivenessOpen(next);
         process.stderr.write(`telegram gateway: ${formatTurnLifecycle("set", "enqueue", next, startedAt)}
@@ -96014,7 +96806,8 @@ bot.command("model", async (ctx) => {
   const parsed = parseModelCommand(text5) ?? { kind: "show" };
   const chatId = String(ctx.chat.id);
   const threadId = resolveThreadId(chatId, ctx.message?.message_thread_id);
-  const busyNow = currentTurn !== null || turnInFlightForGate();
+  const modelBusy = resolveModelEffortBusy();
+  const busyNow = modelBusy.currentTurnActive || modelBusy.turnInFlight;
   process.stderr.write(modelCommandReceiptLine(getMyAgentName(), parsed, busyNow) + `
 `);
   if (HISTORY_ENABLED && ctx.message?.message_id != null) {
@@ -96035,8 +96828,8 @@ bot.command("model", async (ctx) => {
   }
   const deps = buildModelDeps({ chatId, threadId });
   const disposition = planModelCommand(parsed, {
-    currentTurnActive: currentTurn !== null,
-    turnInFlight: turnInFlightForGate(),
+    currentTurnActive: modelBusy.currentTurnActive,
+    turnInFlight: modelBusy.turnInFlight,
     menuEnabled: process.env.SWITCHROOM_MODEL_MENU !== "0"
   });
   if (disposition.kind === "menu") {
@@ -96107,7 +96900,8 @@ bot.command("effort", async (ctx) => {
     await switchroomReply(ctx, menu.text, { html: true, reply_markup: effortMenuReplyMarkup(menu) });
     return;
   }
-  if ((parsed.kind === "set" || parsed.kind === "default") && currentTurn !== null) {
+  const effortBusy = resolveModelEffortBusy();
+  if ((parsed.kind === "set" || parsed.kind === "default") && effortBusy.currentTurnActive) {
     const requestedLevel = parsed.kind === "set" ? parsed.level : "default";
     const chatId = String(ctx.chat.id);
     const threadId = resolveThreadId(chatId, ctx.message?.message_thread_id);