switchroom 0.18.26 → 0.18.27

package/telegram-plugin/flushed-turn-supersede.ts

@@ -113,6 +113,64 @@ export function decideSupersede(
   return { supersede: true, deleteMessageIds: [...record.messageIds], reason: 'supersede' }
 }
 
+/**
+ * How the gateway should CORRECT a flushed message once its canonical `reply`
+ * lands. Historically the supersede always did `deleteMessage(A)` + fresh send
+ * of the canonical reply B — visible to the user as a delete+replace flicker
+ * plus a second device ping. When the reply fits a single message and matches
+ * the flushed message's type (both plain text, the normal case), we can instead
+ * edit message A in place with B's content: no delete, no flicker, no re-ping.
+ *
+ *   - `edit-in-place` → the gateway feeds `editMessageId` into the existing
+ *     single-message edit path (the `previewMessageId` edit lane in
+ *     `sendReplyChunks`), which renders the canonical reply with the SAME rich
+ *     path a fresh reply uses and, on any edit 400 (message too old / can't be
+ *     edited / not found), falls back to delete+resend — so correctness never
+ *     regresses. `deleteMessageIds` is empty (message A becomes message B).
+ *   - `delete-resend` → the legacy behaviour: delete every flushed message id,
+ *     then send the canonical reply fresh. Chosen whenever edit-in-place isn't
+ *     safe (multi-part reply, >1 flushed message, a file/voice-only reply, or a
+ *     draft-stream preview already owns the single-message edit lane).
+ */
+export type SupersedeCorrection =
+  | { mode: 'edit-in-place'; editMessageId: number; deleteMessageIds: number[] }
+  | { mode: 'delete-resend'; deleteMessageIds: number[] }
+
+/**
+ * Decide how to correct a superseded flush. Pure so the gateway runs the exact
+ * branch the regression tests exercise. Edit-in-place is chosen IFF the flush
+ * posted exactly ONE message AND the canonical reply is a single plain-text
+ * message with no competing edit target:
+ *   - `flushMessageIds.length === 1` — a multi-message flush has no single
+ *     edit target; delete all and resend.
+ *   - `chunkCount === 1` — a multi-part reply can't collapse into one edit.
+ *   - `!hasFiles` — a file/album reply is not a plain-text edit.
+ *   - `!suppressText` — a voice-only reply sends no text body to edit into.
+ *   - `!hasOpenPreview` — a live draft-stream preview already owns the
+ *     single-message edit lane; deleting the flush and letting the preview edit
+ *     keeps exactly one message.
+ * `literalText` (`format:'text'`) stays eligible — it is still a text message,
+ * and the edit lane renders literal vs rich identically to a fresh send.
+ */
+export function decideSupersedeCorrection(input: {
+  flushMessageIds: number[]
+  chunkCount: number
+  hasFiles: boolean
+  suppressText: boolean
+  hasOpenPreview: boolean
+}): SupersedeCorrection {
+  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] }
+}
+
 /** Sentinel key for records whose flush carried no turnId nonce. */
 const NULL_TURN_KEY = '<<null-turn>>'
 

package/telegram-plugin/gateway/derive-turn-id.ts

