switchroom 0.20.3 → 0.20.5

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

@@ -65060,6 +65060,9 @@ var EDIT_FLOOD_FUSE_DEFAULTS = {
   perChatSendMaxPerWindow: 25,
   cosmeticPerMessageMaxPerWindow: 4,
   cosmeticPerChatMaxPerWindow: 6,
+  cosmeticFloorPerWindow: 2,
+  cosmeticFloorSlots: 2,
+  throttleNoticeMs: 45000,
   perChatTotalMaxPerWindow: 20,
   perChatReplyReserve: 8,
   perChatCriticalMinPerWindow: 3,
@@ -65094,6 +65097,11 @@ function editFloodFuseConfigFromEnv(env) {
   };
   assign("cosmeticPerMessageMaxPerWindow", envInt(env.SWITCHROOM_FEED_EDIT_MAX_PER_MSG_PER_MIN));
   assign("cosmeticPerChatMaxPerWindow", envInt(env.SWITCHROOM_FEED_EDIT_MAX_PER_CHAT_PER_MIN));
+  if (env.SWITCHROOM_FEED_FAIR_SHARE === "0")
+    cfg.cosmeticFairShareEnabled = false;
+  assign("cosmeticFloorPerWindow", envInt(env.SWITCHROOM_FEED_EDIT_FLOOR_PER_MSG_PER_MIN));
+  assign("cosmeticFloorSlots", envInt(env.SWITCHROOM_FEED_EDIT_FLOOR_SLOTS));
+  assign("throttleNoticeMs", envInt(env.SWITCHROOM_FEED_THROTTLE_NOTICE_MS));
   assign("perChatTotalMaxPerWindow", envInt(env.SWITCHROOM_CHAT_TOTAL_MAX_PER_MIN));
   assign("perChatReplyReserve", envInt(env.SWITCHROOM_CHAT_REPLY_RESERVE));
   assign("perChatCriticalMinPerWindow", envInt(env.SWITCHROOM_CHAT_CRITICAL_MIN_PER_MIN));
@@ -65118,6 +65126,11 @@ function createEditFloodFuse(config = {}) {
   const perChatSendMax = config.perChatSendMaxPerWindow ?? D.perChatSendMaxPerWindow;
   const cosmeticPerMessageMax = Math.min(perMessageMax, config.cosmeticPerMessageMaxPerWindow ?? D.cosmeticPerMessageMaxPerWindow);
   const cosmeticPerChatMax = Math.min(perChatEditMax, config.cosmeticPerChatMaxPerWindow ?? D.cosmeticPerChatMaxPerWindow);
+  const cosmeticFairShareEnabled = config.cosmeticFairShareEnabled ?? true;
+  const cosmeticFloorPerWindow = Math.min(cosmeticPerMessageMax, Math.max(0, config.cosmeticFloorPerWindow ?? D.cosmeticFloorPerWindow));
+  const cosmeticFloorAggMax = Math.min(cosmeticPerChatMax, cosmeticFloorPerWindow * Math.max(0, config.cosmeticFloorSlots ?? D.cosmeticFloorSlots));
+  const cosmeticRemainderMax = Math.max(0, cosmeticPerChatMax - cosmeticFloorAggMax);
+  const throttleNoticeMs = Math.max(0, config.throttleNoticeMs ?? D.throttleNoticeMs);
   const perChatTotalMax = config.perChatTotalMaxPerWindow ?? D.perChatTotalMaxPerWindow;
   const perChatWindowMs = config.perChatWindowMs ?? D.perChatWindowMs;
   const perChatReplyReserve = Math.min(Math.max(0, config.perChatReplyReserve ?? D.perChatReplyReserve), Math.max(0, perChatTotalMax - 1));
@@ -65142,7 +65155,8 @@ function createEditFloodFuse(config = {}) {
     superseded: 0,
     floodObserved: 0,
     meteredByDefault: 0,
-    chatless: 0
+    chatless: 0,
+    throttled: 0
   };
   let tightenLevel = 0;
   let tightenedUntil = 0;
@@ -65189,6 +65203,12 @@ function createEditFloodFuse(config = {}) {
       return eff;
     return Math.max(eff, Math.min(base, perChatCriticalMin));
   }
+  function cosmeticMessageCeiling(now) {
+    const eff = ceiling(cosmeticPerMessageMax, now);
+    if (!cosmeticFairShareEnabled)
+      return eff;
+    return Math.max(eff, Math.min(cosmeticPerMessageMax, cosmeticFloorPerWindow));
+  }
   function cosmeticTotalMax(now) {
     const eff = ceiling(perChatTotalMax, now);
     if (replyReserveFraction <= 0)
@@ -65281,9 +65301,87 @@ function createEditFloodFuse(config = {}) {
     if (i >= 0)
       w.ts.splice(i, 1);
   }
+  function makeThrottleNotice(method, key, cls) {
+    if (!cosmeticFairShareEnabled || cls !== "cosmetic" || throttleNoticeMs <= 0) {
+      return { tick: () => {}, sleepCap: () => Number.POSITIVE_INFINITY };
+    }
+    let firstAt = Number.NaN;
+    let fired = false;
+    return {
+      tick: (now) => {
+        if (Number.isNaN(firstAt))
+          firstAt = now;
+        if (fired || now - firstAt < throttleNoticeMs)
+          return;
+        fired = true;
+        counters.throttled++;
+        onTrip?.({ method, key, action: "throttled", cls });
+      },
+      sleepCap: (now) => {
+        if (fired || Number.isNaN(firstAt))
+          return Number.POSITIVE_INFINITY;
+        return Math.max(1, firstAt + throttleNoticeMs - now);
+      }
+    };
+  }
+  async function awaitCosmeticChatFair(chat, msg, method, cls, dropGuard, deadline, lateReleaseKey) {
+    const fMsgKey = `cmf:${chat}:${msg}`;
+    const fAggKey = `cfa:${chat}`;
+    const remKey = `cer:${chat}`;
+    const fw = win(fMsgKey);
+    const aw = win(fAggKey);
+    const rw = win(remKey);
+    let counted = false;
+    const throttle = makeThrottleNotice(method, remKey, cls);
+    for (;; ) {
+      const now = clock.now();
+      const wFloor = Math.max(waitFor(fw, now, perChatWindowMs, cosmeticFloorPerWindow), waitFor(aw, now, perChatWindowMs, cosmeticFloorAggMax));
+      const remCap = cosmeticRemainderMax <= 0 ? 0 : ceiling(cosmeticRemainderMax, now);
+      const wRem = waitFor(rw, now, perChatWindowMs, remCap);
+      if (wFloor === 0) {
+        fw.ts.push(now);
+        aw.ts.push(now);
+        return [[fMsgKey, now], [fAggKey, now]];
+      }
+      if (remCap > 0 && wRem === 0) {
+        rw.ts.push(now);
+        return [[remKey, now]];
+      }
+      if (now >= deadline) {
+        if (dropGuard()) {
+          counters.dropped++;
+          onTrip?.({ method, key: remKey, action: "dropped", cls });
+          return null;
+        }
+        const lw = win(lateReleaseKey);
+        prune(lw, now, perChatWindowMs);
+        if (lw.ts.length >= ceiling(lateReleaseMax, now)) {
+          counters.dropped++;
+          onTrip?.({ method, key: remKey, action: "dropped", cls });
+          return null;
+        }
+        lw.ts.push(now);
+        if (cosmeticRemainderMax > 0) {
+          rw.ts.push(now);
+          return [[remKey, now]];
+        }
+        fw.ts.push(now);
+        aw.ts.push(now);
+        return [[fMsgKey, now], [fAggKey, now]];
+      }
+      if (!counted) {
+        counters.deferred++;
+        counted = true;
+        onTrip?.({ method, key: remKey, action: "deferred", cls });
+      }
+      throttle.tick(now);
+      await clock.sleep(Math.min(Math.min(wFloor, wRem), deadline - now, throttle.sleepCap(now)));
+    }
+  }
   async function awaitRoom(key, windowMs, maxFor, method, mode, cls, dropGuard, deadline, lateReleaseKey) {
     const w = win(key);
     let counted = false;
+    const throttle = makeThrottleNotice(method, key, cls);
     for (;; ) {
       const now = clock.now();
       const wait = waitFor(w, now, windowMs, maxFor(now));
@@ -65315,6 +65413,8 @@ function createEditFloodFuse(config = {}) {
         counted = true;
         onTrip?.({ method, key, action: "deferred", cls });
       }
+      throttle.tick(now);
+      const nap = Math.min(wait, deadline - now, throttle.sleepCap(now));
       let killed = false;
       if (mode === "supersede") {
         w.waiter?.kill();
@@ -65324,7 +65424,7 @@ function createEditFloodFuse(config = {}) {
             resolve6();
           } };
         });
-        await Promise.race([clock.sleep(Math.min(wait, deadline - now)), superseded]);
+        await Promise.race([clock.sleep(nap), superseded]);
         if (killed) {
           counters.superseded++;
           onTrip?.({ method, key, action: "superseded", cls });
@@ -65332,7 +65432,7 @@ function createEditFloodFuse(config = {}) {
         }
         w.waiter = null;
       } else {
-        await clock.sleep(Math.min(wait, deadline - now));
+        await clock.sleep(nap);
       }
     }
   }
@@ -65368,7 +65468,7 @@ function createEditFloodFuse(config = {}) {
       const dropGuard = () => mw.inflight > 1;
       const lateKey = cls === "cosmetic" ? `lr:${chat}` : undefined;
       try {
-        const msgSlot = await awaitRoom(msgKey, perMessageWindowMs, cls === "cosmetic" ? (t) => ceiling(cosmeticPerMessageMax, t) : (t) => classCeiling(perMessageMax, cls, t), method, "supersede", cls, dropGuard, deadline, lateKey);
+        const msgSlot = await awaitRoom(msgKey, perMessageWindowMs, cls === "cosmetic" ? (t) => cosmeticMessageCeiling(t) : (t) => classCeiling(perMessageMax, cls, t), method, "supersede", cls, dropGuard, deadline, lateKey);
         if (msgSlot === null)
           return DROPPED_RESULT;
         const reserved = [[msgKey, msgSlot]];
@@ -65376,13 +65476,22 @@ function createEditFloodFuse(config = {}) {
           for (const [k, at] of reserved)
             unreserve(k, at);
         };
-        const chatKey2 = `ce:${chat}`;
-        const chatSlot = await awaitRoom(chatKey2, perChatWindowMs, cls === "cosmetic" ? (t) => ceiling(cosmeticPerChatMax, t) : (t) => classCeiling(perChatEditMax, cls, t), method, "drop", cls, dropGuard, deadline, lateKey);
-        if (chatSlot === null) {
-          giveBack();
-          return DROPPED_RESULT;
+        if (cls === "cosmetic" && cosmeticFairShareEnabled) {
+          const fairSlots = await awaitCosmeticChatFair(chat, msg, method, cls, dropGuard, deadline, lateKey);
+          if (fairSlots === null) {
+            giveBack();
+            return DROPPED_RESULT;
+          }
+          reserved.push(...fairSlots);
+        } else {
+          const chatKey2 = `ce:${chat}`;
+          const chatSlot = await awaitRoom(chatKey2, perChatWindowMs, cls === "cosmetic" ? (t) => ceiling(cosmeticPerChatMax, t) : (t) => classCeiling(perChatEditMax, cls, t), method, "drop", cls, dropGuard, deadline, lateKey);
+          if (chatSlot === null) {
+            giveBack();
+            return DROPPED_RESULT;
+          }
+          reserved.push([chatKey2, chatSlot]);
         }
-        reserved.push([chatKey2, chatSlot]);
         const totalSlot = await awaitRoom(totalKey, perChatWindowMs, chatTotalMax, method, cls === "cosmetic" ? "drop" : "release", cls, dropGuard, deadline, lateKey);
         if (totalSlot === null) {
           giveBack();
@@ -65431,6 +65540,8 @@ function createEditFloodFuse(config = {}) {
       deferred: counters.deferred,
       dropped: counters.dropped,
       superseded: counters.superseded,
+      throttled: counters.throttled,
+      cosmeticFairShareEnabled,
       floodObserved: counters.floodObserved,
       tightened: isTightened(now),
       tightenLevel: levelAt(now),
@@ -71444,6 +71555,7 @@ __export(exports_silence_poke, {
   noteThinking: () => noteThinking,
   noteProduction: () => noteProduction,
   noteOutbound: () => noteOutbound2,
+  noteCardRender: () => noteCardRender,
   noteBackgroundShellDead: () => noteBackgroundShellDead,
   noteBackgroundShellAlive: () => noteBackgroundShellAlive,
   longestInFlightTool: () => longestInFlightTool,
@@ -71456,7 +71568,8 @@ __export(exports_silence_poke, {
   __getStateForTests: () => __getStateForTests,
   __bgMarkerParserConfirmedForTests: () => __bgMarkerParserConfirmedForTests,
   DEFAULT_THRESHOLDS: () => DEFAULT_THRESHOLDS,
-  DEFAULT_POLL_INTERVAL_MS: () => DEFAULT_POLL_INTERVAL_MS
+  DEFAULT_POLL_INTERVAL_MS: () => DEFAULT_POLL_INTERVAL_MS,
+  CARD_RENDER_FRESH_MS: () => CARD_RENDER_FRESH_MS
 });
 
 // turn-liveness-floor.ts
@@ -71522,6 +71635,7 @@ var DEFAULT_THRESHOLDS = {
   fallback: 300000
 };
 var DEFAULT_POLL_INTERVAL_MS = 5000;
+var CARD_RENDER_FRESH_MS = 30000;
 var state2 = new Map;
 var timer = null;
 var activeDeps = null;
@@ -71540,6 +71654,7 @@ function startTurn(key, now) {
     fallbackFired: false,
     floorFired: false,
     inFlightTools: new Map,
+    lastCardRenderAt: null,
     sawBashThisTurn: false,
     aliveShells: new Set
   });
@@ -71571,6 +71686,12 @@ function noteProduction(key, now) {
   s.lastOutboundAt = now;
   s.fallbackFired = false;
 }
+function noteCardRender(key, now) {
+  const s = state2.get(key);
+  if (s == null)
+    return;
+  s.lastCardRenderAt = now;
+}
 function noteThinking(key, now) {
   const s = state2.get(key);
   if (s == null)
@@ -71717,6 +71838,8 @@ function tick(now) {
       if (underCeiling) {
         if (activeDeps.isCompactionInFlight?.(key) === true)
           continue;
+        if (s.lastCardRenderAt != null && now - s.lastCardRenderAt < CARD_RENDER_FRESH_MS)
+          continue;
         const forceDisable = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === "0";
         if (!forceDisable && activeDeps.isLegitimatelyWorking != null) {
           if (activeDeps.isLegitimatelyWorking(key))
@@ -78753,6 +78876,28 @@ init_rich_send();
 init_format();
 
 // registry/subagents-schema.ts
+function mapSubagentRow(row) {
+  return {
+    id: row.id,
+    parent_session_id: row.parent_session_id,
+    parent_turn_key: row.parent_turn_key,
+    agent_type: row.agent_type,
+    description: row.description,
+    background: row.background !== 0,
+    started_at: row.started_at,
+    last_activity_at: row.last_activity_at,
+    ended_at: row.ended_at,
+    status: row.status,
+    result_summary: row.result_summary,
+    jsonl_agent_id: row.jsonl_agent_id,
+    parent_agent_id: row.parent_agent_id ?? null,
+    model: row.model ?? null
+  };
+}
+function getSubagentByJsonlId(db2, jsonlAgentId) {
+  const row = db2.prepare("SELECT * FROM subagents WHERE jsonl_agent_id = ?").get(jsonlAgentId);
+  return row ? mapSubagentRow(row) : null;
+}
 function countRunningBackgroundSubagents(db2) {
   const row = db2.prepare("SELECT count(*) AS n FROM subagents WHERE background = 1 AND status = 'running'").get();
   return row?.n ?? 0;
@@ -78847,6 +78992,19 @@ function recordNestedSubagentDispatch(db2, args) {
     WHERE id = ?
   `).run(args.parentJsonlAgentId, args.parentJsonlAgentId, args.toolUseId);
 }
+function stampSubagentDispatchTurn(db2, args) {
+  db2.prepare(`
+    INSERT OR IGNORE INTO subagents
+      (id, parent_session_id, parent_turn_key, agent_type, description,
+       background, started_at, last_activity_at, status)
+    VALUES (?, NULL, ?, ?, ?, ?, ?, ?, 'running')
+  `).run(args.toolUseId, args.parentTurnKey, args.agentType ?? null, args.description ?? null, args.background ? 1 : 0, args.now, args.now);
+  db2.prepare(`
+    UPDATE subagents
+    SET parent_turn_key = COALESCE(parent_turn_key, ?)
+    WHERE id = ?
+  `).run(args.parentTurnKey, args.toolUseId);
+}
 function resolveSubagentOriginTurnKey(db2, jsonlAgentId, maxHops = 5) {
   const seen = new Set;
   let currentJsonlId = jsonlAgentId;
@@ -81177,6 +81335,28 @@ function isDraftOfReply(textBlock, replyText) {
 }
 
 // registry/turns-schema.ts
+function mapRow(row) {
+  return {
+    turn_key: row.turn_key,
+    chat_id: row.chat_id,
+    thread_id: row.thread_id,
+    started_at: row.started_at,
+    ended_at: row.ended_at,
+    ended_via: row.ended_via ?? null,
+    last_assistant_msg_id: row.last_assistant_msg_id,
+    last_assistant_done: row.last_assistant_done === null ? null : row.last_assistant_done !== 0,
+    last_user_msg_id: row.last_user_msg_id,
+    user_prompt_preview: row.user_prompt_preview,
+    assistant_reply_preview: row.assistant_reply_preview,
+    tool_call_count: row.tool_call_count,
+    interrupt_reason: row.interrupt_reason,
+    resumed_at: row.resumed_at,
+    session_id: row.session_id ?? null,
+    answer_redelivered_at: row.answer_redelivered_at ?? null,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
 function recordTurnStart(db3, args) {
   const now = Date.now();
   db3.prepare(`
@@ -81201,6 +81381,19 @@ function recordTurnEnd(db3, args) {
     WHERE turn_key = ?
   `).run(now, args.endedVia, args.lastAssistantMsgId ?? null, args.lastAssistantDone !== undefined ? args.lastAssistantDone ? 1 : 0 : null, args.assistantReplyPreview ?? null, args.toolCallCount !== undefined ? args.toolCallCount : null, now, args.turnKey);
 }
+function getTurnByKey(db3, turnKey3) {
+  const row = db3.prepare(`SELECT * FROM turns WHERE turn_key = ?`).get(turnKey3);
+  return row ? mapRow(row) : null;
+}
+function findMostRecentTurn(db3, beforeOrAtMs) {
+  const row = db3.prepare(`
+    SELECT * FROM turns
+    WHERE started_at <= ?
+    ORDER BY started_at DESC
+    LIMIT 1
+  `).get(beforeOrAtMs);
+  return row ? mapRow(row) : null;
+}
 var INTERRUPTED_VIA = new Set([
   "restart",
   "reaped_stale",
@@ -81316,7 +81509,7 @@ function mayOpenActivityCard(input) {
   if (input.crossTurnAnswerDelivered)
     return false;
   if (input.finalAnswerEverDelivered) {
-    if (input.postAnswerSubagentActivity && input.producer === "tool")
+    if ((input.postAnswerSubagentActivity || input.postAnswerMainActivity) && input.producer === "tool")
       return true;
     return false;
   }
@@ -81429,17 +81622,24 @@ class EmissionAuthority {
 }
 
 // gateway/feed-reopen-gate.ts
+var SUBSTANTIVE_REOPEN_MIN_LABELS = 2;
 function shouldReopenFeedAfterAck(input) {
   if (!input.finalAnswerDelivered)
     return false;
-  if (input.finalAnswerSubstantive)
-    return false;
+  if (input.finalAnswerSubstantive) {
+    if (input.reopenAfterSubstantiveEnabled !== true)
+      return false;
+    return (input.postSubstantiveToolLabelCount ?? 0) >= SUBSTANTIVE_REOPEN_MIN_LABELS;
+  }
   return input.enabled === true;
 }
 function decideFeedReopen(input) {
   if (!shouldReopenFeedAfterAck(input)) {
     return { dropLabel: true };
   }
+  if (input.finalAnswerSubstantive) {
+    return { dropLabel: false, liftLeverOne: true };
+  }
   return {
     dropLabel: false,
     reset: {
@@ -81950,6 +82150,12 @@ function noteProduction2(key, now) {
   s.lastOutboundAt = now;
   s.fallbackFired = false;
 }
+function noteCardRender2(key, now) {
+  const s = state5.get(key);
+  if (s == null)
+    return;
+  s.lastCardRenderAt = now;
+}
 function endTurn2(key) {
   state5.delete(key);
 }
@@ -82165,6 +82371,8 @@ function beginTurn(deps, ev) {
       replyCalled: false,
       finalAnswerDelivered: false,
       finalAnswerSubstantive: false,
+      postSubstantiveToolLabelCount: 0,
+      postAnswerMainActivity: false,
       finalAnswerEverDelivered: false,
       answerDelivered: false,
       flushedAnswerText: null,
@@ -82278,6 +82486,7 @@ function handleSessionEvent(deps, ev) {
     CONTEXT_EXHAUSTION_COOLDOWN_MS,
     DELIVERY_CONFIRM_ENABLED,
     FEED_REOPEN_AFTER_ACK_ENABLED,
+    FEED_REOPEN_AFTER_SUBSTANTIVE_ENABLED,
     HANDBACK_PRETURN_ENABLED,
     HISTORY_ENABLED,
     LIVENESS_TERMINAL_HONESTY,
@@ -82472,6 +82681,21 @@ function handleSessionEvent(deps, ev) {
       resolvePendingNarrativeOnTool(turn, ev.toolName, ev.input);
       turn.toolCallCount++;
       touchTurnActiveMarker(STATE_DIR);
+      if ((ev.toolName === "Agent" || ev.toolName === "Task") && ev.toolUseId != null && ev.toolUseId.length > 0 && turn.registryKey != null && turnsDb != null) {
+        try {
+          stampSubagentDispatchTurn(turnsDb, {
+            toolUseId: ev.toolUseId,
+            parentTurnKey: turn.registryKey,
+            agentType: typeof ev.input?.subagent_type === "string" ? ev.input.subagent_type : null,
+            description: typeof ev.input?.description === "string" ? ev.input.description : null,
+            background: ev.input?.run_in_background === true,
+            now: Date.now()
+          });
+        } catch (err) {
+          process.stderr.write(`telegram gateway: dispatch-time parent_turn_key stamp failed toolUseId=${ev.toolUseId}: ${err.message}
+`);
+        }
+      }
       preambleSuppressor.onTool({ isReplyTool: isTelegramSurfaceTool(ev.toolName) });
       surfaceMemoryLegibility(turn, ev.toolName, ev.toolUseId, ev.input);
       const ctrl = activeStatusReactions.get(statusKey(turn.sessionChatId, turn.sessionThreadId));
@@ -82510,16 +82734,24 @@ function handleSessionEvent(deps, ev) {
       if (isTelegramSurfaceTool(ev.toolName))
         return;
       if (turn.finalAnswerDelivered) {
+        if (turn.finalAnswerSubstantive)
+          turn.postSubstantiveToolLabelCount++;
         const reopen = decideFeedReopen({
           finalAnswerDelivered: turn.finalAnswerDelivered,
           finalAnswerSubstantive: turn.finalAnswerSubstantive,
-          enabled: FEED_REOPEN_AFTER_ACK_ENABLED
+          enabled: FEED_REOPEN_AFTER_ACK_ENABLED,
+          reopenAfterSubstantiveEnabled: FEED_REOPEN_AFTER_SUBSTANTIVE_ENABLED,
+          postSubstantiveToolLabelCount: turn.postSubstantiveToolLabelCount
         });
         if (reopen.dropLabel)
           return;
-        turn.finalAnswerDelivered = reopen.reset.finalAnswerDelivered;
-        turn.activityMessageId = reopen.reset.activityMessageId;
-        turn.activityLastSentRender = reopen.reset.activityLastSentRender;
+        if (reopen.reset != null) {
+          turn.finalAnswerDelivered = reopen.reset.finalAnswerDelivered;
+          turn.activityMessageId = reopen.reset.activityMessageId;
+          turn.activityLastSentRender = reopen.reset.activityLastSentRender;
+        }
+        if (reopen.liftLeverOne)
+          turn.postAnswerMainActivity = true;
       }
       const rendered = appendActivityLabel(turn.mirrorLines, ev.label);
       if (rendered != null) {
@@ -83450,7 +83682,8 @@ function createNarrativeLane(deps) {
           finalAnswerEverDelivered: turn.finalAnswerEverDelivered,
           labeledToolCount: turn.labeledToolCount,
           crossTurnAnswerDelivered,
-          postAnswerSubagentActivity: openFlags?.postAnswerSubagentActivity
+          postAnswerSubagentActivity: openFlags?.postAnswerSubagentActivity,
+          postAnswerMainActivity: turn.postAnswerMainActivity
         })) {
           break;
         }
@@ -83491,6 +83724,7 @@ function createNarrativeLane(deps) {
             if (isSendGateShed(editRes))
               break;
           }
+          noteCardRender2(statusKey(chat, thread), Date.now());
           turn.activityLastSentRender = target;
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
@@ -94966,6 +95200,77 @@ function createTurnStartSurfaces(deps) {
   return { armTurnStartSurfaces };
 }
 
+// gateway/progress-fallback-cap.ts
+var recentSends = new Map;
+var PROGRESS_FALLBACK_WINDOW_MS = 15 * 60000;
+var PROGRESS_FALLBACK_MAX = 5;
+function prune(key, now) {
+  const cutoff = now - PROGRESS_FALLBACK_WINDOW_MS;
+  const recent = (recentSends.get(key) ?? []).filter((ts) => ts > cutoff);
+  if (recent.length === 0)
+    recentSends.delete(key);
+  else
+    recentSends.set(key, recent);
+  return recent;
+}
+function reserveProgressFallbackSlot(key, now) {
+  const recent = prune(key, now);
+  if (recent.length >= PROGRESS_FALLBACK_MAX)
+    return null;
+  recent.push(now);
+  recentSends.set(key, recent);
+  let released = false;
+  return {
+    release: () => {
+      if (released)
+        return;
+      released = true;
+      const arr = recentSends.get(key);
+      if (!arr)
+        return;
+      const idx = arr.indexOf(now);
+      if (idx >= 0)
+        arr.splice(idx, 1);
+      if (arr.length === 0)
+        recentSends.delete(key);
+      else
+        recentSends.set(key, arr);
+    }
+  };
+}
+var PROGRESS_TURN_MAX = 5;
+function reserveProgressSlot(deps) {
+  const { key, now, turnStart, turnCount } = deps;
+  if (turnStart != null) {
+    const current = turnCount.get(key) ?? 0;
+    if (current >= PROGRESS_TURN_MAX)
+      return null;
+    turnCount.set(key, current + 1);
+    let released = false;
+    return {
+      release: () => {
+        if (released)
+          return;
+        released = true;
+        turnCount.set(key, Math.max(0, (turnCount.get(key) ?? 0) - 1));
+      }
+    };
+  }
+  return reserveProgressFallbackSlot(key, now);
+}
+async function sendWithProgressCap(deps, send) {
+  const reservation = reserveProgressSlot(deps);
+  if (reservation === null)
+    return { capped: true };
+  try {
+    const result = await send();
+    return { capped: false, result };
+  } catch (err) {
+    reservation.release();
+    throw err;
+  }
+}
+
 // gateway/delivery-confirm-wiring.ts
 function createDeliveryConfirmWiring(deps) {
   const {
@@ -96432,6 +96737,7 @@ ${result}
     meta: {
       source: "subagent_handback",
       outcome: opts.ctx.outcome,
+      chat_id: opts.ctx.chatId,
       message_id: String(ts),
       ...opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {},
       ...opts.ctx.jsonlAgentId ? { subagent_jsonl_id: opts.ctx.jsonlAgentId } : {}
@@ -96511,6 +96817,7 @@ ${summary}
     text: text4,
     meta: {
       source: "subagent_progress",
+      chat_id: opts.ctx.chatId,
       ...opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {},
       subagent_jsonl_id: opts.ctx.subagentJsonlId,
       bucket_idx: String(opts.ctx.bucketIdx),
@@ -102121,10 +102428,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.20.3";
-var COMMIT_SHA = "02c60960";
-var COMMIT_DATE = "2026-08-03T13:46:01Z";
-var LATEST_PR = 4322;
+var VERSION2 = "0.20.5";
+var COMMIT_SHA = "fc40cc8e";
+var COMMIT_DATE = "2026-08-04T04:03:52Z";
+var LATEST_PR = 4338;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -103176,7 +103483,7 @@ function openTurnsDb(agentDir) {
   } catch {}
   return db3;
 }
-function mapRow(row) {
+function mapRow2(row) {
   return {
     turn_key: row.turn_key,
     chat_id: row.chat_id,
@@ -103213,10 +103520,6 @@ function recordTurnEnd2(db3, args) {
     WHERE turn_key = ?
   `).run(now, args.endedVia, args.lastAssistantMsgId ?? null, args.lastAssistantDone !== undefined ? args.lastAssistantDone ? 1 : 0 : null, args.assistantReplyPreview ?? null, args.toolCallCount !== undefined ? args.toolCallCount : null, now, args.turnKey);
 }
-function getTurnByKey(db3, turnKey3) {
-  const row = db3.prepare(`SELECT * FROM turns WHERE turn_key = ?`).get(turnKey3);
-  return row ? mapRow(row) : null;
-}
 function markOrphanedWithTimeoutClassification(db3, opts) {
   const now = opts.now ?? Date.now();
   const isHang = opts.markerAgeMs != null && opts.markerAgeMs >= opts.hangThresholdMs && opts.markerTurnKey != null && opts.markerTurnKey.length > 0;
@@ -103307,7 +103610,7 @@ function findLatestTurnIfInterrupted(db3) {
   `).get();
   if (!row)
     return null;
-  const turn = mapRow(row);
+  const turn = mapRow2(row);
   if (turn.resumed_at != null)
     return null;
   if (turn.ended_at == null)
@@ -104296,7 +104599,7 @@ function applySubagentsSchema(db3) {
   db3.exec("CREATE INDEX IF NOT EXISTS subagents_jsonl_id ON subagents(jsonl_agent_id)");
   db3.exec("CREATE INDEX IF NOT EXISTS subagents_parent_agent ON subagents(parent_agent_id)");
 }
-function mapSubagentRow(row) {
+function mapSubagentRow2(row) {
   return {
     id: row.id,
     parent_session_id: row.parent_session_id,
@@ -104314,9 +104617,9 @@ function mapSubagentRow(row) {
     model: row.model ?? null
   };
 }
-function getSubagentByJsonlId(db3, jsonlAgentId) {
+function getSubagentByJsonlId2(db3, jsonlAgentId) {
   const row = db3.prepare("SELECT * FROM subagents WHERE jsonl_agent_id = ?").get(jsonlAgentId);
-  return row ? mapSubagentRow(row) : null;
+  return row ? mapSubagentRow2(row) : null;
 }
 function listNonTerminalSubagentsForTurn(db3, parentTurnKey) {
   const rows = db3.prepare(`
@@ -104325,23 +104628,74 @@ function listNonTerminalSubagentsForTurn(db3, parentTurnKey) {
         AND status NOT IN ('completed', 'failed')
       ORDER BY started_at ASC
     `).all(parentTurnKey);
-  return rows.map(mapSubagentRow);
+  return rows.map(mapSubagentRow2);
 }
-function resolveSubagentOriginTurnKey2(db3, jsonlAgentId, maxHops = 5) {
-  const seen = new Set;
-  let currentJsonlId = jsonlAgentId;
-  for (let hop = 0;hop <= maxHops && currentJsonlId != null; hop++) {
-    if (seen.has(currentJsonlId))
+
+// gateway/subagent-origin-surface.ts
+function turnToSurfaceChat(turn) {
+  if (turn == null || turn.chat_id.length === 0)
+    return null;
+  const threadNum = turn.thread_id != null && turn.thread_id.length > 0 ? Number(turn.thread_id) : NaN;
+  return {
+    chatId: turn.chat_id,
+    ...Number.isFinite(threadNum) ? { threadId: threadNum } : {}
+  };
+}
+function resolveSubagentOriginChatDb(db3, jsonlAgentId) {
+  try {
+    const originKey = resolveSubagentOriginTurnKey(db3, jsonlAgentId);
+    if (originKey == null)
       return null;
-    seen.add(currentJsonlId);
-    const row = db3.prepare("SELECT parent_turn_key, parent_agent_id FROM subagents WHERE jsonl_agent_id = ? LIMIT 1").get(currentJsonlId);
-    if (row == null)
+    return turnToSurfaceChat(getTurnByKey(db3, originKey));
+  } catch {
+    return null;
+  }
+}
+function resolveRecentTurnFallbackChat(db3, jsonlAgentId) {
+  try {
+    const worker = getSubagentByJsonlId(db3, jsonlAgentId);
+    if (worker == null)
       return null;
-    if (row.parent_turn_key != null && row.parent_turn_key.length > 0)
-      return row.parent_turn_key;
-    currentJsonlId = row.parent_agent_id ?? null;
+    return turnToSurfaceChat(findMostRecentTurn(db3, worker.started_at));
+  } catch {
+    return null;
   }
-  return null;
+}
+var RECENT_TURN_FLOOR_LOG_CAP = 256;
+var recentTurnFloorLogged = new Set;
+function noteWorkerRecentTurnFloor(agentId, dest, log = (line) => process.stderr.write(line)) {
+  if (recentTurnFloorLogged.has(agentId))
+    return;
+  recentTurnFloorLogged.add(agentId);
+  if (recentTurnFloorLogged.size > RECENT_TURN_FLOOR_LOG_CAP) {
+    const oldest = recentTurnFloorLogged.values().next().value;
+    if (oldest != null)
+      recentTurnFloorLogged.delete(oldest);
+  }
+  log(`telegram gateway: worker origin unresolved agent=${agentId} \u2014 flooring to pre-dispatch recent turn chat=${dest.chatId}${dest.threadId != null ? ` thread=${dest.threadId}` : ""}
+`);
+}
+function resolveWorkerSurfaceForDecider(db3, jsonlAgentId, opts) {
+  const dest = resolveWorkerSurfaceChat(db3, jsonlAgentId, opts);
+  if (dest.via === "recent-turn")
+    noteWorkerRecentTurnFloor(jsonlAgentId, dest);
+  return {
+    fleetChatId: dest.via === "owner-dm" || dest.via === "none" ? "" : dest.chatId,
+    ...dest.threadId != null ? { originThreadId: dest.threadId } : {}
+  };
+}
+function resolveWorkerSurfaceChat(db3, jsonlAgentId, opts) {
+  const origin = db3 != null ? resolveSubagentOriginChatDb(db3, jsonlAgentId) : null;
+  if (origin != null && origin.chatId.length > 0)
+    return { ...origin, via: "origin" };
+  if (opts.fleetChatId.length > 0)
+    return { chatId: opts.fleetChatId, via: "fleet" };
+  const recent = db3 != null ? resolveRecentTurnFallbackChat(db3, jsonlAgentId) : null;
+  if (recent != null)
+    return { ...recent, via: "recent-turn" };
+  if (opts.ownerDm.length > 0)
+    return { chatId: opts.ownerDm, via: "owner-dm" };
+  return { chatId: "", via: "none" };
 }
 
 // gateway/worker-feed-dispatch.ts
@@ -104887,21 +105241,12 @@ if (isGatewayMain)
 function resolveSubagentOriginChat(agentId) {
   if (turnsDb == null)
     return null;
-  try {
-    const originKey = resolveSubagentOriginTurnKey2(turnsDb, agentId);
-    if (originKey == null)
-      return null;
-    const turn = getTurnByKey(turnsDb, originKey);
-    if (turn == null || turn.chat_id.length === 0)
-      return null;
-    const threadNum = turn.thread_id != null && turn.thread_id.length > 0 ? Number(turn.thread_id) : NaN;
-    return {
-      chatId: turn.chat_id,
-      threadId: Number.isFinite(threadNum) ? threadNum : undefined
-    };
-  } catch {
+  return resolveSubagentOriginChatDb(turnsDb, agentId);
+}
+function recentTurnFallbackChat(agentId) {
+  if (turnsDb == null)
     return null;
-  }
+  return resolveRecentTurnFallbackChat(turnsDb, agentId);
 }
 var WORKER_FEED_FALLBACK_LOG_CAP = 256;
 var WORKER_FEED_STALE_TTL_MARGIN_MS = 5 * 60000;
@@ -104925,17 +105270,16 @@ function noteWorkerFeedOwnerDmFallback(agentId) {
 }
 var workerFeedOriginDeferrals = new Map;
 var WORKER_FEED_ORIGIN_DEFER_MAX = 10;
-function resolveWorkerFeedChat(agentId, fleetChatId, fallbackThreadId) {
-  const origin = resolveSubagentOriginChat(agentId);
-  if (origin != null && origin.chatId.length > 0)
-    return origin;
-  if (fleetChatId.length > 0)
-    return { chatId: fleetChatId, threadId: fallbackThreadId };
-  const ownerDm = loadAccess().allowFrom[0] ?? "";
-  if (origin == null && fleetChatId.length === 0 && ownerDm.length > 0) {
+function resolveWorkerFeedChat(agentId, fleetChatId) {
+  const dest = resolveWorkerSurfaceChat(turnsDb, agentId, {
+    fleetChatId,
+    ownerDm: loadAccess().allowFrom[0] ?? ""
+  });
+  if (dest.via === "recent-turn")
+    noteWorkerRecentTurnFloor(agentId, dest);
+  if (dest.via === "owner-dm")
     noteWorkerFeedOwnerDmFallback(agentId);
-  }
-  return { chatId: ownerDm, threadId: origin?.threadId ?? fallbackThreadId };
+  return { chatId: dest.chatId, ...dest.threadId != null ? { threadId: dest.threadId } : {} };
 }
 var REGISTRY_REAPER_INTERVAL_MS = 6 * 60 * 60 * 1000;
 function runHistoryReaperNow(reason) {
@@ -105197,6 +105541,7 @@ var TOPIC_FRAMING_ENABLED = process.env.SWITCHROOM_TOPIC_FRAMING !== "0";
 var QUEUED_STATUS_UX_ENABLED = process.env.SWITCHROOM_QUEUED_STATUS_UX !== "0";
 var MIDFLIGHT_BUSY_ACK_ENABLED = process.env.SWITCHROOM_MIDFLIGHT_BUSY_ACK !== "0";
 var FEED_REOPEN_AFTER_ACK_ENABLED = process.env.SWITCHROOM_FEED_REOPEN_AFTER_ACK !== "0";
+var FEED_REOPEN_AFTER_SUBSTANTIVE_ENABLED = process.env.SWITCHROOM_FEED_REOPEN_AFTER_SUBSTANTIVE !== "0";
 var FEED_HEARTBEAT_ENABLED = process.env.SWITCHROOM_FEED_HEARTBEAT !== "0";
 var FEED_HEARTBEAT_TICK_MS = 6000;
 var FEED_HEARTBEAT_MIN_STALE_MS = 6000;
@@ -107697,7 +108042,7 @@ async function runMidSessionCardReaper() {
           if (turnsDb == null)
             return "unknown";
           try {
-            const row = getSubagentByJsonlId(turnsDb, agentId);
+            const row = getSubagentByJsonlId2(turnsDb, agentId);
             if (row == null)
               return "unknown";
             if (row.status === "completed" || row.status === "failed")
@@ -109571,26 +109916,23 @@ async function executeProgressUpdate(args) {
     }
   }
   const turnStart = activeTurnStartedAt.get(key);
-  if (turnStart != null) {
-    const currentCount = progressUpdateTurnCount.get(key) ?? 0;
-    if (currentCount >= 5) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ ok: false, reason: "turn_limit" })
-          }
-        ]
-      };
-    }
-    progressUpdateTurnCount.set(key, currentCount + 1);
-  }
   const access = loadAccess();
   const literalText = (access.parseMode ?? "html") === "text";
   const sendOpts = {
     ...threadId != null ? { message_thread_id: threadId } : {}
   };
-  const sent = await robustApiCall(() => literalText ? lockedBot.api.sendMessage(chat_id, text5, sendOpts) : lockedBot.api.sendRichMessage(chat_id, richMessage2(text5), sendOpts), { verb: "sendMessage", chat_id, threadId });
+  const capped = await sendWithProgressCap({ key, now, turnStart, turnCount: progressUpdateTurnCount }, () => robustApiCall(() => literalText ? lockedBot.api.sendMessage(chat_id, text5, sendOpts) : lockedBot.api.sendRichMessage(chat_id, richMessage2(text5), sendOpts), { verb: "sendMessage", chat_id, threadId }));
+  if (capped.capped) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ ok: false, reason: "turn_limit" })
+        }
+      ]
+    };
+  }
+  const sent = capped.result;
   if (HISTORY_ENABLED) {
     recordOutbound({
       chat_id,
@@ -109603,6 +109945,9 @@ async function executeProgressUpdate(args) {
   try {
     noteSignal(key, Date.now());
   } catch {}
+  try {
+    noteOutbound2(key, Date.now());
+  } catch {}
   return {
     content: [
       {
@@ -110421,6 +110766,7 @@ function gatewayStreamRenderDeps() {
     CONTEXT_EXHAUSTION_COOLDOWN_MS,
     DELIVERY_CONFIRM_ENABLED,
     FEED_REOPEN_AFTER_ACK_ENABLED,
+    FEED_REOPEN_AFTER_SUBSTANTIVE_ENABLED,
     HANDBACK_PRETURN_ENABLED,
     HISTORY_ENABLED,
     LIVENESS_TERMINAL_HONESTY,
@@ -116006,7 +116352,7 @@ async function startGateway() {
                 let dispatch = resolveWorkerFeedDispatch(null, description2, entryBackground);
                 if (turnsDb != null) {
                   try {
-                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description2, entryBackground);
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId2(turnsDb, agentId), description2, entryBackground);
                   } catch {}
                 }
                 let isBackground = dispatch.isBackground;
@@ -116088,14 +116434,13 @@ async function startGateway() {
                     model: dispatch.feedModel ?? undefined
                   });
                 }
-                const handbackOrigin = resolveSubagentOriginChat(agentId);
+                const hbOwnerDm = loadAccess().allowFrom[0] ?? "";
                 const decision = decideSubagentHandback({
                   handbackEnvValue: process.env.SWITCHROOM_SUBAGENT_HANDBACK,
                   outcome,
                   isBackground,
-                  fleetChatId: handbackOrigin?.chatId || fleetChatId,
-                  ...handbackOrigin?.threadId != null ? { originThreadId: handbackOrigin.threadId } : {},
-                  ownerChatId: loadAccess().allowFrom[0] ?? "",
+                  ...resolveWorkerSurfaceForDecider(turnsDb, agentId, { fleetChatId, ownerDm: hbOwnerDm }),
+                  ownerChatId: hbOwnerDm,
                   taskDescription: description2,
                   resultText,
                   jsonlAgentId: agentId
@@ -116136,7 +116481,7 @@ async function startGateway() {
                 let dispatch = resolveWorkerFeedDispatch(null, description2);
                 if (turnsDb != null) {
                   try {
-                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId(turnsDb, agentId), description2);
+                    dispatch = resolveWorkerFeedDispatch(getSubagentByJsonlId2(turnsDb, agentId), description2);
                   } catch {}
                 }
                 const isBackground = dispatch.isBackground || dispatch.isNested;
@@ -116212,14 +116557,16 @@ async function startGateway() {
                   stampTurn.subagentActivityAt = Date.now();
                 }
                 if (workerFeedEnabled) {
+                  const wfOrigin = resolveSubagentOriginChat(agentId);
+                  const wfStamp = stampTurn != null ? { chatId: stampTurn.sessionChatId, threadId: stampTurn.sessionThreadId } : wfOrigin == null ? recentTurnFallbackChat(agentId) : null;
                   const dest = decideWorkerFeedDestination({
-                    origin: resolveSubagentOriginChat(agentId),
+                    origin: wfOrigin,
                     cardExists: workerActivityFeed?.has(agentId) === true,
                     priorDeferrals: workerFeedOriginDeferrals.get(agentId) ?? 0,
                     maxDeferrals: WORKER_FEED_ORIGIN_DEFER_MAX,
                     fleetChatId,
-                    stampChatId: stampTurn?.sessionChatId,
-                    stampThreadId: stampTurn?.sessionThreadId,
+                    stampChatId: wfStamp?.chatId,
+                    stampThreadId: wfStamp?.threadId,
                     ownerDm: loadAccess().allowFrom[0] ?? ""
                   });
                   if (dest.action === "defer") {
@@ -116233,6 +116580,9 @@ async function startGateway() {
                   }
                   if (dest.ownerDmFallback)
                     noteWorkerFeedOwnerDmFallback(agentId);
+                  if (stampTurn == null && wfOrigin == null && wfStamp != null && dest.chatId === wfStamp.chatId) {
+                    noteWorkerRecentTurnFloor(agentId, wfStamp);
+                  }
                   workerActivityFeed?.update(agentId, dest.chatId, {
                     description: dispatch.feedDescription,
                     lastTool,
@@ -116245,14 +116595,17 @@ async function startGateway() {
                   }, dest.threadId);
                   return;
                 }
-                const progressOrigin = resolveSubagentOriginChat(agentId);
+                const pgOwnerDm = loadAccess().allowFrom[0] ?? "";
+                const progressSurface = resolveWorkerSurfaceForDecider(turnsDb, agentId, {
+                  fleetChatId,
+                  ownerDm: pgOwnerDm
+                });
                 const decision = decideSubagentProgress({
                   skeleton: skeleton === true,
                   disableEnvValue: process.env.SWITCHROOM_DISABLE_SUBAGENT_PROGRESS,
                   isBackground,
-                  fleetChatId: progressOrigin?.chatId || fleetChatId,
-                  ...progressOrigin?.threadId != null ? { originThreadId: progressOrigin.threadId } : {},
-                  ownerChatId: loadAccess().allowFrom[0] ?? "",
+                  ...progressSurface,
+                  ownerChatId: pgOwnerDm,
                   subagentJsonlId: agentId,
                   taskDescription: description2,
                   latestSummary,
@@ -116264,7 +116617,7 @@ async function startGateway() {
                   return;
                 setBucketIdx(decision.bucketIdx);
                 pendingInboundBuffer.push(process.env.SWITCHROOM_AGENT_NAME ?? "", decision.inbound);
-                clearPending(statusKey(decision.chatId, progressOrigin?.threadId), "progress");
+                clearPending(statusKey(decision.chatId, progressSurface.originThreadId), "progress");
                 process.stderr.write(`telegram gateway: subagent-progress queued agent=${agentId} bucket=${decision.bucketIdx} elapsed_ms=${elapsedMs} chat=${decision.chatId}
 `);
               }