switchroom 0.18.26 → 0.18.28

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

@@ -39670,6 +39670,13 @@ function decideSupersede(record, args) {
   }
   return { supersede: true, deleteMessageIds: [...record.messageIds], reason: "supersede" };
 }
+function decideSupersedeCorrection(input) {
+  const eligible = input.flushMessageIds.length === 1 && input.chunkCount === 1 && !input.hasFiles && !input.suppressText && !input.hasOpenPreview;
+  if (eligible) {
+    return { mode: "edit-in-place", editMessageId: input.flushMessageIds[0], deleteMessageIds: [] };
+  }
+  return { mode: "delete-resend", deleteMessageIds: [...input.flushMessageIds] };
+}
 var NULL_TURN_KEY = "<<null-turn>>";
 function turnKey(turnId) {
   return turnId == null ? NULL_TURN_KEY : turnId;
@@ -40962,6 +40969,7 @@ function createWorkerActivityFeed(opts) {
   const nowFn = opts.now ?? Date.now;
   const floodWaitRemainingMs = opts.floodWaitRemainingMs ?? (() => 0);
   const minEditInterval = opts.minEditIntervalMs ?? 2500;
+  const elapsedRefreshMs = Math.max(minEditInterval, Math.floor(opts.elapsedRefreshMs ?? 15000));
   const firstPaintMin = opts.firstPaintMinMs ?? 8000;
   const heartbeatTickMs = opts.heartbeatTickMs ?? 6000;
   const maxRows = Math.max(1, Math.floor(opts.maxRows ?? 8));
@@ -41076,11 +41084,46 @@ function createWorkerActivityFeed(opts) {
     });
     return renderCombinedWorkerFeed(rows, { maxRows });
   }
+  function groupSubstanceKey(g, terminalRecap) {
+    const FS = "\x00";
+    const RS = "\x1E";
+    if (terminalRecap != null) {
+      return [
+        "T",
+        terminalRecap.state,
+        terminalRecap.description,
+        terminalRecap.toolCount,
+        terminalRecap.totalTokens ?? "",
+        terminalRecap.latestSummary,
+        ...terminalRecap.narrativeLines ?? []
+      ].join(FS);
+    }
+    const running = runningRows(g);
+    if (running.length === 0)
+      return "EMPTY";
+    return running.map((r) => {
+      const v = r.lastView;
+      return [
+        r.agentId,
+        v.state,
+        v.description,
+        v.toolCount,
+        v.totalTokens ?? "",
+        ...r.narrative
+      ].join(FS);
+    }).join(RS);
+  }
   function removeWorker(g, agentId) {
     g.workers.delete(agentId);
     agentIndex.delete(agentId);
     maybeDeleteGroup(g);
   }