@@ -0,0 +1,32 @@
+/**
+ * derive-turn-id.ts — the stable per-turn identity, extracted from the gateway
+ * monolith so BOTH the enqueue seam and out-of-gateway tests use the SAME
+ * function (no mirror-drift between production and the round-trip test).
+ *
+ * Component 3 — derive the stable per-turn identity from the chat, thread, and
+ * originating message id. Stamped into the inbound meta at build time
+ * (`origin_turn_id`) AND reconstructed at enqueue time from the same three
+ * values, so the id stamped on the message the model reads matches the id on
+ * the turn the gateway started for it. Using the message id (not the
+ * not-yet-known startedAt) is what lets the two sites agree. Returns null when
+ * there is no message id (synthetic / cron turns with no originating inbound —
+ * they never need origin routing, the live turn IS the origin).
+ *
+ * NOTE (#3268): a subagent-handback IS a synthetic inbound, but it MUST still
+ * derive a stable non-null id so the dead-air pre-turn card can be adopted by
+ * identity at enqueue. The handback inbound builder therefore rounds-trips its
+ * fabricated `ts` through `meta.message_id` (mirroring resume-inbound-builder),
+ * so `ev.messageId` is populated at enqueue and this function yields the SAME
+ * `chatKey#ts` the pre-turn seam recorded at release.
+ */
+
+import { chatKey } from './chat-key.js'
+
+export function deriveTurnId(
+  chatId: string,
+  threadId: number | null | undefined,
+  messageId: string | number | null | undefined,
+): string | null {
+  if (messageId == null || messageId === '' || String(messageId) === '0') return null
+  return `${chatKey(chatId, threadId ?? null)}#${messageId}`
+}

package/telegram-plugin/gateway/gateway.ts

@@ -88,7 +88,7 @@ import {
   type TelegraphAccount,
 } from '../telegraph.js'
 import { OutboundDedupCache } from '../recent-outbound-dedup.js'
