switchroom 0.19.37 → 0.19.39

package/dist/host-control/main.js

@@ -21311,7 +21311,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.19.37";
+var VERSION = "0.19.39";
 
 // src/setup/hindsight-recall-tunables.ts
 var RECALL_DEADLINE_HEADROOM_SECONDS = 2;
@@ -21440,8 +21440,8 @@ var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION = 16 * 1024;
 var HINDSIGHT_PG_APP_ANON_MIB = 2560;
 var HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB = 2048;
 var HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB = HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION - HINDSIGHT_PG_APP_ANON_MIB - HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB;
-var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 3072;
-var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 7168;
+var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 6144;
+var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 12288;
 function pgMib(mib) {
   return `${mib}MB`;
 }
@@ -21485,7 +21485,7 @@ var HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150;
 var HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4;
 var HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8;
 var HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 500;
+var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 250;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT = 6;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1;
 var HINDSIGHT_DEFAULT_RECENCY_DECAY_FUNCTION = "exponential";

package/dist/vault/approvals/kernel-server.js

@@ -19337,8 +19337,8 @@ var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION = 16 * 1024;
 var HINDSIGHT_PG_APP_ANON_MIB = 2560;
 var HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB = 2048;
 var HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB = HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION - HINDSIGHT_PG_APP_ANON_MIB - HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB;
-var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 3072;
-var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 7168;
+var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 6144;
+var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 12288;
 function pgMib(mib) {
   return `${mib}MB`;
 }
@@ -19382,7 +19382,7 @@ var HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150;
 var HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4;
 var HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8;
 var HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 500;
+var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 250;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT = 6;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1;
 var HINDSIGHT_DEFAULT_RECENCY_DECAY_FUNCTION = "exponential";

package/dist/vault/broker/server.js

@@ -19750,8 +19750,8 @@ var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION = 16 * 1024;
 var HINDSIGHT_PG_APP_ANON_MIB = 2560;
 var HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB = 2048;
 var HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB = HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION - HINDSIGHT_PG_APP_ANON_MIB - HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB;
-var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 3072;
-var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 7168;
+var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 6144;
+var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 12288;
 function pgMib(mib) {
   return `${mib}MB`;
 }
@@ -19795,7 +19795,7 @@ var HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150;
 var HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4;
 var HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8;
 var HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 500;
+var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 250;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT = 6;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1;
 var HINDSIGHT_DEFAULT_RECENCY_DECAY_FUNCTION = "exponential";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.19.37",
+  "version": "0.19.39",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

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

@@ -47609,6 +47609,23 @@ function computeLabel(toolName, input) {
   }
   return "Working\u2026";
 }