+  function evictRowFromGroup(g, agentId) {
+    g.workers.delete(agentId);
+    if (agentIndex.get(agentId) === g.feedKey)
+      agentIndex.delete(agentId);
+    maybeDeleteGroup(g);
+  }
   function maybeDeleteGroup(g) {
     if (g.workers.size === 0 && g.pendingFinalize.size === 0)
       groups.delete(g.feedKey);
@@ -41125,6 +41168,7 @@ function createWorkerActivityFeed(opts) {
       return;
     }
     const body = renderGroupBody(g, now, opts2.terminalRecap ?? null, opts2.heartbeat ?? false);
+    const substanceKey = groupSubstanceKey(g, opts2.terminalRecap ?? null);
     if (body == null) {
       if (isTerminal)
         clearStaged();
@@ -41148,6 +41192,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = sent.message_id;
         g.messageCreatedAtMs = now;
         g.lastBody = body;
+        g.lastSubstanceKey = substanceKey;
         g.lastEditAt = now;
         g.terminalPainted = false;
         syncPin(g);
@@ -41163,8 +41208,13 @@ function createWorkerActivityFeed(opts) {
         clearStaged();
       return;
     }
-    if (!opts2.force && now - g.lastEditAt < minEditInterval)
-      return;
+    if (!opts2.force && !isTerminal) {
+      if (now - g.lastEditAt < minEditInterval)
+        return;
+      const substanceChanged = substanceKey !== g.lastSubstanceKey;
+      if (!substanceChanged && now - g.lastEditAt < elapsedRefreshMs)
+        return;
+    }
     try {
       const res = await opts.bot.editMessageText(g.chatId, g.messageId, body, sendOptsFor(g));
       if (isSendGateShed(res)) {
@@ -41172,6 +41222,7 @@ function createWorkerActivityFeed(opts) {
         return;
       }
       g.lastBody = body;
+      g.lastSubstanceKey = substanceKey;
       g.lastEditAt = now;
       if (isTerminal) {
         log(`worker-feed: finish feed=${g.feedKey} chat=${g.chatId} thread=${g.threadId ?? "-"} ` + `msgId=${g.messageId} agent=${finishingAgentId ?? "-"} ` + `state=${opts2.terminalRecap?.state ?? "done"} bytes=${body.length}`);
@@ -41189,6 +41240,7 @@ function createWorkerActivityFeed(opts) {
       }
       if (outcome === "not_modified") {
         g.lastBody = body;
+        g.lastSubstanceKey = substanceKey;
         g.lastEditAt = now;
         if (isTerminal)
           clearStaged();
@@ -41198,6 +41250,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = null;
         g.messageCreatedAtMs = 0;
         g.lastBody = null;
+        g.lastSubstanceKey = null;
         if (isTerminal)
           clearStaged();
         else
@@ -41262,7 +41315,7 @@ function createWorkerActivityFeed(opts) {
         if (row.finished)
           staleFinished.push({ g, agentId: row.agentId, reason });
         else
-          staleAgentIds.push({ agentId: row.agentId, reason });
+          staleAgentIds.push({ g, agentId: row.agentId, reason });
       }
     }
     for (const { g, agentId, reason } of staleFinished) {
@@ -41276,15 +41329,22 @@ function createWorkerActivityFeed(opts) {
       removeWorker(g, agentId);
       syncPin(g);
     }
-    for (const { agentId, reason } of staleAgentIds) {
-      const row = groupOfAgent(agentId)?.workers.get(agentId);
+    for (const { g, agentId, reason } of staleAgentIds) {
+      const row = g.workers.get(agentId);
       if (reason === "absolute") {
         const age = Math.floor((now - (row?.createdAtMs ?? now)) / 1000);
         log(`worker-feed: ABSOLUTE cap reap agent=${agentId} \u2014 row age ${age}s (>= ${Math.floor(absoluteRowLifetimeCapMs / 1000)}s); force-terminating immortal row (survives lastUpdateAt reset)`);
       } else {
         log(`worker-feed: TTL reap agent=${agentId} \u2014 no update in ${Math.floor((now - (row?.lastUpdateAt ?? now)) / 1000)}s (>= ${Math.floor(staleWorkerTtlMs / 1000)}s); force-terminating leaked row`);
       }
-      terminateWorker(agentId);
+      if (groupOfAgent(agentId) === g) {
+        terminateWorker(agentId);
+      } else {
+        log(`worker-feed: force-evicting leaked row agent=${agentId} feed=${g.feedKey} \u2014 agentIndex desynced (points elsewhere); removing directly`);
+        markFinalized(agentId);
+        evictRowFromGroup(g, agentId);
+        syncPin(g);
+      }
     }
     for (const g of [...groups.values()]) {
       if (g.pendingFinalize.size > 0 && now >= g.cooldownUntil) {
@@ -41307,6 +41367,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = null;
         g.messageCreatedAtMs = 0;
         g.lastBody = null;
+        g.lastSubstanceKey = null;
         syncPin(g);
         opts.bot.editMessageText(g.chatId, retiredId, WORKER_CARD_SUPERSEDED_BODY, sendOptsFor(g)).catch(() => {});
       }
@@ -41330,6 +41391,14 @@ function createWorkerActivityFeed(opts) {
     }
   }
   heartbeatTimer = setIntervalFn(heartbeatTick, heartbeatTickMs);
+  opts.exposeTestControls?.({
+    repointAgentIndex: (agentId, feedKey) => {
+      if (feedKey == null)
+        agentIndex.delete(agentId);
+      else
+        agentIndex.set(agentId, feedKey);
+    }
+  });
   return {
     has(agentId) {
       const g = groupOfAgent(agentId);
@@ -41357,6 +41426,14 @@ function createWorkerActivityFeed(opts) {
       if (existingRow?.finished === true)
         return Promise.resolve();
       const feedKey = feedKeyOf(chatId, threadId);
+      const priorFeedKey = agentIndex.get(agentId);
+      if (priorFeedKey != null && priorFeedKey !== feedKey) {
+        const priorGroup = groups.get(priorFeedKey);
+        if (priorGroup != null) {
+          evictRowFromGroup(priorGroup, agentId);
+          syncPin(priorGroup);
+        }
+      }
       let g = groups.get(feedKey);
       if (g == null) {
         g = {
@@ -41366,6 +41443,7 @@ function createWorkerActivityFeed(opts) {
           messageId: null,
           messageCreatedAtMs: 0,
           lastBody: null,
+          lastSubstanceKey: null,
           lastEditAt: 0,
           cooldownUntil: 0,
           chain: Promise.resolve(),
@@ -41379,6 +41457,7 @@ function createWorkerActivityFeed(opts) {
         g.messageId = null;
         g.messageCreatedAtMs = 0;
         g.lastBody = null;
+        g.lastSubstanceKey = null;
         g.pendingFinalize.clear();
         g.terminalPainted = false;
         syncPin(g);
@@ -46193,6 +46272,207 @@ function createTurnTypingLoop(deps) {
   };
 }
 
+// gateway/handback-preturn-signal.ts
+var PRETURN_TURNKEY_PREFIX = "preturn:";
+function isHandbackInbound(msg) {
+  return msg.type === "inbound" && msg.meta?.source === "subagent_handback";
+}
+function createHandbackPreturnSignal(deps) {
+  const now = deps.now ?? (() => Date.now());
+  const debounceMs = deps.debounceMs ?? 700;
+  const adoptTimeoutMs = deps.adoptTimeoutMs ?? 30000;
+  const setTimer = deps.setTimer ?? ((fn, ms) => {
+    const t = setTimeout(fn, ms);
+    t.unref?.();
+    return t;
+  });
+  const clearTimer = deps.clearTimer ?? ((h) => clearTimeout(h));
+  const log = deps.log ?? ((l) => process.stderr.write(l));
+  const byKey = new Map;
+  const bySyntheticKey = new Map;
+  function clearTimers(entry) {
+    if (entry.debounceTimer != null) {
+      clearTimer(entry.debounceTimer);
+      entry.debounceTimer = null;
+    }
+    if (entry.reapTimer != null) {
+      clearTimer(entry.reapTimer);
+      entry.reapTimer = null;
+    }
+  }
+  function dropEntry(entry) {
+    clearTimers(entry);
+    byKey.delete(entry.statusKey);
+    bySyntheticKey.delete(entry.syntheticTurnKey);
+  }
+  function emit(entry) {
+    entry.debounceTimer = null;
+    if (entry.consumed)
+      return;
+    if (deps.isTurnSettled?.(entry.statusKey)) {
+      dropEntry(entry);
+      return;
+    }
+    deps.startTypingLoop(entry.chatId, entry.threadId);
+    entry.emitted = true;
+    entry.reapTimer = setTimer(() => reap(entry), adoptTimeoutMs);
+    Promise.resolve().then(() => deps.openCard(entry.chatId, entry.threadId)).then((messageId) => {
+      if (messageId == null)
+        return;
+      if (entry.consumed) {
+        deps.finalizeCard({
+          turnKey: entry.syntheticTurnKey,
+          chatId: entry.chatId,
+          threadId: entry.threadId,
+          activityMessageId: messageId,
+          startedAt: entry.startedAt,
+          pinned: entry.pinned
+        });
+        return;
+      }
+      entry.activityMessageId = messageId;
+      const record = {
+        turnKey: entry.syntheticTurnKey,
+        chatId: entry.chatId,
+        threadId: entry.threadId,
+        activityMessageId: messageId,
+        startedAt: entry.startedAt,
+        pinned: entry.pinned
+      };
+      deps.writeCardRecord(record);
+    }).catch((err) => {
+      log(`handback-preturn-signal: openCard failed key=${entry.statusKey}: ` + `${err instanceof Error ? err.message : String(err)}
+`);
+    });
+  }
+  function reap(entry) {
+    entry.reapTimer = null;
+    if (entry.consumed)
+      return;
+    entry.consumed = true;
+    deps.stopTypingLoop(entry.chatId, entry.threadId);
+    if (entry.activityMessageId != null) {
+      const record = {
+        turnKey: entry.syntheticTurnKey,
+        chatId: entry.chatId,
+        threadId: entry.threadId,
+        activityMessageId: entry.activityMessageId,
+        startedAt: entry.startedAt,
+        pinned: entry.pinned
+      };
+      deps.clearCardRecord(entry.syntheticTurnKey, entry.activityMessageId);
+      Promise.resolve(deps.finalizeCard(record)).catch((err) => {
+        log(`handback-preturn-signal: orphan finalize failed key=${entry.statusKey}: ` + `${err instanceof Error ? err.message : String(err)}
+`);
+      });
+    }
+    dropEntry(entry);
+  }
+  return {
+    noteHandbackRelease(inbound) {
+      if (!isHandbackInbound(inbound))
+        return;
+      const chatId = inbound.chatId;
+      if (chatId == null || chatId === "")
+        return;
+      const threadId = inbound.threadId ?? null;
+      const adoptTurnId = deps.deriveTurnId(chatId, threadId, inbound.messageId);
+      if (adoptTurnId == null)
+        return;
+      const statusKey = deps.chatKey(chatId, threadId);
+      if (byKey.has(statusKey))
+        return;
+      const startedAt = now();
+      const syntheticTurnKey = `${PRETURN_TURNKEY_PREFIX}${statusKey}:${startedAt}`;
+      const entry = {
+        statusKey,
+        chatId,
+        threadId,
+        adoptTurnId,
+        syntheticTurnKey,
+        startedAt,
+        pinned: false,
+        debounceTimer: null,
+        reapTimer: null,
+        activityMessageId: null,
+        emitted: false,
+        consumed: false
+      };
+      byKey.set(statusKey, entry);
+      bySyntheticKey.set(syntheticTurnKey, statusKey);
+      entry.debounceTimer = setTimer(() => emit(entry), debounceMs);
+    },
+    tryAdopt(turnId) {
+      let entry;
+      for (const e of byKey.values()) {
+        if (e.adoptTurnId === turnId && !e.consumed) {
+          entry = e;
+          break;
+        }
+      }
+      if (entry == null)
+        return null;
+      entry.consumed = true;
+      clearTimers(entry);
+      const adoption = {
+        statusKey: entry.statusKey,
+        chatId: entry.chatId,
+        threadId: entry.threadId,
+        activityMessageId: entry.activityMessageId,
+        startedAt: entry.startedAt,
+        pinned: entry.pinned
+      };
+      if (entry.activityMessageId != null) {
+        deps.clearCardRecord(entry.syntheticTurnKey, entry.activityMessageId);
+        deps.writeCardRecord({
+          turnKey: entry.statusKey,
+          chatId: entry.chatId,
+          threadId: entry.threadId,
+          activityMessageId: entry.activityMessageId,
+          startedAt: entry.startedAt,
+          pinned: entry.pinned
+        });
+      }
+      dropEntry(entry);
+      return adoption;
+    },
+    isPreTurnRecord(turnKey2) {
+      return turnKey2.startsWith(PRETURN_TURNKEY_PREFIX);
+    },
+    handleReaped(turnKey2) {
+      const statusKey = bySyntheticKey.get(turnKey2);
+      if (statusKey == null)
+        return;
+      const entry = byKey.get(statusKey);
+      if (entry == null)
+        return;
+      entry.consumed = true;
+      deps.stopTypingLoop(entry.chatId, entry.threadId);
+      dropEntry(entry);
+    },
+    pendingCount() {
+      let n = 0;
+      for (const e of byKey.values())
+        if (!e.consumed)
+          n++;
+      return n;
+    },
+    stopAll() {
+      for (const e of [...byKey.values()])
+        clearTimers(e);
+      byKey.clear();
+      bySyntheticKey.clear();
+    }
+  };
+}
+
+// gateway/derive-turn-id.ts
+function deriveTurnId(chatId, threadId, messageId) {
+  if (messageId == null || messageId === "" || String(messageId) === "0")
+    return null;
+  return `${chatKey(chatId, threadId ?? null)}#${messageId}`;
+}
+
 // typing-emitter.ts
 var TYPING_REFRESH_MS = 4000;
 var TYPING_FLOOR_MS = 3500;
@@ -56388,7 +56668,9 @@ var SEND_GATE_DEFAULTS = {
   perChatBurst: 3,
   perGroupPerMin: 18,
   perGroupBurst: 2,
-  editFloorMs: 1500
+  editFloorMs: 1500,
+  perMessageEditWindowMs: 300000,
+  perMessageEditMaxPerWindow: 150
 };
 function createSendGate(config) {
   const enabled2 = config.enabled;
@@ -56400,6 +56682,8 @@ function createSendGate(config) {
   const perGroupPerMin = config.perGroupPerMin ?? SEND_GATE_DEFAULTS.perGroupPerMin;
   const perGroupBurst = config.perGroupBurst ?? SEND_GATE_DEFAULTS.perGroupBurst;
   const editFloorMs = config.editFloorMs ?? SEND_GATE_DEFAULTS.editFloorMs;
+  const perMessageEditWindowMs = Math.max(1, Math.floor(config.perMessageEditWindowMs ?? SEND_GATE_DEFAULTS.perMessageEditWindowMs));
+  const perMessageEditMaxPerWindow = Math.max(0, Math.floor(config.perMessageEditMaxPerWindow ?? SEND_GATE_DEFAULTS.perMessageEditMaxPerWindow));
   const messageStateTtlMs = config.messageStateTtlMs ?? 60000;
   const maxMessageStates = config.maxMessageStates ?? 5000;
   const usefulTtlMs = config.usefulTtlMs ?? 120000;
@@ -56415,7 +56699,8 @@ function createSendGate(config) {
     dropped: 0,
     shed: 0,
     expired: 0,
-    failedFast: 0
+    failedFast: 0,
+    budgetDeferred: 0
   };
   const bootStart = clock.now();
   const globalRamp = config.bootRamp ? {
@@ -56454,7 +56739,8 @@ function createSendGate(config) {
         lastHash: undefined,
         pending: null,
         running: false,
-        suppressedUntilMs: 0
+        suppressedUntilMs: 0,
+        editWindowTs: []
       };
       perMessage.set(key, state);
     }
@@ -56641,7 +56927,20 @@ function createSendGate(config) {
     try {
       while (state.pending) {
         const now = clock.now();
-        const readyAt = Math.max(state.lastSentMs + editFloorMs, state.suppressedUntilMs);
+        let readyAt = Math.max(state.lastSentMs + editFloorMs, state.suppressedUntilMs);
+        if (perMessageEditMaxPerWindow > 0 && state.pending.priorityClass === "cosmetic") {
+          const windowStart = now - perMessageEditWindowMs;
+          while (state.editWindowTs.length > 0 && state.editWindowTs[0] <= windowStart) {
+            state.editWindowTs.shift();
+          }
+          if (state.editWindowTs.length >= perMessageEditMaxPerWindow) {
+            const budgetReadyAt = state.editWindowTs[0] + perMessageEditWindowMs;
+            if (budgetReadyAt > readyAt) {
+              readyAt = budgetReadyAt;
+              counters.budgetDeferred++;
+            }
+          }
+        }
         const waitMs = readyAt - now;
         if (waitMs > 0) {
           await clock.sleep(waitMs);
@@ -56667,6 +56966,12 @@ function createSendGate(config) {
           await admit(bucketsFor(opts));
         }
         state.lastSentMs = clock.now();
+        if (perMessageEditMaxPerWindow > 0 && p.priorityClass === "cosmetic") {
+          state.editWindowTs.push(state.lastSentMs);
+          const overflow = state.editWindowTs.length - (perMessageEditMaxPerWindow + 1);
+          if (overflow > 0)
+            state.editWindowTs.splice(0, overflow);
+        }
         try {
           const res = await p.fn();
           state.lastHash = p.hash;
@@ -56854,6 +57159,12 @@ function sendGateConfigFromEnv(env = process.env) {
   const editFloorMs = parseNonNegativeInt(env.SWITCHROOM_TG_SEND_GATE_EDIT_FLOOR_MS);
   if (editFloorMs !== undefined)
     out.editFloorMs = editFloorMs;
+  const perMsgWindowMs = parsePositiveInt(env.SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_WINDOW_MS);
+  if (perMsgWindowMs !== undefined)
+    out.perMessageEditWindowMs = perMsgWindowMs;
+  const perMsgMax = parseNonNegativeInt(env.SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_MAX);
+  if (perMsgMax !== undefined)
+    out.perMessageEditMaxPerWindow = perMsgMax;
   const conservativeGlobal = parseBoolFlag(env.SWITCHROOM_TG_SEND_GATE_CONSERVATIVE_GLOBAL);
   if (conservativeGlobal !== undefined)
     out.conservativeGlobalFloodScope = conservativeGlobal;
@@ -70901,6 +71212,15 @@ function parseModelCommand(text4) {
 function isModelCommandBusy(ctx) {
   return ctx.currentTurnActive || ctx.turnInFlight;
 }
+function resolveStaleAwareBusy(input) {
+  const turnStale = input.currentTurnActive && input.turnAgeMs !== null && input.turnAgeMs > input.hardTtlMs;
+  const approvalLive = input.oldestPendingApprovalAgeMs !== null && input.oldestPendingApprovalAgeMs <= input.hardTtlMs;
+  return {
+    currentTurnActive: input.currentTurnActive && !turnStale,
+    turnInFlight: input.machineInTurn || approvalLive,
+    clearStaleTurn: turnStale
+  };
+}
 function planModelCommand(parsed, ctx) {
   if (parsed.kind === "show" && ctx.menuEnabled)
     return { kind: "menu" };
@@ -75523,10 +75843,34 @@ function validateMs365Preview(input) {
     out.sizeBytesBefore = o.sizeBytesBefore;
   if (typeof o.sizeBytesAfter === "number")
     out.sizeBytesAfter = o.sizeBytesAfter;
+  if (typeof o.eventWhen === "string")
+    out.eventWhen = o.eventWhen;
+  const changes = sanitizeChanges(o.changes);
+  if (changes)
+    out.changes = changes;
   if (typeof o.agentRationale === "string")
     out.agentRationale = o.agentRationale;
   return out;
 }
+function sanitizeChanges(input) {
+  if (!Array.isArray(input))
+    return;
+  const out = [];
+  for (const raw of input) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const c = raw;
+    if (typeof c.field !== "string" || c.field.length === 0)
+      continue;
+    const entry = { field: c.field };
+    if (typeof c.before === "string")
+      entry.before = c.before;
+    if (typeof c.after === "string")
+      entry.after = c.after;
+    out.push(entry);
+  }
+  return out.length > 0 ? out : undefined;
+}
 var DEFAULT_TTL_MS2 = 5 * 60 * 1000;
 var MAX_TTL_MS2 = 30 * 60 * 1000;
 var MIN_TTL_MS2 = 30 * 1000;
@@ -75551,6 +75895,9 @@ function buildMs365CardText(p) {
     lines.push(`ID:   ${truncate3(p.itemId, 96)}`);
   }
   lines.push(`Account: ${truncate3(p.accountEmail, 96)}`);
+  if (p.eventWhen) {
+    lines.push(`When: ${truncate3(p.eventWhen, 96)}`);
+  }
   if (typeof p.sizeBytesBefore === "number" || typeof p.sizeBytesAfter === "number") {
     const before = p.sizeBytesBefore ?? 0;
     const after = p.sizeBytesAfter ?? 0;
@@ -75561,19 +75908,29 @@ function buildMs365CardText(p) {
   if (p.deepLink) {
     lines.push(`Link: ${truncate3(p.deepLink, 256)}`);
   }
+  if (p.changes && p.changes.length > 0) {
+    lines.push("");
+    lines.push("Changes:");
+    for (const c of p.changes.slice(0, 8)) {
+      const before = c.before !== undefined ? truncate3(c.before, 96) : "(none)";
+      const after = c.after !== undefined ? truncate3(c.after, 96) : "(cleared)";
+      lines.push(`\u2022 ${c.field}: ${before} \u2192 ${after}`);
+    }
+  }
   if (p.agentRationale) {
     lines.push("");
     lines.push(`\uD83D\uDCAC ${truncate3(p.agentRationale, 512)}`);
   }
   lines.push("");
-  lines.push("\u26a0\ufe0f Weak attestation (RFC \u00a78 v1): operator should click through to verify the actual change before approving. Structural diff coming v1.5.");
+  lines.push(p.changes && p.changes.length > 0 ? "\u26a0\ufe0f Attestation (RFC \u00a78 v1.5): the diff above is derived from live Graph state + the mutation payload. Verify before approving." : "\u26a0\ufe0f Weak attestation (RFC \u00a78 v1): operator should click through to verify the actual change before approving. Structural diff coming v1.5.");
   return hardenCardBreaks(lines.join(`
 `));
 }
 function truncate3(s, n) {
-  if (s.length <= n)
-    return s;
-  return s.slice(0, n - 1) + "\u2026";
+  const oneLine = s.replace(/[\r\n\t]+/g, " ");
+  if (oneLine.length <= n)
+    return oneLine;
+  return oneLine.slice(0, n - 1) + "\u2026";
 }
 function humanBytes(bytes) {
   const abs = Math.abs(bytes);
@@ -76431,6 +76788,28 @@ function workerAgentIdOfPinKey(pinKey) {
   const agentId = pinKey.slice(WORKER_PIN_KEY_PREFIX.length);
   return agentId.length > 0 ? agentId : null;
 }
+function storeOnlyWorkerPinCandidates(args) {
+  const out = [];
+  for (const r of args.rows) {
+    if (workerAgentIdOfPinKey(r.pinKey) == null)
+      continue;
+    if (r.pending)
+      continue;
+    if (r.expiresAt != null)
+      continue;
+    if (r.chatId.length === 0)
+      continue;
+    if (args.inMemoryPinKeys.has(r.pinKey))
+      continue;
+    out.push({
+      pinKey: r.pinKey,
+      chatId: r.chatId,
+      pinnedAt: args.now,
+      messageId: r.messageId
+    });
+  }
+  return out;
+}
 function decideWorkerPinReaps(args) {
   const reaps = [];
   for (const pin of args.pins) {
@@ -78164,6 +78543,7 @@ ${result}
     meta: {
       source: "subagent_handback",
       outcome: opts.ctx.outcome,
+      message_id: String(ts),
       ...opts.ctx.threadId != null ? { message_thread_id: String(opts.ctx.threadId) } : {},
       ...opts.ctx.jsonlAgentId ? { subagent_jsonl_id: opts.ctx.jsonlAgentId } : {}
     }
@@ -80002,6 +80382,7 @@ import {
 } from "node:fs";
 import { join as join39 } from "node:path";
 var TURN_ACTIVE_MARKER_FILE = "turn-active.json";
+var TURN_ACTIVE_HARD_TTL_MS = 10 * 60000;
 function touchTurnActiveMarker(stateDir) {
   const path2 = join39(stateDir, TURN_ACTIVE_MARKER_FILE);
   if (!existsSync34(path2))
@@ -83728,6 +84109,8 @@ import {
 } from "node:fs";
 import { join as join52 } from "node:path";
 var TURN_ACTIVE_MARKER_FILE2 = "turn-active.json";
+var TURN_ACTIVE_HARD_TTL_MS2 = 10 * 60000;
+var TURN_ACTIVE_IDLE_SWEEP_MS = 60000;
 function writeTurnActiveMarker(stateDir, marker) {
   try {
     mkdirSync37(stateDir, { recursive: true });
@@ -83794,12 +84177,15 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
     return null;
   }
 }
+function effectiveTurnAgeMs(markerAgeMs, turnStartedAt, now) {
+  return markerAgeMs ?? now - turnStartedAt;
+}
 
 // ../src/build-info.ts
-var VERSION = "0.18.26";
-var COMMIT_SHA = "ceb7d1a9";
-var COMMIT_DATE = "2026-07-15T11:05:52Z";
-var LATEST_PR = 3258;
+var VERSION = "0.18.28";
+var COMMIT_SHA = "ef0be9a2";
+var COMMIT_DATE = "2026-07-16T14:42:35+10:00";
+var LATEST_PR = 3274;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -86479,9 +86865,43 @@ var FEED_LIVENESS_OPEN_MS = (() => {
 var POST_ANSWER_LIVENESS_STALE_MS = parsePostAnswerLivenessMs(process.env.SWITCHROOM_POST_ANSWER_LIVENESS_STALE_MS) || 30000;
 function turnInFlightForGate() {
   const hasPendingApproval = pendingPermissions.size > 0;
+  return turnInFlightMachineOnly() || hasPendingApproval;
+}
+function turnInFlightMachineOnly() {
   if (!isDeliveryCutoverEnabled())
-    return claudeBusyKeys.size > 0 || hasPendingApproval;
-  return probeGateParity(isMachineInTurn(), claudeBusyKeys.size) || hasPendingApproval;
+    return claudeBusyKeys.size > 0;
+  return probeGateParity(isMachineInTurn(), claudeBusyKeys.size);
+}
+function liveTurnAgeMs(now) {
+  if (currentTurn === null)
+    return null;
+  return effectiveTurnAgeMs(readTurnActiveMarkerAgeMs(STATE_DIR, now), currentTurn.startedAt, now);
+}
+function oldestPendingApprovalAgeMs(now) {
+  let oldest = null;
+  for (const p of pendingPermissions.values()) {
+    const age = now - p.startedAt;
+    if (oldest === null || age > oldest)
+      oldest = age;
+  }
+  return oldest;
+}
+function resolveModelEffortBusy(now = Date.now()) {
+  const turnAgeMs = liveTurnAgeMs(now);
+  const resolved = resolveStaleAwareBusy({
+    currentTurnActive: currentTurn !== null,
+    turnAgeMs,
+    machineInTurn: turnInFlightMachineOnly(),
+    oldestPendingApprovalAgeMs: oldestPendingApprovalAgeMs(now),
+    hardTtlMs: TURN_ACTIVE_HARD_TTL_MS2
+  });
+  if (resolved.clearStaleTurn && currentTurn !== null) {
+    const ageSec = Math.round((turnAgeMs ?? 0) / 1000);
+    process.stderr.write(`telegram gateway: [phantomturn] cleared stale currentTurn atom age=${ageSec}s ttl=${Math.round(TURN_ACTIVE_HARD_TTL_MS2 / 1000)}s for /model|/effort busy-check agent=${getMyAgentName()}
+`);
+    clearAllCurrentTurns();
+  }
+  return { currentTurnActive: resolved.currentTurnActive, turnInFlight: resolved.turnInFlight };
 }
 function deliverResumeSyntheticOrBuffer(agent, inbound) {
   const decision = decideInboundDelivery({
@@ -86649,11 +87069,6 @@ function findTurnByQuotedMessageId(chatId, replyTo) {
     return null;
   return turn;
 }
-function deriveTurnId(chatId, threadId, messageId) {
-  if (messageId == null || messageId === "" || String(messageId) === "0")
-    return null;
-  return `${chatKey2(chatId, threadId ?? null)}#${messageId}`;
-}
 function findTurnByOriginId(originTurnId) {
   if (originTurnId == null || originTurnId === "")
     return null;
@@ -88479,8 +88894,8 @@ var pendingStateReaper = setInterval(() => {
   try {
     sweepStaleTurnActiveMarker(STATE_DIR, {
       turnInFlight: currentTurn?.registryKey != null,
-      idleSweepMs: 60000,
-      hardTtlMs: 600000,
+      idleSweepMs: TURN_ACTIVE_IDLE_SWEEP_MS,
+      hardTtlMs: TURN_ACTIVE_HARD_TTL_MS2,
       now,
       onRemove: ({ ageMs, reason, payload }) => {
         const agent = getMyAgentName();
@@ -88927,11 +89342,16 @@ async function runMidSessionCardReaper() {
         isLive: (record2) => topicKeys.has(record2.turnKey),
         ttlMs: MID_SESSION_CARD_REAPER_TTL_MS,
         now,
-        finalizeCard: (record2) => robustApiCall(() => lockedBot.api.editMessageText(record2.chatId, record2.activityMessageId, richMessage2(restartOrphanCardFinalizeText(record2.startedAt)), {}), {
-          chat_id: record2.chatId,
-          ...record2.threadId != null ? { threadId: record2.threadId } : {},
-          verb: "activity-card.mid-session-reap-finalize"
-        }),
+        finalizeCard: (record2) => {
+          if (handbackPreturnSignal.isPreTurnRecord(record2.turnKey)) {
+            handbackPreturnSignal.handleReaped(record2.turnKey);
+          }
+          return robustApiCall(() => lockedBot.api.editMessageText(record2.chatId, record2.activityMessageId, richMessage2(restartOrphanCardFinalizeText(record2.startedAt)), {}), {
+            chat_id: record2.chatId,
+            ...record2.threadId != null ? { threadId: record2.threadId } : {},
+            verb: "activity-card.mid-session-reap-finalize"
+          });
+        },
         unpinCard: async (record2) => {
           const pinKey = `fg:${record2.turnKey}`;
           if (statusPinState.has(pinKey)) {
@@ -88956,11 +89376,19 @@ async function runMidSessionCardReaper() {
   }
   if (WORKER_PIN_REAPER_ENABLED && PIN_STATUS_WHILE_WORKING) {
     try {
-      const candidates = [...statusPinState.keys()].filter((k) => k.startsWith("wk:")).map((k) => ({
+      const inMemoryKeys = new Set([...statusPinState.keys()].filter((k) => k.startsWith("wk:")));
+      const inMemoryCandidates = [...inMemoryKeys].map((k) => ({
         pinKey: k,
         chatId: statusPinChatIds.get(k) ?? "",
         pinnedAt: statusPinPinnedAt.get(k) ?? now
       }));
+      const storeOnlyCandidates = statusPinPersistEnabled ? storeOnlyWorkerPinCandidates({
+        rows: loadStatusPins(STATUS_PIN_STORE_PATH, statusPinStoreFs),
+        inMemoryPinKeys: inMemoryKeys,
+        now
+      }) : [];
+      const storeOnlyKeys = new Set(storeOnlyCandidates.map((c) => c.pinKey));
+      const candidates = [...inMemoryCandidates, ...storeOnlyCandidates];
       const reaps = decideWorkerPinReaps({
         pins: candidates,
         statusOf: (agentId) => {
@@ -88987,9 +89415,20 @@ async function runMidSessionCardReaper() {
         now
       });
       for (const reap of reaps) {
-        process.stderr.write(`telegram gateway: worker-pin reaper unpinning ${reap.pinKey} (chat=${reap.chatId} reason=${reap.reason})
+        const storeOnly = storeOnlyKeys.has(reap.pinKey);
+        process.stderr.write(`telegram gateway: worker-pin reaper unpinning ${reap.pinKey} (chat=${reap.chatId} reason=${reap.reason}${storeOnly ? " source=store-orphan" : ""})
 `);
-        await reconcileStatusPin(reap.pinKey, reap.chatId, { pinned: false });
+        if (storeOnly && reap.messageId != null) {
+          try {
+            await statusPinApi().unpinChatMessage(reap.chatId, reap.messageId);
+          } catch (err) {
+            process.stderr.write(`telegram gateway: worker-pin reaper store-orphan unpin failed (${reap.pinKey} chat=${reap.chatId} msg=${reap.messageId}): ${err.message}
+`);
+          }
+          await mutateStatusPinRow(STATUS_PIN_STORE_PATH, statusPinStoreFs, reap.pinKey, null);
+        } else {
+          await reconcileStatusPin(reap.pinKey, reap.chatId, { pinned: false });
+        }
       }
     } catch (err) {
       process.stderr.write(`telegram gateway: worker-pin reaper error: ${err.message}
@@ -89411,6 +89850,8 @@ var _deliveryMachineTick = setInterval(() => {
 }, DELIVERY_MACHINE_TICK_MS);
 _deliveryMachineTick.unref?.();
 function trackRedeliveredInbound(merged) {
+  if (HANDBACK_PRETURN_ENABLED)
+    handbackPreturnSignal.noteHandbackRelease(merged);
   if (!DELIVERY_CONFIRM_ENABLED)
     return;
   const isTrackableResume = isTrackableResumeSynthetic(merged.meta);
@@ -91090,6 +91531,7 @@ async function executeReply(args) {
       return { content: [{ type: "text", text: "sent (deduped \u2014 same content sent via earlier path)" }] };
     }
   }
+  let supersedeFlushIds = [];
   {
     const replyThreadId = args.message_thread_id != null ? Number(args.message_thread_id) : undefined;
     const ownerTurn = resolveReplyOwnerTurn(turn, chat_id, args);
@@ -91098,9 +91540,9 @@ async function executeReply(args) {
     if (decision.supersede) {
       process.stderr.write(`telegram gateway: reply: superseding flushed turn message(s) chatId=${chat_id} ids=${JSON.stringify(decision.deleteMessageIds)}
 `);
-      for (const id of decision.deleteMessageIds) {
-        await swallowingApiCall(() => lockedBot.api.deleteMessage(chat_id, id), { chat_id, verb: "reply.supersedeFlushed" });
-      }
+      supersedeFlushIds = decision.deleteMessageIds;
+      if (ownerTurn != null)
+        ownerTurn.answerDelivered = true;
     } else {
       const replySubstantive = isSubstantiveFinalReply({
         text: rawText,
@@ -91328,6 +91770,25 @@ ${url}`;
       });
     }
   }
+  if (supersedeFlushIds.length > 0) {
+    const correction = decideSupersedeCorrection({
+      flushMessageIds: supersedeFlushIds,
+      chunkCount: chunks.length,
+      hasFiles: files.length > 0,
+      suppressText,
+      hasOpenPreview: previewMessageId != null
+    });
+    if (correction.mode === "edit-in-place") {
+      previewMessageId = correction.editMessageId;
+      reply_to = undefined;
+      process.stderr.write(`telegram gateway: reply: superseding flushed message via edit-in-place chatId=${chat_id} id=${correction.editMessageId}
+`);
+    } else {
+      for (const id of correction.deleteMessageIds) {
+        await swallowingApiCall(() => lockedBot.api.deleteMessage(chat_id, id), { chat_id, verb: "reply.supersedeFlushed" });
+      }
+    }
+  }
   if (previewMessageId != null && reply_to != null && replyMode !== "off") {
     await deleteStalePreview(previewMessageId);
     previewMessageId = null;
@@ -91336,7 +91797,7 @@ ${url}`;
   let silentAnchorEditDone = false;
   {
     const turn2 = currentTurn;
-    if (turn2 != null && chunks.length === 1) {
+    if (turn2 != null && chunks.length === 1 && supersedeFlushIds.length === 0) {
       const decision = decideSilentReplyAnchor({
         effectivelySilent: disableNotification,
         anchorMessageId: turn2.silentAnchorMessageId,
@@ -93151,6 +93612,61 @@ function clearActivitySummary(turn, finalHtmlOverride) {
     }
   });
 }
+var HANDBACK_PRETURN_ENABLED = !STATIC && process.env.SWITCHROOM_HANDBACK_PRETURN !== "0";
+var HANDBACK_PRETURN_HTML = "\uD83E\uDD1D Reading the worker\u2019s results\u2026";
+var HANDBACK_PRETURN_ORPHAN_HTML = "\uD83E\uDD1D A background worker finished, but the handback never started \u2014 it may need a nudge.";
+async function openHandbackPreTurnCard(chatId, threadId) {
+  if (STATIC)
+    return null;
+  try {
+    const sent = await robustApiCall(() => bot.api.sendRichMessage(chatId, richMessage2(HANDBACK_PRETURN_HTML), {
+      ...threadId != null ? { message_thread_id: threadId } : {},
+      disable_notification: true
+    }), {
+      chat_id: chatId,
+      ...threadId != null ? { threadId } : {},
+      verb: "handback-preturn.send"
+    });
+    return sent?.message_id ?? null;
+  } catch (err) {
+    process.stderr.write(`telegram gateway: handback pre-turn card send failed: ${err.message}
+`);
+    return null;
+  }
+}
+function finalizeHandbackPreTurnCard(record2) {
+  return robustApiCall(() => bot.api.editMessageText(record2.chatId, record2.activityMessageId, richMessage2(HANDBACK_PRETURN_ORPHAN_HTML), {}), {
+    chat_id: record2.chatId,
+    ...record2.threadId != null ? { threadId: record2.threadId } : {},
+    verb: "handback-preturn.orphan-finalize"
+  }).then(() => {
+    return;
+  }).catch(() => {
+    return;
+  });
+}
+var handbackPreturnSignal = createHandbackPreturnSignal({
+  chatKey: (chatId, threadId) => chatKey2(chatId, threadId),
+  deriveTurnId: (chatId, threadId, messageId) => deriveTurnId(chatId, threadId, messageId),
+  startTypingLoop: (chatId, threadId) => startTurnTypingLoop(chatId, threadId),
+  stopTypingLoop: (chatId, threadId) => stopTurnTypingLoop(chatId, threadId),
+  openCard: openHandbackPreTurnCard,
+  finalizeCard: finalizeHandbackPreTurnCard,
+  writeCardRecord: (record2) => {
+    if (!activityCardPersistEnabled)
+      return;
+    writeActivityCardRecord(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs, record2);
+  },
+  clearCardRecord: (turnKey2, activityMessageId) => {
+    if (!activityCardPersistEnabled)
+      return;
+    clearActivityCardRecord(ACTIVITY_CARD_STORE_PATH, activityCardStoreFs, turnKey2, activityMessageId);
+  },
+  isTurnSettled: (key) => {
+    const live = currentTurnMap.get(key);
+    return live != null && (live.finalAnswerDelivered || live.endedAt != null);
+  }
+});
 var memoryLegibilityStager = new MemoryLegibilityStager;
 function sendMemoryLegibilityLine(event, chatId, threadId) {
   const line = renderMemoryLegibilityLine(event);
@@ -93304,6 +93820,16 @@ function handleSessionEvent(ev) {
           emissionAuthority: new EmissionAuthority(statusKey(ev.chatId, enqThreadIdNum))
         };
         next.narrativeGate = makeNarrativeGate(next);
+        if (HANDBACK_PRETURN_ENABLED) {
+          const handbackAdoption = handbackPreturnSignal.tryAdopt(turnId);
+          if (handbackAdoption != null) {
+            if (handbackAdoption.activityMessageId != null) {
+              next.activityMessageId = handbackAdoption.activityMessageId;
+              next.activityEverOpened = true;
+            }
+            startTurnTypingLoop(ev.chatId, enqThreadIdNum ?? null);
+          }
+        }
         setCurrentTurn(next, statusKey(ev.chatId, enqThreadIdNum));
         scheduleEarlyLivenessOpen(next);
         process.stderr.write(`telegram gateway: ${formatTurnLifecycle("set", "enqueue", next, startedAt)}
@@ -96350,7 +96876,8 @@ bot.command("model", async (ctx) => {
   const parsed = parseModelCommand(text5) ?? { kind: "show" };
   const chatId = String(ctx.chat.id);
   const threadId = resolveThreadId(chatId, ctx.message?.message_thread_id);
-  const busyNow = currentTurn !== null || turnInFlightForGate();
+  const modelBusy = resolveModelEffortBusy();
+  const busyNow = modelBusy.currentTurnActive || modelBusy.turnInFlight;
   process.stderr.write(modelCommandReceiptLine(getMyAgentName(), parsed, busyNow) + `
 `);
   if (HISTORY_ENABLED && ctx.message?.message_id != null) {
@@ -96371,8 +96898,8 @@ bot.command("model", async (ctx) => {
   }
   const deps = buildModelDeps({ chatId, threadId });
   const disposition = planModelCommand(parsed, {
-    currentTurnActive: currentTurn !== null,
-    turnInFlight: turnInFlightForGate(),
+    currentTurnActive: modelBusy.currentTurnActive,
+    turnInFlight: modelBusy.turnInFlight,
     menuEnabled: process.env.SWITCHROOM_MODEL_MENU !== "0"
   });
   if (disposition.kind === "menu") {
@@ -96443,7 +96970,8 @@ bot.command("effort", async (ctx) => {
     await switchroomReply(ctx, menu.text, { html: true, reply_markup: effortMenuReplyMarkup(menu) });
     return;
   }
-  if ((parsed.kind === "set" || parsed.kind === "default") && currentTurn !== null) {
+  const effortBusy = resolveModelEffortBusy();
+  if ((parsed.kind === "set" || parsed.kind === "default") && effortBusy.currentTurnActive) {
     const requestedLevel = parsed.kind === "set" ? parsed.level : "default";
     const chatId = String(ctx.chat.id);
     const threadId = resolveThreadId(chatId, ctx.message?.message_thread_id);