-import { FlushedTurnSupersedeRegistry, DEFAULT_SUPERSEDE_TTL_MS } from '../flushed-turn-supersede.js'
+import { FlushedTurnSupersedeRegistry, DEFAULT_SUPERSEDE_TTL_MS, decideSupersedeCorrection } from '../flushed-turn-supersede.js'
 import { createInboundCoalescer, inboundCoalesceKey } from './inbound-coalesce.js'
 import {
   splitCoalescedAttachments,
@@ -198,6 +198,11 @@ import { NarrativeFlushController, PENDING_NARRATIVE_FLUSH_MS } from '../narrati
 import { toolLabel } from '../tool-labels.js'
 import { createTypingWrapper } from '../typing-wrap.js'
 import { createTurnTypingLoop } from './turn-typing-loop.js'
+import {
+  createHandbackPreturnSignal,
+  type PreTurnCardRecord,
+} from './handback-preturn-signal.js'
+import { deriveTurnId } from './derive-turn-id.js'
 import { createTypingEmitter, TYPING_REFRESH_MS } from '../typing-emitter.js'
 import { type DraftStreamHandle } from '../draft-stream.js'
 import { handlePtyPartialPure, type PtyHandlerState } from '../pty-partial-handler.js'
@@ -463,6 +468,7 @@ import { handleInjectCommand, type InjectDeps } from './inject-handler.js'
 import {
   parseModelCommand,
   planModelCommand,
+  resolveStaleAwareBusy,
   modelCommandReceiptLine,
   handleModelCommand,
   buildModelMenu,
@@ -802,7 +808,10 @@ import {
   removeTurnActiveMarker,
   sweepStaleTurnActiveMarker,
   readTurnActiveMarkerAgeMs,
+  effectiveTurnAgeMs,
   TURN_ACTIVE_MARKER_FILE,
+  TURN_ACTIVE_HARD_TTL_MS,
+  TURN_ACTIVE_IDLE_SWEEP_MS,
 } from './turn-active-marker.js'
 import {
   VERSION,
@@ -2859,14 +2868,91 @@ function turnInFlightForGate(): boolean {
   // handlers and do not sit behind this gate — and the block is surfaced
   // off-Telegram in blocked-approvals/<agent>.json.
   const hasPendingApproval = pendingPermissions.size > 0
-  if (!isDeliveryCutoverEnabled()) return claudeBusyKeys.size > 0 || hasPendingApproval
+  // The shared inbound gate stays STRICT: unconditionally busy whenever an
+  // approval card is outstanding (#2841 — a new inbound in that window would
+  // displace the approval context and orphan the pending MCP call). Only the
+  // machine-in-turn leg is factored out (`turnInFlightMachineOnly`); the
+  // `|| hasPendingApproval` composition here is what preserves the contract.
+  return turnInFlightMachineOnly() || hasPendingApproval
+}
+
+/**
+ * The machine-in-turn portion of the gate WITHOUT the `pendingPermissions`
+ * hold — "claude is actively producing a turn right now", ignoring an
+ * outstanding approval card. `turnInFlightForGate()` = this OR a pending
+ * approval, so the shared inbound-hold contract (#2841) is unchanged.
+ *
+ * Factored out so the `/model` & `/effort` busy decision can read THIS
+ * machine-only leg (plus a TTL-bounded approval check in
+ * `resolveModelEffortBusy`) — a wedged / undeliverable approval that "never
+ * expires by design" (#3084) must not hold their switch queued forever on an
+ * idle session (#3262), even though it correctly holds the general inbound gate.
+ */
+function turnInFlightMachineOnly(): boolean {
+  if (!isDeliveryCutoverEnabled()) return claudeBusyKeys.size > 0
   // Machine is authoritative. Run the log-only drift canary (#2794): the
   // imperative `claudeBusyKeys` shadow is still live in parallel, so a
   // dangerous over-hold divergence (machine holds the gate while the
   // imperative view is idle) is surfaced without changing behaviour. The
   // benign orphan-dangle direction — the wedge the machine self-heals — is
   // NOT flagged. `probeGateParity` returns the machine value unchanged.
-  return probeGateParity(isMachineInTurn(), claudeBusyKeys.size) || hasPendingApproval
+  return probeGateParity(isMachineInTurn(), claudeBusyKeys.size)
+}
+
+/**
+ * Age (ms) of the live turn for the phantom-turn cross-check (#3262): the
+ * turn-active liveness marker's mtime age (touched on every foreground
+ * tool_use AND on sub-agent JSONL growth, so a genuinely long turn keeps it
+ * small), falling back to `now - turn.startedAt` when the marker is absent
+ * (e.g. already swept). Null when no turn atom is set. A large age on a
+ * non-null atom is the dangling-atom signal.
+ */
+function liveTurnAgeMs(now: number): number | null {
+  if (currentTurn === null) return null
+  return effectiveTurnAgeMs(readTurnActiveMarkerAgeMs(STATE_DIR, now), currentTurn.startedAt, now)
+}
+
+/** Age (ms) of the OLDEST outstanding pending approval, or null when none. */
+function oldestPendingApprovalAgeMs(now: number): number | null {
+  let oldest: number | null = null
+  for (const p of pendingPermissions.values()) {
+    const age = now - p.startedAt
+    if (oldest === null || age > oldest) oldest = age
+  }
+  return oldest
+}
+
+/**
+ * Resolve the apply-vs-queue busy signals for a `/model` or `/effort` command,
+ * sweeping a stale (dangling) turn atom and discounting a wedged (undeliverable)
+ * approval hold — both bounded by the SAME `TURN_ACTIVE_HARD_TTL_MS` ceiling the
+ * marker sweep uses (#3262). A genuinely in-flight turn (fresh marker) and a
+ * recent pending approval still read busy, so the #3017/#3039 apply-or-queue
+ * contract and #3177/#3180 are preserved. Clears the dangling atom as a side
+ * effect so the phantom can't re-block the next command.
+ */
+function resolveModelEffortBusy(now = Date.now()): { currentTurnActive: boolean; turnInFlight: boolean } {
+  const turnAgeMs = liveTurnAgeMs(now)
+  const resolved = resolveStaleAwareBusy({
+    currentTurnActive: currentTurn !== null,
+    turnAgeMs,
+    machineInTurn: turnInFlightMachineOnly(),
+    oldestPendingApprovalAgeMs: oldestPendingApprovalAgeMs(now),
+    hardTtlMs: TURN_ACTIVE_HARD_TTL_MS,
+  })
+  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_MS / 1000)}s for /model|/effort busy-check agent=${getMyAgentName()}\n`,
+    )
+    // Single-tenant / sequential-CLI invariant: the singleton `currentTurn` IS
+    // the only live turn, and a stale atom is a ghost (its `turn_end` never
+    // fired) — clearing every entry is equivalent to clearing it, matching the
+    // bridge-died "every entry is a ghost" semantics.
+    clearAllCurrentTurns()
+  }
+  return { currentTurnActive: resolved.currentTurnActive, turnInFlight: resolved.turnInFlight }
 }
 
 /**
@@ -3674,25 +3760,10 @@ function findTurnByQuotedMessageId(chatId: string, replyTo: unknown): CurrentTur
   if (turn == null || turn.sessionChatId !== chatId) return null
   return turn
 }
-/**
- * Component 3 — derive the stable per-turn identity from the chat, thread,
- * and originating message id. Stamped into the inbound meta at build time
- * (`origin_turn_id`) AND reconstructed at enqueue time from the same three
- * values, so the id stamped on the message the model reads matches the id
- * on the turn the gateway started for it. Using the message id (not the
- * not-yet-known startedAt) is what lets the two sites agree. Returns null
- * when there is no message id (synthetic / cron / handback turns have no
- * originating inbound — they never need origin routing, the live turn IS
- * the origin).
- */
-function deriveTurnId(
-  chatId: string,
-  threadId: number | null | undefined,
-  messageId: string | number | null | undefined,
-): string | null {
-  if (messageId == null || messageId === '' || String(messageId) === '0') return null
-  return `${chatKey(chatId, threadId ?? null)}#${messageId}`
-}
+// Component 3 — the stable per-turn identity. Extracted to `derive-turn-id.ts`
+// (#3268) so the enqueue seam and the handback round-trip test share ONE
+// function. Re-exported into scope under the original name so every existing
+// callsite is unchanged.
 
 /**
  * Component 3 — resolve the turn that OWNS a reply by its `origin_turn_id`
@@ -7767,8 +7838,8 @@ const pendingStateReaper = setInterval(() => {
   try {
     sweepStaleTurnActiveMarker(STATE_DIR, {
       turnInFlight: currentTurn?.registryKey != null,
-      idleSweepMs: 60_000,
-      hardTtlMs: 10 * 60_000,
+      idleSweepMs: TURN_ACTIVE_IDLE_SWEEP_MS,
+      hardTtlMs: TURN_ACTIVE_HARD_TTL_MS,
       now,
       onRemove: ({ ageMs, reason, payload }) => {
         const agent = getMyAgentName()
@@ -8883,11 +8954,20 @@ 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),
         ttlMs: MID_SESSION_CARD_REAPER_TTL_MS,
         now,
-        finalizeCard: (record) =>
-          robustApiCall(
+        finalizeCard: (record) => {
+          // Reap hook (design lever 4): a never-adopted pre-turn card being
+          // finalized here must also stop its forever-running typing loop and
+          // drop the seam's in-memory entry.
+          if (handbackPreturnSignal.isPreTurnRecord(record.turnKey)) {
+            handbackPreturnSignal.handleReaped(record.turnKey)
+          }
+          return robustApiCall(
             () =>
               lockedBot.api.editMessageText(
                 record.chatId,
@@ -8900,7 +8980,8 @@ async function runMidSessionCardReaper(): Promise<void> {
               ...(record.threadId != null ? { threadId: record.threadId } : {}),
               verb: 'activity-card.mid-session-reap-finalize',
             },
-          ),
+          )
+        },
         // #3001: route through reconcileStatusPin when the pin is a live
         // in-memory claim, so the claim AND the durable status-pins.json row
         // clear together (the raw-API unpin left both behind — the boot sweep
@@ -10002,6 +10083,15 @@ _deliveryMachineTick.unref?.()
 // synthetic-source/empty, which never produce an `enqueue` and would otherwise
 // re-deliver forever.
 function trackRedeliveredInbound(merged: InboundMessage): void {
+  // Dead-air pre-turn signal: this is the shared CONFIRMED-release chokepoint
+  // (buffer drain, idle-drain tick, bridge re-register). A released
+  // subagent-handback gets a `typing…` + pre-turn card the imminent turn
+  // adopts; a no-op for every non-handback inbound (guarded inside the seam).
+  // Emitted BEFORE the delivery-confirm early-return so it fires regardless of
+  // that feature flag. Design lever 1: emit at release, do NOT gate on
+  // turn-in-flight (the common case is a worker finishing while the parent is
+  // mid-turn on another topic).
+  if (HANDBACK_PRETURN_ENABLED) handbackPreturnSignal.noteHandbackRelease(merged)
   if (!DELIVERY_CONFIRM_ENABLED) return
   // The boot-resume synthetic ('resume_interrupted') is the ONE synthetic we DO
   // enrol: a restart can drop it into a not-ready session exactly like a user
@@ -13292,6 +13382,15 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   // exact-text `outboundDedup` above structurally cannot catch. A reply for a
   // DIFFERENT newer live turn never supersedes (decideSupersede → different-turn),
   // so a fresh turn's answer is never clobbered.
+  //
+  // Reply-flicker fix: rather than delete the flushed message(s) HERE (which
+  // makes the user see delete+replace when the canonical reply sends fresh
+  // below), we DEFER the correction to the send site. Once chunk count / files /
+  // preview are known, `decideSupersedeCorrection` picks edit-in-place (edit the
+  // single flushed message into the canonical reply — no flicker, no re-ping)
+  // when the reply fits one plain-text message, and falls back to the legacy
+  // delete+resend otherwise. `supersedeFlushIds` carries the ids forward.
+  let supersedeFlushIds: number[] = []
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined
     // 2026-07 double-reply-on-DM fix (Part 1) — resolve the turn this reply
@@ -13319,12 +13418,24 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
         `telegram gateway: reply: superseding flushed turn message(s) ` +
         `chatId=${chat_id} ids=${JSON.stringify(decision.deleteMessageIds)}\n`,
       )
-      for (const id of decision.deleteMessageIds) {
-        await swallowingApiCall(
-          () => lockedBot.api.deleteMessage(chat_id, id),
-          { chat_id, verb: 'reply.supersedeFlushed' },
-        )
-      }
+      // Deferred: the correction (edit-in-place vs delete+resend) is decided at
+      // the send site once chunk count / files / preview are known.
+      supersedeFlushIds = decision.deleteMessageIds
+      // Set the answer-delivered latch NOW, at record consumption — BEFORE the
+      // arg-validation throws between here and the correction site (file
+      // too-large ~L13699, inline_keyboard invalid ~L13782). Without this, a
+      // late reply that supersedes a flush AND carries an oversized file /
+      // invalid keyboard would throw before the correction runs (message A
+      // neither deleted nor edited), the model would retry `reply`, and — the
+      // supersede record already consumed by `take()` above — the retry would
+      // fall into the else/no-record branch below with no latch set, so
+      // suppression wouldn't fire and a fresh B would ship alongside the stale
+      // narration A (both visible). Latching here mirrors the else-branch's own
+      // `answerDelivered = true` and closes that resurrection window: the retry
+      // resolves the same ended owner turn, sees the latch, and is suppressed —
+      // exactly one message ever ships. The latch is idempotent and the normal
+      // (no-throw) path is unaffected: the correction below still ships B once.
+      if (ownerTurn != null) ownerTurn.answerDelivered = true
     } else {
       // 2026-07 double-reply-on-DM fix (Part 2) — answer-delivered race latch.
       // Supersede found no record. Either there was no flush (normal reply), or
@@ -13858,6 +13969,41 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
     }
   }
 
+  // Reply-flicker fix — apply the deferred flushed-turn correction now that
+  // chunk count / files / preview are all resolved. `edit-in-place` reuses the
+  // single-message edit lane below (`previewMessageId`): it edits the flushed
+  // message A into the canonical reply B with the SAME rich rendering a fresh
+  // reply uses, and `sendReplyChunks` falls back to delete+resend on any edit
+  // 400 (message too old / uneditable / gone) — so exactly one message with the
+  // canonical content always survives. We also forgo the quote (an edit can't
+  // carry a reply_parameters quote) by clearing `reply_to`, so the quote-delete
+  // guard just below does NOT delete our edit target. `delete-resend` keeps the
+  // legacy behaviour (delete the flushed message(s), then send fresh below).
+  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}\n`,
+      )
+    } 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
@@ -13874,7 +14020,12 @@ async function executeReply(args: Record<string, unknown>): Promise<{ content: A
   let silentAnchorEditDone = false
   {
     const turn = currentTurn
-    if (turn != null && chunks.length === 1) {
+    // Skip the silent-anchor merge when a flushed-turn supersede is active: an
+    // edit-in-place correction has re-pointed `previewMessageId` at the flushed
+    // message (the chunk loop below edits it), and merging into a prior silent
+    // anchor instead would orphan the flushed message A (leaving BOTH A and the
+    // anchor visible — the exact duplicate this supersede exists to prevent).
+    if (turn != null && chunks.length === 1 && supersedeFlushIds.length === 0) {
       const decision = decideSilentReplyAnchor({
         effectivelySilent: disableNotification,
         anchorMessageId: turn.silentAnchorMessageId,
@@ -16996,6 +17147,90 @@ function clearActivitySummary(turn: CurrentTurn, finalHtmlOverride?: string | nu
   })
 }
 
+// ─── Sub-agent handback dead-air pre-turn signal ─────────────────────────────
+// Closes the gap between a background sub-agent's handback being RELEASED for
+// delivery (the buffer drain) and the parent turn that consumes it minting +
+// rendering its first tool/narration. On release we emit a `typing…` loop + a
+// "reading the worker's results…" card; the imminent turn ADOPTS that exact
+// card (by inbound identity) so it's one continuous card lifecycle finalized by
+// the turn's normal `clearActivitySummary`, never a second card. See
+// handback-preturn-signal.ts for the design + the red-team holes each lever
+// closes. Kill switch: SWITCHROOM_HANDBACK_PRETURN=0.
+const HANDBACK_PRETURN_ENABLED = !STATIC && process.env.SWITCHROOM_HANDBACK_PRETURN !== '0'
+const HANDBACK_PRETURN_HTML = '🤝 Reading the worker’s results…'
+const HANDBACK_PRETURN_ORPHAN_HTML =
+  '🤝 A background worker finished, but the handback never started — it may need a nudge.'
+
+async function openHandbackPreTurnCard(
+  chatId: string,
+  threadId: number | null,
+): Promise<number | null> {
+  if (STATIC) return null
+  try {
+    const sent = await robustApiCall(
+      // allow-raw-bot-api: sendRichMessage routed through robustApiCall (not in the THREAD_NOT_FOUND blast pattern)
+      () =>
+        bot.api.sendRichMessage(chatId, richMessage(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 as Error).message}\n`,
+    )
+    return null
+  }
+}
+
+function finalizeHandbackPreTurnCard(record: PreTurnCardRecord): Promise<void> {
+  return robustApiCall(
+    () =>
+      bot.api.editMessageText(
+        record.chatId,
+        record.activityMessageId,
+        richMessage(HANDBACK_PRETURN_ORPHAN_HTML),
+        {},
+      ),
+    {
+      chat_id: record.chatId,
+      ...(record.threadId != null ? { threadId: record.threadId } : {}),
+      verb: 'handback-preturn.orphan-finalize',
+    },
+  )
+    .then(() => undefined)
+    .catch(() => undefined)
+}
+
+const handbackPreturnSignal = createHandbackPreturnSignal({
+  chatKey: (chatId, threadId) => chatKey(chatId, threadId) as string,
+  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: (record) => {
+    if (!activityCardPersistEnabled) return
+    writeActivityCardRecord(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs, record)
+  },
+  clearCardRecord: (turnKey, activityMessageId) => {
+    if (!activityCardPersistEnabled) return
+    clearActivityCardRecord(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs, turnKey, activityMessageId)
+  },
+  // Lever 5: never paint a pre-turn card beneath a turn that already delivered
+  // its answer / ended by the time the debounce fires.
+  isTurnSettled: (key) => {
+    const live = currentTurnMap.get(key)
+    return live != null && (live.finalAnswerDelivered || live.endedAt != null)
+  },
+})
+
 /**
  * #2849 hindsight Phase 4 — sparse chat-legible memory.
  *
@@ -17349,6 +17584,27 @@ function handleSessionEvent(ev: SessionEvent): void {
         // Wire the per-turn narrative gate now that `next` exists (its SHOW/RETRACT
         // effects close over the turn). Born with this turn, torn down at turn end.
         next.narrativeGate = makeNarrativeGate(next)
+        // Dead-air pre-turn signal — ADOPT by inbound identity (design lever 2).
+        // If a subagent-handback pre-turn signal was emitted for THIS exact turn
+        // (matched on `turnId`, not the bare topic key, so a racing user inbound
+        // can't mis-adopt), consume it. A card-bearing adoption seeds
+        // `activityMessageId` + `activityEverOpened` so `renderActivityFeed`
+        // EDITS the existing card instead of opening a second one, and so the
+        // turn's own end-of-turn `clearActivitySummary` finalizes it (lever 3).
+        // The handback turn also gets the turn-long typing loop it never had —
+        // whether or not a card was painted (the debounce may not have fired) —
+        // stopped by the canonical turn-end (`purgeReactionTracking →
+        // stopTurnTypingLoop`).
+        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)
+          }
+        }
         // PR-4e — route the turn-SET through the keyed accessor: flag-OFF assigns
         // the singleton (byte-identical to `currentTurn = next`); flag-ON sets the
         // per-topic `byKey[statusKey]` entry AND the most-recent mirror. The key is
@@ -23515,8 +23771,13 @@ bot.command('model', async ctx => {
   // command leaves a greppable log line + a history row before any branch. This
   // is the fix for the finn 2026-07-12 zero-trace swallow (no log, no reply, no
   // ack, no deferred apply). `busyNow` folds BOTH busy signals (turn atom AND
-  // the authoritative delivery-machine/approval gate).
-  const busyNow = currentTurn !== null || turnInFlightForGate()
+  // the authoritative delivery-machine/approval gate) — but a STALE atom or a
+  // wedged approval older than the hard TTL is discounted as idle (#3262), so a
+  // phantom "active turn" on an idle session no longer blocks the switch. Resolve
+  // once (it may clear a dangling atom) and reuse for both the receipt log and
+  // the routing disposition.
+  const modelBusy = resolveModelEffortBusy()
+  const busyNow = modelBusy.currentTurnActive || modelBusy.turnInFlight
   process.stderr.write(modelCommandReceiptLine(getMyAgentName(), parsed, busyNow) + '\n')
   if (HISTORY_ENABLED && ctx.message?.message_id != null) {
     try {
@@ -23538,8 +23799,8 @@ bot.command('model', async ctx => {
   // session busy by EITHER measure ack+queues instead of silently injecting
   // into a busy pane. Every branch below produces a visible action.
   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') {
@@ -23650,9 +23911,12 @@ bot.command('effort', async ctx => {
   }
   // Mid-turn: ACK + QUEUE + apply-on-idle + confirm (#3017) — parity with
   // /model. `applyEffort` mid-turn silently maybe-failed ("couldn't confirm it
-  // applied") before this gate existed. `currentTurn !== null` is the same
-  // busy signal the model path reads via deps.isBusy().
-  if ((parsed.kind === 'set' || parsed.kind === 'default') && currentTurn !== null) {
+  // applied") before this gate existed. Use the SAME stale-aware busy resolver
+  // as /model (#3262) so a dangling turn atom older than the hard TTL is
+  // discounted as idle and the switch applies instead of queuing forever on an
+  // idle session.
+  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)