+function isSubagentToolCall(event) {
+  if (!event || typeof event !== "object")
+    return false;
+  const at = event.agent_type;
+  if (typeof at === "string" && at.length > 0)
+    return at !== "main";
+  const aid = event.agent_id;
+  const sid = event.session_id;
+  return typeof aid === "string" && aid.length > 0 && typeof sid === "string" && sid.length > 0 && aid !== sid;
+}
+function hasAttributionSignal(event) {
+  if (!event || typeof event !== "object")
+    return false;
+  const at = event.agent_type;
+  const aid = event.agent_id;
+  return typeof at === "string" && at.length > 0 || typeof aid === "string" && aid.length > 0;
+}
 function main() {
   const raw = readStdin().trim();
   if (!raw)
@@ -47627,6 +47644,14 @@ function main() {
   const toolName = event.tool_name;
   if (!sessionId || !toolUseId || !toolName)
     process.exit(0);
+  if (!hasAttributionSignal(event)) {
+    try {
+      process.stderr.write(`[tool-label-pretool] WARNING: PreToolUse payload carries neither ` + `agent_type nor agent_id \u2014 the sidechain-attribution invariant may be ` + `broken by a Claude Code schema change; sub-agent labels may be ` + `mis-attributed to the parent session (tool_use_id=${toolUseId}).
+`);
+    } catch {}
+  }
+  if (isSubagentToolCall(event))
+    process.exit(0);
   let label;
   try {
     label = computeLabel(toolName, event.tool_input);
@@ -53405,6 +53430,12 @@ function createHandbackPreturnSignal(deps) {
     entry.reapTimer = null;
     if (entry.consumed)
       return;
+    if (deps.isClaudeBusy?.() === true) {
+      log(`handback-preturn-signal: reap deferred key=${entry.statusKey} ` + `(claude busy \u2014 handback enqueued behind an in-flight turn, not orphaned)
+`);
+      entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs);
+      return;
+    }
     entry.consumed = true;
     stopTypingUnlessTurnLive(entry, "orphan reap");
     if (entry.activityMessageId != null) {
@@ -53501,6 +53532,13 @@ function createHandbackPreturnSignal(deps) {
       dropEntry(entry);
       return adoption;
     },
+    hasPendingForTurnId(turnId) {
+      for (const e of byKey.values()) {
+        if (e.adoptTurnId === turnId && !e.consumed)
+          return true;
+      }
+      return false;
+    },
     isPreTurnRecord(turnKey2) {
       return turnKey2.startsWith(PRETURN_TURNKEY_PREFIX);
     },
@@ -80098,23 +80136,35 @@ function decideFallbackTeardownNotice2(input) {
 // gateway/stream-render.ts
 var PARKED_TURN_START_MAX = 16;
 var PARKED_TURN_START_TTL_MS = 30 * 60000;
+var QUEUED_CARD_ENABLED = process.env.SWITCHROOM_QUEUED_CARD !== "0";
+var QUEUED_CARD_HTML = "\u23f3 Queued \u2014 waiting for the current task to finish\u2026";
+var QUEUED_CARD_FOLDED_HTML = "\u2705 Folded into the current task.";
+var QUEUED_CARD_EXPIRED_HTML = "\u26a0\ufe0f This queued message timed out before it could start.";
 var parkedTurnStarts = [];
-function pruneParkedTurnStarts(now) {
+function pruneParkedTurnStarts(now, onDrop) {
   for (let i = parkedTurnStarts.length - 1;i >= 0; i--) {
     if (now - parkedTurnStarts[i].parkedAt > PARKED_TURN_START_TTL_MS) {
       const [dropped] = parkedTurnStarts.splice(i, 1);
       process.stderr.write(`telegram gateway: parked-turn-start expired chat=${dropped.chatId ?? "-"} ` + `msg=${dropped.messageId ?? "-"} age_ms=${now - dropped.parkedAt}
 `);
+      try {
+        onDrop?.(dropped);
+      } catch {}
     }
   }
 }
-function parkTurnStart(env, now) {
-  parkedTurnStarts.push({ ...env, parkedAt: now });
+function parkTurnStart(env, now, onEvict) {
+  const entry = { ...env, parkedAt: now };
+  parkedTurnStarts.push(entry);
   while (parkedTurnStarts.length > PARKED_TURN_START_MAX) {
     const [dropped] = parkedTurnStarts.splice(0, 1);
     process.stderr.write(`telegram gateway: parked-turn-start evicted (cap ${PARKED_TURN_START_MAX}) ` + `chat=${dropped.chatId ?? "-"} msg=${dropped.messageId ?? "-"}
 `);
+    try {
+      onEvict?.(dropped);
+    } catch {}
   }
+  return entry;
 }
 function takeParkedTurnStart() {
   return parkedTurnStarts.pop() ?? null;
@@ -80122,11 +80172,56 @@ function takeParkedTurnStart() {
 function discardParkedTurnStart(rawContent) {
   for (let i = parkedTurnStarts.length - 1;i >= 0; i--) {
     if (parkedTurnStarts[i].rawContent === rawContent) {
-      parkedTurnStarts.splice(i, 1);
-      return true;
+      const [dropped] = parkedTurnStarts.splice(i, 1);
+      return dropped;
     }
   }
-  return false;
+  return null;
+}
+async function openQueuedCard(deps, chatId, threadId, replyToMessageId) {
+  try {
+    const sent = await deps.robustApiCall(() => deps.bot.api.sendRichMessage(chatId, richMessage(QUEUED_CARD_HTML), {
+      ...threadId != null ? { message_thread_id: threadId } : {},
+      ...replyToMessageId != null ? { reply_parameters: { message_id: replyToMessageId, allow_sending_without_reply: true } } : {},
+      disable_notification: true
+    }), {
+      chat_id: chatId,
+      ...threadId != null ? { threadId } : {},
+      verb: "queued-card.send"
+    });
+    return sent?.message_id ?? null;
+  } catch (err) {
+    process.stderr.write(`telegram gateway: queued card send failed: ${err.message}
+`);
+    return null;
+  }
+}
+function finalizeQueuedCard(deps, chatId, threadId, messageId, html) {
+  deps.robustApiCall(() => deps.bot.api.editMessageText(chatId, messageId, richMessage(html), {}), {
+    chat_id: chatId,
+    ...threadId != null ? { threadId } : {},
+    verb: "queued-card.finalize"
+  }).catch(() => {
+    return;
+  });
+}
+function deleteQueuedCard(deps, chatId, messageId) {
+  deps.robustApiCall(() => deps.bot.api.deleteMessage(chatId, messageId), { chat_id: chatId, verb: "queued-card.delete-orphan" }).catch(() => {
+    return;
+  });
+}
+function envThreadIdNum(threadId) {
+  if (threadId == null)
+    return null;
+  const n = Number(threadId);
+  return Number.isFinite(n) ? n : null;
+}
+function finalizeParkedEntryCard(deps, entry, html) {
+  if (!QUEUED_CARD_ENABLED)
+    return;
+  if (entry.queuedCardMessageId == null || entry.chatId == null)
+    return;
+  finalizeQueuedCard(deps, entry.chatId, envThreadIdNum(entry.threadId), entry.queuedCardMessageId, html);
 }
 function beginTurn(deps, ev) {
   const {
@@ -80240,6 +80335,16 @@ function beginTurn(deps, ev) {
 `);
       }
     }
+    if (QUEUED_CARD_ENABLED && ev.queuedCardMessageId != null && next.activityMessageId == null) {
+      next.activityMessageId = ev.queuedCardMessageId;
+      next.activityEverOpened = true;
+      process.stderr.write(`telegram gateway: queued card adopted turnId=${turnId} card=${ev.queuedCardMessageId}
+`);
+    } else if (QUEUED_CARD_ENABLED && ev.queuedCardMessageId != null && ev.chatId != null && next.activityMessageId != null && next.activityMessageId !== ev.queuedCardMessageId) {
+      deleteQueuedCard(deps, ev.chatId, ev.queuedCardMessageId);
+      process.stderr.write(`telegram gateway: queued card superseded by handback adoption turnId=${turnId} ` + `queued=${ev.queuedCardMessageId} adopted=${next.activityMessageId}
+`);
+    }
     startTurnTypingLoop(ev.chatId, enqThreadIdNum ?? null);
     setCurrentTurn(next, statusKey(ev.chatId, enqThreadIdNum));
     scheduleEarlyLivenessOpen(next);
@@ -80388,7 +80493,7 @@ function handleSessionEvent(deps, ev) {
           ackDelivery(deliveryQueue, chatKey(ev.chatId, ev.threadId != null ? Number(ev.threadId) : null), ev.messageId, ev.rawContent);
         }
       }
-      pruneParkedTurnStarts(now);
+      pruneParkedTurnStarts(now, (e) => finalizeParkedEntryCard(deps, e, QUEUED_CARD_EXPIRED_HTML));
       if (!ev.chatId) {
         beginTurn(deps, ev);
         return;
@@ -80399,18 +80504,38 @@ function handleSessionEvent(deps, ev) {
         beginTurn(deps, ev);
         return;
       }
-      parkTurnStart({
+      const parkedEntry = parkTurnStart({
         chatId: ev.chatId,
         messageId: ev.messageId,
         threadId: ev.threadId,
         rawContent: ev.rawContent
-      }, now);
+      }, now, (evicted) => finalizeParkedEntryCard(deps, evicted, QUEUED_CARD_EXPIRED_HTML));
       process.stderr.write(`telegram gateway: turn-start parked (session busy) chat=${ev.chatId} ` + `thread=${enqThreadIdNum ?? "-"} msg=${ev.messageId ?? "-"} ` + `parked=${parkedTurnStarts.length}
 `);
+      const parkTurnId = deriveTurnId(ev.chatId, enqThreadIdNum ?? null, ev.messageId);
+      const handbackOwnsSurface = HANDBACK_PRETURN_ENABLED && parkTurnId != null && handbackPreturnSignal.hasPendingForTurnId(parkTurnId);
+      if (handbackOwnsSurface) {
+        process.stderr.write(`telegram gateway: queued card suppressed (handback owns surface) ` + `turnId=${parkTurnId} msg=${ev.messageId ?? "-"}
+`);
+      }
+      if (QUEUED_CARD_ENABLED && !handbackOwnsSurface) {
+        const cardChatId = ev.chatId;
+        const replyToRaw = ev.messageId != null ? Number(ev.messageId) : null;
+        const replyTo = replyToRaw != null && Number.isFinite(replyToRaw) ? replyToRaw : null;
+        openQueuedCard(deps, cardChatId, enqThreadIdNum ?? null, replyTo).then((cardId) => {
+          if (cardId == null)
+            return;
+          if (parkedTurnStarts.includes(parkedEntry)) {
+            parkedEntry.queuedCardMessageId = cardId;
+          } else {
+            deleteQueuedCard(deps, cardChatId, cardId);
+          }
+        });
+      }
       return;
     }
     case "dequeue": {
-      pruneParkedTurnStarts(Date.now());
+      pruneParkedTurnStarts(Date.now(), (e) => finalizeParkedEntryCard(deps, e, QUEUED_CARD_EXPIRED_HTML));
       const parked = takeParkedTurnStart();
       if (parked == null)
         return;
@@ -80418,8 +80543,10 @@ function handleSessionEvent(deps, ev) {
       return;
     }
     case "queue_remove": {
-      pruneParkedTurnStarts(Date.now());
-      discardParkedTurnStart(ev.rawContent);
+      pruneParkedTurnStarts(Date.now(), (e) => finalizeParkedEntryCard(deps, e, QUEUED_CARD_EXPIRED_HTML));
+      const removed = discardParkedTurnStart(ev.rawContent);
+      if (removed != null)
+        finalizeParkedEntryCard(deps, removed, QUEUED_CARD_FOLDED_HTML);
       return;
     }
     case "model": {
@@ -84938,8 +85065,8 @@ var HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION = 16 * 1024;
 var HINDSIGHT_PG_APP_ANON_MIB = 2560;
 var HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB = 2048;
 var HINDSIGHT_PG_SHARED_BUFFERS_BUDGET_MIB = HINDSIGHT_PG_MEM_LIMIT_MIB_FOR_DERIVATION - HINDSIGHT_PG_APP_ANON_MIB - HINDSIGHT_PG_PAGE_CACHE_FLOOR_MIB;
-var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 3072;
-var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 7168;
+var HINDSIGHT_PG_DEFAULT_SHARED_BUFFERS_MIB = 6144;
+var HINDSIGHT_PG_DEFAULT_EFFECTIVE_CACHE_SIZE_MIB = 12288;
 function pgMib(mib) {
   return `${mib}MB`;
 }
@@ -84983,7 +85110,7 @@ var HINDSIGHT_DEFAULT_RERANKER_MAX_CANDIDATES = 150;
 var HINDSIGHT_DEFAULT_RERANKER_LOCAL_MAX_CONCURRENT = 4;
 var HINDSIGHT_DEFAULT_RECALL_MAX_CONCURRENT = 8;
 var HINDSIGHT_DEFAULT_REFLECT_WALL_TIMEOUT_S = 600;
-var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 500;
+var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_MEMORIES_PER_ROUND = 250;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_SLOT_LIMIT = 6;
 var HINDSIGHT_DEFAULT_CONSOLIDATION_MAX_SLOTS = 1;
 var HINDSIGHT_DEFAULT_RECENCY_DECAY_FUNCTION = "exponential";
@@ -99672,10 +99799,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.19.37";
-var COMMIT_SHA = "5d2f9a17";
-var COMMIT_DATE = "2026-07-30T08:57:38Z";
-var LATEST_PR = 4023;
+var VERSION2 = "0.19.39";
+var COMMIT_SHA = "4aff2bdd";
+var COMMIT_DATE = "2026-07-31T00:54:36Z";
+var LATEST_PR = 4041;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -104885,7 +105012,7 @@ async function runMidSessionCardReaper() {
       const { finalized, vanished, total } = await runActivityCardMidSessionReaper({
         path: ACTIVITY_CARD_STORE_PATH,
         fs: activityCardStoreFs,
-        isLive: (record2) => topicKeys.has(record2.turnKey),
+        isLive: (record2) => topicKeys.has(record2.turnKey) || handbackPreturnSignal.isPreTurnRecord(record2.turnKey) && isMachineInTurn(),
         ttlMs: MID_SESSION_CARD_REAPER_TTL_MS,
         now,
         finalizeCard: (record2) => {
@@ -107525,7 +107652,8 @@ var handbackPreturnSignal = createHandbackPreturnSignal({
     if (live == null || live.endedAt != null)
       return false;
     return statusKey(live.sessionChatId, live.sessionThreadId) === key;
-  }
+  },
+  isClaudeBusy: () => isMachineInTurn()
 });
 var memoryLegibilityStager = new MemoryLegibilityStager;
 function sendMemoryLegibilityLine(event, chatId, threadId) {

package/telegram-plugin/gateway/gateway.ts

@@ -8909,10 +8909,14 @@ async function runMidSessionCardReaper(): Promise<void> {
       const { finalized, vanished, total } = await runActivityCardMidSessionReaper({
         path: ACTIVITY_CARD_STORE_PATH,
         fs: activityCardStoreFs,
-        // A synthetic pre-turn record's key is never a live topic key, so it is
-        // correctly seen as ownerless here (the seam's own age-based self-reap is
-        // the fast path; this is the crash / long-lived backstop).
-        isLive: (record) => topicKeys.has(record.turnKey),
+        // A synthetic pre-turn key reads as ownerless here (self-reap is the fast
+        // path; this is the crash backstop). EXCEPTION: a pre-turn handback still
+        // enqueued behind an in-flight turn is NOT an orphan — keep it live while
+        // claude is busy, else this 15-min backstop re-posts the false nudge the
+        // self-reap gate removed. (Boot reaper stays ungated: boot is never mid-turn.)
+        isLive: (record) =>
+          topicKeys.has(record.turnKey) ||
+          (handbackPreturnSignal.isPreTurnRecord(record.turnKey) && isMachineInTurn()),
         ttlMs: MID_SESSION_CARD_REAPER_TTL_MS,
         now,
         finalizeCard: (record) => {
@@ -13827,6 +13831,10 @@ const handbackPreturnSignal = createHandbackPreturnSignal({
     // dark-indicator bug). Flag-ON is already per-key; the check is a no-op there.
     return statusKey(live.sessionChatId, live.sessionThreadId) === key
   },
+  // Queue-state gate for the orphan reap (see the signal's `isClaudeBusy` doc):
+  // while a turn is in flight the handback is enqueued behind it, not orphaned.
+  // False for both `bridge_alive_idle` and `bridge_dead` → genuine orphan reaps.
+  isClaudeBusy: () => isMachineInTurn(),
 })
 
 /**

package/telegram-plugin/gateway/handback-preturn-signal.ts

@@ -54,9 +54,23 @@
  *     On adoption the durable record is re-keyed from its synthetic pre-turn key
  *     to the real `statusKey` so that teardown matches.
  *
- *   • NEVER-ADOPTED ORPHAN REAP. A degenerate case (bridge death after release,
- *     no enqueue ever arrives) would leave a frozen card + a forever `typing…`
- *     loop. The pre-turn card is persisted as a COMPLETE `ActivityCardRecord`
+ *   • NEVER-ADOPTED ORPHAN REAP — GATED ON A GLOBAL-BUSY QUEUE CHECK. A
+ *     degenerate case (bridge death after release, no enqueue ever arrives)
+ *     would leave a frozen card + a forever `typing…` loop. But the reap must
+ *     fire ONLY for that genuine orphan, never for a handback that is correctly
+ *     enqueued and simply waiting behind a long in-flight turn: claude has ONE
+ *     bridge / ONE input queue, so a released handback mints its adopting turn
+ *     only when claude next goes idle. A flat age-based reap cannot tell the two
+ *     apart and (before this gate) posted a false "never started — needs a
+ *     nudge" card every time a parent turn out-ran the timeout (the 3-cards-in-
+ *     4-min incident). The reap therefore consults `isClaudeBusy()` — the
+ *     machine-level "a turn is in flight right now" signal — and DEFERS
+ *     (re-arms for another `adoptTimeoutMs`) while claude is busy, finalizing
+ *     only once claude is idle AND the handback still has not been adopted. That
+ *     idle-with-no-adoption state is the genuine bridge-death / dropped-inbound
+ *     degenerate case. Lengthening the flat timeout would merely move the false
+ *     positive; the queue-state gate removes it. The pre-turn card is persisted
+ *     as a COMPLETE `ActivityCardRecord`
  *     under a SYNTHETIC `turnKey` (`preturn:<statusKey>:<startedAt>`) — synthetic
  *     so a sibling REAL turn on the same topic key can neither upsert-clobber it
  *     nor keep it "live" (the mid-session reaper's `isLive` keys on live topic
@@ -171,6 +185,22 @@ export interface HandbackPreturnSignalDeps {
    *  canonical turn-end owns the stop. Optional; defaults to "no live turn"
    *  (the pre-#3544 behaviour). */
   hasLiveTurn?: (statusKey: string) => boolean
+  /** True IFF claude is CURRENTLY producing a turn (ANY topic — the machine has
+   *  ONE bridge / ONE input queue). Consulted by the orphan reap: a released
+   *  handback is delivered into that single queue and only mints its adopting
+   *  turn when claude next goes idle, so while claude is busy the handback is
+   *  NOT orphaned — it is correctly enqueued BEHIND the in-flight turn (a long
+   *  parent turn can run many minutes). Finalizing it as an orphan in that
+   *  window posts a false "never started — needs a nudge" card. The reap
+   *  therefore DEFERS (re-arms) while this is true and finalizes only once
+   *  claude is idle and the handback still has not been adopted — the genuine
+   *  bridge-death / dropped-inbound degenerate case the reap exists for.
+   *  Distinct from `hasLiveTurn`, which is PER-KEY and only governs the
+   *  typing-loop stop; this is the GLOBAL busy signal because the handback
+   *  queues behind whatever turn is running, regardless of topic. Optional;
+   *  defaults to "not busy" (immediate reap — the pre-fix behaviour), so the
+   *  genuine-orphan path is unchanged. */
+  isClaudeBusy?: () => boolean
   now?: () => number
   /** Debounce before painting the pre-turn card (kills sub-second flicker). */
   debounceMs?: number
@@ -216,6 +246,15 @@ export interface HandbackPreturnSignal {
    *  re-keyed to the real `statusKey` so the turn's end-of-turn
    *  `clearActivitySummary` finalizes it. Cancels the debounce/self-reap. */
   tryAdopt: (turnId: string) => HandbackAdoption | null
+  /** True IFF a live (un-consumed) pre-turn entry is armed whose adopting turn
+   *  is `turnId`. Consulted by the queued-card surface (stream-render Part B) at
+   *  PARK time: when a handback pre-turn signal already owns the surface for the
+   *  turn this parked message will mint, the queued card must NOT be posted —
+   *  otherwise the same message ends up with two cards (the handback card the
+   *  turn adopts, plus a queued card that then freezes). Turn-scoped, NOT
+   *  key-scoped, so an unrelated user message parked on the same topic (a
+   *  DIFFERENT adoptTurnId) is not wrongly suppressed. */
+  hasPendingForTurnId: (turnId: string) => boolean
   /** True IFF `turnKey` is a synthetic pre-turn record key. */
   isPreTurnRecord: (turnKey: string) => boolean
   /** Reap hook for the gateway's mid-session / boot card reapers: stop the
@@ -349,6 +388,25 @@ export function createHandbackPreturnSignal(
   function reap(entry: PreTurnEntry): void {
     entry.reapTimer = null
     if (entry.consumed) return
+    // PRIMARY GATE (queue state, not a flat timeout): a released handback is
+    // delivered into claude's SINGLE input queue and mints its adopting turn
+    // only when claude next goes idle. If claude is STILL in a turn, this
+    // handback is not orphaned — it is correctly enqueued behind the in-flight
+    // turn (a long parent turn can run many minutes). Finalizing now would post
+    // a false "never started — needs a nudge" card (the 3-cards-in-4-min
+    // incident). Defer: re-arm and re-check. We finalize only once claude is
+    // idle AND the handback still has not been adopted (the genuine bridge-
+    // death / dropped-inbound case). This cannot loop forever on a healthy
+    // agent: claude processes its queue FIFO, so the handback is either adopted
+    // (cancelling the reap) or claude eventually goes idle (letting it fire).
+    if (deps.isClaudeBusy?.() === true) {
+      log(
+        `handback-preturn-signal: reap deferred key=${entry.statusKey} ` +
+          `(claude busy — handback enqueued behind an in-flight turn, not orphaned)\n`,
+      )
+      entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs)
+      return
+    }
     entry.consumed = true
     // Stop the forever-running typing loop and finalize the frozen card.
     stopTypingUnlessTurnLive(entry, 'orphan reap')
@@ -467,6 +525,13 @@ export function createHandbackPreturnSignal(
       return adoption
     },
 
+    hasPendingForTurnId(turnId) {
+      for (const e of byKey.values()) {
+        if (e.adoptTurnId === turnId && !e.consumed) return true
+      }
+      return false
+    },
+
     isPreTurnRecord(turnKey) {
       return turnKey.startsWith(PRETURN_TURNKEY_PREFIX)
     },