botmux 3.16.0 → 3.17.0

package/dist/core/worker-pool.js

@@ -36,6 +36,8 @@ import { hasUnprovenContainment } from './mojo-containment.js';
 import { MOJO_EXPLICIT_CLOSE_RESULT_TIMEOUT_MS } from '../adapters/backend/mojo-budgets.js';
 import { buildEffectiveMojoConfig, diffMojoSessionIdentity, MOJO_IDENTITY_KEYS, pickMojoLivePatch, isMojoRemoteGone, mojoUnprovableEnvKeys, pickMojoSessionIdentity, } from '../adapters/backend/mojo-types.js';
 import { sanitizePerBotEnv } from './per-bot-env.js';
+import { normalizeExistingAppServerEndpoint } from './existing-app-server.js';
+import { isExistingAppServerSharedAdoptPersistedSession, isSharedAdoptPersistedSession, isSharedAdoptSession, } from './shared-adopt.js';
 import { closeResidualClause } from './close-residual.js';
 import { logger } from '../utils/logger.js';
 import { createCliAdapterSync } from '../adapters/cli/registry.js';
@@ -308,7 +310,7 @@ import { hasProtectedSessionMutationOwnership } from './session-mutation-guard.j
 import { DONE_REACTION_EMOJI_TYPE } from './pending-response.js';
 import { buildTerminalUrl } from './terminal-url.js';
 import { prependBotmuxBin, resolveBotmuxWrapperBinDir } from './botmux-wrapper.js';
-import { usageLimitStateKey } from '../utils/cli-usage-limit.js';
+import { usageLimitStateKey, isActiveWorkRuntimeStatus } from '../utils/cli-usage-limit.js';
 import { evaluateVcMeetingManagedSend, resolveVcMeetingImTurnOrigin, } from '../services/vc-meeting-send-policy.js';
 import { finishVcMeetingImReply, prepareVcMeetingDeliveryReply, prepareVcMeetingImReply, } from '../services/vc-meeting-im-reply.js';
 import { neutralizeLarkAtTags } from '../services/send-policy.js';
@@ -327,6 +329,7 @@ import { recordDispatchInputCommit } from './dispatch.js';
 import { sendWorkerIpc } from './worker-ipc.js';
 import { cleanupExplicitSessionBacking } from './explicit-session-backing-cleanup.js';
 import { REMOTE_ADMISSION_RESTORE_TIMEOUT_MS } from './shutdown-budgets.js';
+import { MAX_STARTUP_AUTO_RETRIES, isTransientStartupFailure, startupAutoRetryDelayMs, } from './worker-startup-retry.js';
 import { managedOriginCapabilityPath, replaceManagedOriginCapabilityFile, } from './managed-origin-capability.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -570,7 +573,7 @@ function scheduleLocalCliOpenReadinessPatch(ds) {
     const botCfg = getBot(ds.larkAppId).config;
     const effectiveCliId = sessionCliId(ds, botCfg);
     const status = ds.usageLimit ? 'limited' : (ds.lastScreenStatus ?? 'starting');
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     scheduleCardPatch(ds, cardJson);
 }
 function flushPendingLocalCliOpenReadinessPatch(ds) {
@@ -582,7 +585,7 @@ function flushPendingLocalCliOpenReadinessPatch(ds) {
 /** PATCH the live card when the executor reports a different active runtime.
  * Runtime identity stays attached to the streaming usage line. */
 function scheduleActiveRuntimePatch(ds) {
-    if (ds.session.vcMeetingReceiver || streamingCardDisabled(ds) || ds.suppressRecoveryCard) {
+    if (streamingCardDisabled(ds) || ds.suppressRecoveryCard) {
         ds.pendingActiveRuntimeCardRefresh = undefined;
         return;
     }
@@ -602,7 +605,7 @@ function scheduleActiveRuntimePatch(ds) {
     const botCfg = getBot(ds.larkAppId).config;
     const effectiveCliId = sessionCliId(ds, botCfg);
     const status = ds.usageLimit ? 'limited' : (ds.lastScreenStatus ?? 'starting');
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     scheduleCardPatch(ds, cardJson);
 }
 function flushPendingActiveRuntimePatch(ds) {
@@ -613,7 +616,7 @@ function flushPendingActiveRuntimePatch(ds) {
 }
 /** PATCH a live card when rollout settings change, even if the PTY is static. */
 function scheduleCodexServiceTierPatch(ds) {
-    if (ds.session.vcMeetingReceiver || streamingCardDisabled(ds) || ds.suppressRecoveryCard) {
+    if (streamingCardDisabled(ds) || ds.suppressRecoveryCard) {
         ds.pendingCodexTierCardRefresh = undefined;
         return;
     }
@@ -633,7 +636,7 @@ function scheduleCodexServiceTierPatch(ds) {
     const botCfg = getBot(ds.larkAppId).config;
     const effectiveCliId = sessionCliId(ds, botCfg);
     const status = ds.usageLimit ? 'limited' : (ds.lastScreenStatus ?? 'starting');
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), buildTerminalUrl(ds), ds.currentTurnTitle || ds.session.title || getCliDisplayName(effectiveCliId), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), buildTerminalUrl(ds), ds.currentTurnTitle || ds.session.title || getCliDisplayName(effectiveCliId), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     scheduleCardPatch(ds, cardJson);
 }
 /** How often the live streaming card is re-PATCHed with fresh usage while a
@@ -692,7 +695,7 @@ export function refreshStreamingCardUsage(ds) {
     // run for a port=0 backend (ZMX reports ready without a Web Terminal), a raw
     // URL would render a fake `:undefined`/backend-less link. Mirror every other
     // card path — empty string when there is no real terminal.
-    readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', ds.lastScreenStatus ?? 'working', effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), cardUsageLimit(ds), writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), 
+    readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', ds.lastScreenStatus ?? 'working', effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), cardUsageLimit(ds), writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), 
     // fresh:true — the whole point of the tick is to break the 15s throttle so
     // the total/turn usage actually climbs on-screen every interval.
     getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId, { fresh: true }), sessionRuntimeDisplayName(ds, botCfg), 
@@ -764,7 +767,7 @@ export function scheduleRiffAccessUrlPatch(ds) {
     const botCfg = getBot(ds.larkAppId).config;
     const effectiveCliId = sessionCliId(ds, botCfg);
     const status = ds.usageLimit ? 'limited' : (ds.lastScreenStatus ?? 'starting');
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), buildTerminalUrl(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), buildTerminalUrl(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     scheduleCardPatch(ds, cardJson);
 }
 function flushPendingRiffUrlPatch(ds) {
@@ -786,9 +789,7 @@ function sessionCliId(ds, botCfg) {
 function ordinaryTurnRecoveryEligible(ds, botCfg = getBot(ds.larkAppId).config) {
     return sessionCliId(ds, botCfg) === 'claude-code'
         && ds.session.status === 'active'
-        && !ds.adoptedFrom
-        && !ds.session.adoptedFrom
-        && ds.initConfig?.adoptMode !== true
+        && !isSharedAdoptSession(ds)
         && !ds.session.vcMeetingReceiver
         && larkTransportEnabled({ chatId: ds.chatId, apiOnly: botCfg.apiOnly });
 }
@@ -1267,11 +1268,6 @@ export function cardUsageLimit(ds) {
     return ds.lastScreenStatus === 'limited' ? ds.usageLimit : undefined;
 }
 function scheduleUsageLimitCardPatch(ds) {
-    // Dedicated VC receivers keep limit state for dashboard/audit only. A timer
-    // must never revive or mutate an old/manual Lark card after the synchronous
-    // screen_update path has already suppressed auxiliary UI.
-    if (ds.session.vcMeetingReceiver)
-        return;
     if (ds.lastScreenStatus !== 'limited')
         return;
     if (!ds.streamCardId || ds.streamCardId === CARD_POSTING_SENTINEL || !workerHasInitialized(ds))
@@ -1280,7 +1276,7 @@ function scheduleUsageLimitCardPatch(ds) {
     const effectiveCliId = sessionCliId(ds, bot.config);
     const readUrl = readableTerminalUrlFor(ds);
     const turnTitle = ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, bot.config);
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, turnTitle, ds.lastScreenContent ?? '', 'limited', effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), ds.usageLimit, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, bot.config), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, turnTitle, ds.lastScreenContent ?? '', 'limited', effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), ds.usageLimit, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, bot.config), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     scheduleCardPatch(ds, cardJson);
 }
 function armUsageLimitRetryTimer(ds, previous) {
@@ -1328,6 +1324,31 @@ function updateUsageLimitState(ds, usageLimit) {
     persistStreamCardState(ds);
     armUsageLimitRetryTimer(ds, previous);
 }
+/**
+ * Resolve the daemon-side screen status in the presence of a usage limit.
+ *
+ * Limit state is intentionally sticky across ticks that carry no fresh verdict
+ * (the worker re-emits only while the limit text stays on screen; screenshot
+ * ticks arrive every 10s), so a recorded limit survives ordinary idle frames
+ * and the cooldown card stays up until the user retries. But it must
+ * self-heal on evidence of active work: a blocked CLI does not produce
+ * `working`/`analyzing` frames, so a limit that survives such a frame was a
+ * false positive (a flicker-frame screen scan, or a structured emit the CLI
+ * recovered from). Without this the card keeps showing 「限额已达」 for the
+ * rest of the turn even though the CLI is demonstrably still running — the
+ * reported 误报. The worker-side status gate (detectScreenUsageLimit) prevents
+ * the detection while active; this is the daemon-side net for limits recorded
+ * during an idle flicker before work resumed.
+ */
+function resolveUsageAwareScreenStatus(ds, workerStatus, freshUsageLimit) {
+    if (freshUsageLimit)
+        return 'limited';
+    if (ds.usageLimit && isActiveWorkRuntimeStatus(workerStatus)) {
+        clearUsageLimitState(ds);
+        return workerStatus;
+    }
+    return ds.usageLimit ? 'limited' : workerStatus;
+}
 const WORKER_ERROR_MARKER = '[botmux-worker-error]';
 function logWorkerStderr(t, line) {
     if (!line)
@@ -1475,7 +1496,7 @@ function reconcilePostedStartingCard(ds, turnId, revisionAtPost) {
     const botCfg = getBot(ds.larkAppId).config;
     const effectiveCliId = sessionCliId(ds, botCfg);
     const status = ds.usageLimit ? 'limited' : (ds.lastScreenStatus ?? turnStartingCardStatus(ds, effectiveCliId));
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId, { fresh: status === 'idle' }), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), status === 'limited' ? ds.usageLimit : undefined, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId, { fresh: status === 'idle' }), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     scheduleCardPatch(ds, cardJson, turnId);
 }
 /**
@@ -1495,7 +1516,7 @@ export async function postTurnStartingCard(ds, sessionReply, turnId) {
         return false;
     if (ds.streamCardId === CARD_POSTING_SENTINEL)
         return false;
-    if (ds.session.vcMeetingReceiver || streamingCardDisabled(ds, turnId))
+    if (streamingCardDisabled(ds, turnId))
         return false;
     if (!workerHasInitialized(ds))
         return false;
@@ -1519,7 +1540,7 @@ export async function postTurnStartingCard(ds, sessionReply, turnId) {
     const nonce = randomBytes(4).toString('hex');
     const status = turnStartingCardStatus(ds, effectiveCliId);
     const statusRevisionAtPost = ds.streamCardStatusRevision ?? 0;
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), '', status, effectiveCliId, ds.displayMode ?? 'hidden', nonce, undefined, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), ds.usageLimit, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), '', status, effectiveCliId, ds.displayMode ?? 'hidden', nonce, undefined, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), ds.usageLimit, writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     ds.streamCardNonce = nonce;
     ds.streamCardId = CARD_POSTING_SENTINEL;
     const ownsPostIdentity = () => ds.session === sessionAtPost
@@ -1600,10 +1621,6 @@ export async function postTurnStartingCard(ds, sessionReply, turnId) {
  * that so the card keeps live-patching afterwards even when the bot opted out.
  */
 export async function postFreshStreamingCard(ds, sessionReply) {
-    // Receiver terminals can contain meeting-derived private context. Never
-    // publish one into the listener chat as a streaming-card side channel.
-    if (ds.session.vcMeetingReceiver)
-        return false;
     if (isDocNativeSession(ds))
         return false;
     if (!workerHasInitialized(ds))
@@ -1624,7 +1641,7 @@ export async function postFreshStreamingCard(ds, sessionReply) {
     const prevPending = ds.streamCardPending;
     const cardReplyTarget = captureStreamingCardReplyTarget(ds);
     ds.streamCardNonce = randomBytes(4).toString('hex');
-    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, title, ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, !!ds.adoptedFrom, false, localeForBot(ds.larkAppId), cardUsageLimit(ds), writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+    const cardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readUrl, title, ds.lastScreenContent ?? '', status, effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), cardUsageLimit(ds), writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
     ds.streamCardId = CARD_POSTING_SENTINEL;
     try {
         ds.streamCardId = await sessionReply(sessionAnchorId(ds), cardJson, 'interactive', ds.larkAppId, cardReplyTarget.turnId);
@@ -1773,7 +1790,7 @@ export function buildWritableTerminalCard(ds) {
     if (ds.riffAccessUrl) {
         const botCfg = getBot(ds.larkAppId).config;
         const effectiveCliId = sessionCliId(ds, botCfg);
-        return buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), ds.riffAccessUrl, ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, true, !!ds.adoptedFrom, localeForBot(ds.larkAppId), false, sessionRuntimeDisplayName(ds, botCfg));
+        return buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), ds.riffAccessUrl, ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, true, isSharedAdoptSession(ds), localeForBot(ds.larkAppId), false, sessionRuntimeDisplayName(ds, botCfg));
     }
     const port = ds.workerPort ?? ds.session.webPort;
     if (!port || !ds.workerToken)
@@ -1781,7 +1798,7 @@ export function buildWritableTerminalCard(ds) {
     const botCfg = getBot(ds.larkAppId).config;
     const effectiveCliId = sessionCliId(ds, botCfg);
     return buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), buildTerminalUrl(ds, { write: true }), ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, true, // showManageButtons — write-link card includes restart & close
-    !!ds.adoptedFrom, // adoptMode — disconnect, never close-the-CLI
+    isSharedAdoptSession(ds), // shared adopt — disconnect, never close the source conversation
     localeForBot(ds.larkAppId), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), sessionRuntimeDisplayName(ds, botCfg));
 }
 /**
@@ -1852,7 +1869,7 @@ function buildSubstituteControlCard(ds) {
     const botCfg = getBot(ds.larkAppId).config;
     const effectiveCliId = sessionCliId(ds, botCfg);
     return buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), '', // Manage-only: this backend intentionally has no Web Terminal URL.
-    ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, true, !!ds.adoptedFrom, localeForBot(ds.larkAppId), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), sessionRuntimeDisplayName(ds, botCfg));
+    ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, true, isSharedAdoptSession(ds), localeForBot(ds.larkAppId), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), sessionRuntimeDisplayName(ds, botCfg));
 }
 /**
  * DM a control card to the bot's owner(s) for a substitute-mode session.
@@ -2052,8 +2069,14 @@ export const restartCounts = new Map();
 /** Track which CLI adapters have had skills installed this daemon lifecycle */
 const skillsInstalledCliIds = new Set();
 /**
- * Ensure built-in skills are installed for a given CLI.
- * Synchronous and idempotent — runs once per CLI per daemon lifecycle.
+ * Ensure built-in skills are installed for a given CLI. Synchronous and
+ * idempotent. Two cadences:
+ *   - Skill FILES (whiteboard / workflow family / built-in skills) are
+ *     re-evaluated on EVERY spawn, before the `skillsInstalledCliIds` gate, so
+ *     runtime switches (whiteboard, workflow) and user customization (skill body
+ *     override / disable) take effect on the next session without a restart.
+ *   - Hook install + botmux-ask fallback do not vary at runtime, so they run
+ *     once per CLI per daemon lifecycle (behind the gate).
  */
 export function ensureCliSkills(cliId, cliPathOverride) {
     const adapter = createCliAdapterSync(cliId, cliPathOverride);
@@ -2074,9 +2097,15 @@ export function ensureCliSkills(cliId, cliPathOverride) {
         // Workflow skill 家族同理：跟随机器级 workflow 开关，每次 spawn 重新评估，
         // 关闭时删除已装的三个 skill，下一个会话即生效。
         ensureWorkflowSkills(cliId, pluginSkillsDir, isWorkflowFeatureEnabled());
+        // 内置 skill 文件跟随用户自定义（正文覆盖 / 停用），必须每次 spawn 重新落盘
+        // ——与上面白板 / workflow 同样放在 once-cache 之前，否则改了 skill 正文或
+        // 停用某 skill 后，claude 家族（--plugin-dir）的新会话仍读旧文件、要等 daemon
+        // 重启才生效，和自定义页「下一个会话即生效」不符。ensureSkills 幂等（内容相同
+        // 则跳过），每次 spawn 的代价只是几个小文件的读比对。
+        ensurePluginSkills(cliId, adapter.pluginDir);
         if (skillsInstalledCliIds.has(cliId))
             return;
-        ensurePluginSkills(cliId, adapter.pluginDir);
+        // Hook 接管与 botmux-ask 兜底 skill 不随自定义变化 → 每个 daemon 生命周期装一次即可。
         if (adapter.hookInstall) {
             try {
                 installHook(cliId, adapter.hookInstall, hookCommandFor(cliId));
@@ -2118,12 +2147,15 @@ export function ensureCliSkills(cliId, cliPathOverride) {
     ensureWorkflowSkills(cliId, skillsDir, globalInstall && isWorkflowFeatureEnabled());
     if (!globalInstall && skillsDir)
         removeGlobalBotmuxSkills(skillsDir);
-    if (skillsInstalledCliIds.has(cliId))
-        return;
-    // 安装是稳定动作，留在 once-cache 里跑一次即可（幂等，内容相同不重写）。
+    // 内置 skill 文件跟随用户自定义（正文覆盖 / 停用），必须每次 spawn 重新落盘
+    // ——同白板 / workflow 放在 once-cache 之前。global 模式落全局盘；幂等（内容相同
+    // 则跳过），停用的 skill 目录会被 ensureSkills 内部清掉，下一个会话即生效。
     if (globalInstall)
         ensureSkills(cliId, skillsDir);
-    // askUserQuestion 接管策略与 skill 文件无关：hook 该装还得装（Codex 无 hook，
+    if (skillsInstalledCliIds.has(cliId))
+        return;
+    // 以下都不随自定义变化 → 每个 daemon 生命周期装一次即可。
+    // askUserQuestion 接管策略与 skill 文件无关：hook 该装还得装（Codex 无 hook,
     // 靠 botmux-ask skill / catalog 兜底）。
     if (adapter.hookInstall) {
         try {
@@ -2518,7 +2550,7 @@ export async function detachWorkerForTransfer(ds, opts = {}) {
  * adopt-skip decision is unit-testable without spawning a worker.
  */
 export function shouldDestroyPaneBeforeRestart(ds) {
-    return !ds.initConfig?.adoptMode && !ds.adoptedFrom;
+    return !isSharedAdoptSession(ds);
 }
 /**
  * Destroy a still-alive persistent backing pane (tmux/herdr/zellij/zmx) before a
@@ -2818,7 +2850,12 @@ function resolveMojoCancelLaunch(ds, remoteId, label) {
     };
 }
 function destroyOrphanedBackingSession(ds, opts = {}) {
-    if (ds.initConfig?.adoptMode || ds.adoptedFrom)
+    // Traditional `/adopt` observes a user-owned tmux/zellij/Herdr target and
+    // must never destroy it. An App Server shared adopt is different: its
+    // persistent bmx-* pane is BotMux's own `codex --remote` client, so reclaim
+    // that pane while leaving the external App Server untouched.
+    if (!isExistingAppServerSharedAdoptPersistedSession(ds.session)
+        && isSharedAdoptSession(ds))
         return;
     reclaimParkedCrashDiagnostic(ds);
     // Riff cancellation is asynchronous and cannot be made safe from this
@@ -3464,7 +3501,8 @@ async function prepareRiffExplicitClose(ds, stored) {
     }
     if (backendType !== 'riff')
         return { ok: true };
-    if (ds?.initConfig?.adoptMode || ds?.adoptedFrom || session.adoptedFrom)
+    if ((ds && isSharedAdoptSession(ds))
+        || isSharedAdoptPersistedSession(session))
         return { ok: true };
     if (ds?.worker && !ds.worker.killed) {
         if (!stored || stored.status !== 'active') {
@@ -3562,7 +3600,8 @@ async function prepareMojoExplicitClose(ds, stored) {
     const session = ds?.session ?? stored;
     if (!session)
         return { ok: true };
-    if (ds?.initConfig?.adoptMode || ds?.adoptedFrom || session.adoptedFrom)
+    if ((ds && isSharedAdoptSession(ds))
+        || isSharedAdoptPersistedSession(session))
         return { ok: true };
     // A row whose lineage was PARKED (restore-time quarantine moves the id here and
     // clears the active slot) still has a remote session running. It is reported as
@@ -4385,9 +4424,8 @@ function teardownAuthoritativePersistentBackingBeforeCloseImpl(target, closeWins
     }
     const backendType = ds ? getSessionPersistentBackendType(ds) : session.backendType;
     if (backendType !== 'zmx'
-        || ds?.initConfig?.adoptMode
-        || ds?.adoptedFrom
-        || session.adoptedFrom
+        || (ds && isSharedAdoptSession(ds))
+        || isSharedAdoptPersistedSession(session)
         || session.queued
         || session.status === 'closed')
         return;
@@ -4396,6 +4434,16 @@ function teardownAuthoritativePersistentBackingBeforeCloseImpl(target, closeWins
 export function teardownAuthoritativePersistentBackingBeforeClose(target) {
     teardownAuthoritativePersistentBackingBeforeCloseImpl(target, false);
 }
+/** Render the live streaming-card JSON for `ds` (🖥️ header + usage line +
+ *  显示输出/终端/关闭会话 buttons). Factored so callers outside the normal
+ *  screen-update flow — notably the Lark 恢复会话 button — can restore the SAME
+ *  card the session had while running, instead of a stripped-down variant.
+ *  `status` defaults to the session's last known screen status. */
+export function buildStreamingCardJson(ds, status) {
+    const botCfg = getBot(ds.larkAppId).config;
+    const effectiveCliId = sessionCliId(ds, botCfg);
+    return buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readableTerminalUrlFor(ds), ds.currentTurnTitle || ds.session.title || sessionCliDisplayName(ds, botCfg), ds.lastScreenContent ?? '', status ?? ds.lastScreenStatus ?? 'starting', effectiveCliId, ds.displayMode ?? 'hidden', ds.streamCardNonce, ds.currentImageKey, isSharedAdoptSession(ds), false, localeForBot(ds.larkAppId), cardUsageLimit(ds), writableTerminalLinkFor(ds), isLocalCliOpenReady(ds, { cliId: effectiveCliId }), getDaemonStreamingCardUsageSnapshot(ds, effectiveCliId), sessionRuntimeDisplayName(ds, botCfg), codexServiceTierBadge(effectiveCliId, ds.codexServiceTier));
+}
 /**
  * Close from a BACKGROUND path — one with no user surface to report to
  * (trigger-session cleanup, deferred-schedule settlement, sweeps).
@@ -4425,14 +4473,22 @@ export async function closeSessionForBackgroundCleanup(sessionId, context) {
     }
     return result;
 }
-export async function closeSession(sessionId) {
+export async function closeSession(sessionId, opts) {
+    // `awaitWorkerExit` (default true): whether to block on the worker process
+    // actually exiting before returning. A busy CLI wedges in node-pty teardown
+    // and only dies at the ~7s SIGKILL backstop, so callers behind a tight ACK
+    // window (the Lark card "关闭会话" button, whose callback must ACK inside ~3s
+    // or the client surfaces the "code: 300000" toast) pass false: the logical
+    // close below is fully synchronous, and killWorker already armed the kill
+    // backstop, so the worker WILL die in the background — the caller need not
+    // wait for it. Bridge-marker cleanup still runs, deferred behind the fence.
+    const awaitWorkerExit = opts?.awaitWorkerExit ?? true;
     const ds = findActiveBySessionId(sessionId);
     const stored = sessionStore.getOwnedSession(sessionId);
     const closeFrozenBackendType = ds?.initConfig?.backendType
         ?? ds?.session.backendType ?? stored?.backendType;
-    const isOwnedClose = !ds?.initConfig?.adoptMode
-        && !ds?.adoptedFrom
-        && !stored?.adoptedFrom;
+    const isOwnedClose = !(ds && isSharedAdoptSession(ds))
+        && !(stored && isSharedAdoptPersistedSession(stored));
     const isOwnedRiffClose = isOwnedClose && closeFrozenBackendType === 'riff';
     const isOwnedMojoClose = isOwnedClose && closeFrozenBackendType === 'mojo';
     const closeJournal = ds?.session.mojoCloseJournal ?? stored?.mojoCloseJournal;
@@ -4625,8 +4681,16 @@ export async function closeSession(sessionId) {
         publishClosedSessionPatch(sessionId, after?.closedAt ? Date.parse(after.closedAt) : undefined, { tokenUsage: after ? composeRowFromClosed(after).tokenUsage : null });
     }
     if (wasOpen && hadLiveWorker) {
-        await closeFenceFor(sessionId, closeWorkerGeneration);
-        sessionStore.cleanupSessionBridgeSendMarkersNow(sessionId);
+        if (awaitWorkerExit) {
+            await closeFenceFor(sessionId, closeWorkerGeneration);
+            sessionStore.cleanupSessionBridgeSendMarkersNow(sessionId);
+        }
+        else {
+            // Don't block the caller on the worker exiting (killWorker already armed
+            // the SIGKILL backstop). Defer bridge-marker cleanup behind the same
+            // fence so a mid-flight send is still credited until the worker ACKs/exits.
+            sessionStore.cleanupSessionBridgeSendMarkers(sessionId);
+        }
     }
     // All authoritative map/status/store/event state above transitions
     // synchronously, before the first await. Lark reaction/unsubscribe cleanup is
@@ -4824,10 +4888,11 @@ function removeInactiveRegistration(map, key, ds) {
 }
 function persistedActiveSessionKey(session, fallbackLarkAppId) {
     const larkAppId = session.larkAppId ?? fallbackLarkAppId;
-    const anchor = session.vcMeetingReceiver
-        ? `vc-receiver:${session.sessionId}`
-        : storedSessionAnchorId(session);
-    return sessionKey(anchor, larkAppId);
+    // Plan B: a VC meeting agent is an ordinary chat-scope session keyed by its
+    // normal chat anchor — this must stay in lockstep with activeSessionKey()
+    // (core/types.ts) so a restored meeting row re-registers at the SAME slot the
+    // live path uses. The vcMeetingReceiver marker is delivery metadata only.
+    return sessionKey(storedSessionAnchorId(session), larkAppId);
 }
 /**
  * Return an active persisted row that deliberately reserves this routing key
@@ -5053,7 +5118,14 @@ function failOrdinaryImDelivery(record, reason) {
         requireOrdinaryTurnRecoveryAttention(record.ds.session, record.turnId, 'recovery_delivery_failed');
         return;
     }
-    if (record.ds.session.vcMeetingReceiver || isSilentScheduledTurn(record.ds, record.turnId))
+    // Plan B: a meeting agent is an ordinary chat-scope session. This tracker only
+    // ever holds ORDINARY IM turns (durable transcript deliveries use the receipt
+    // path, not this map), so a plain user turn's delivery failure must be reported
+    // like any session — otherwise the user's message is silently dropped. Only a
+    // stamped meeting @mention follow-up stays fenced (isMeetingDrivenTurn); a
+    // silent scheduled turn stays suppressed as before. (isMeetingDrivenTurn
+    // supersedes the pre-Plan-B `vcMeetingReceiver` blanket check.)
+    if (isMeetingDrivenTurn(record.ds, record.turnId) || isSilentScheduledTurn(record.ds, record.turnId))
         return;
     const loc = botLocale(getBot(record.ds.larkAppId).config);
     void requireCallbacks().sessionReply(sessionAnchorId(record.ds), tr('worker.input_delivery_failed', { turnId: record.turnId.substring(0, 16) }, loc), 'text', record.ds.larkAppId, record.turnId).catch(err => logger.error(`[${tag(record.ds)}] Failed to report ordinary IM worker delivery failure: `
@@ -5143,8 +5215,13 @@ function shouldTrackOrdinaryImDelivery(ds, message) {
         && (message.turnId.startsWith('om_') || message.turnId.startsWith('bmx-recovery-'))
         && message.dispatchAttempt === undefined
         && (message.type !== 'init' || (!!message.prompt && !message.adoptMode))
-        && !ds.adoptedFrom
-        && !ds.session.vcMeetingReceiver
+        && !isSharedAdoptSession(ds)
+        // Plan B: a meeting agent is an ordinary chat-scope session. A plain user
+        // turn on it IS an ordinary IM delivery (track it for receipt-ACK + retry so
+        // its failure is reported). Only a meeting-driven turn — a stamped @mention
+        // follow-up here, since durable deliveries are already excluded by the
+        // dispatchAttempt===undefined guard above — stays on the receipt/lease path.
+        && !isMeetingDrivenTurn(ds, message.turnId, message.dispatchAttempt)
         && Number.isSafeInteger(ds.workerGeneration)
         && (ds.workerGeneration ?? 0) > 0
         && ds.session.workerGeneration === ds.workerGeneration;
@@ -5463,8 +5540,6 @@ targetScope, opts) {
         runtimeWorkingDir: ds.workingDir,
         runtimeAdoptedFrom: ds.adoptedFrom,
     });
-    if (ds.session.vcMeetingReceiver)
-        return { ok: false, error: 'vc_receiver_not_relayable' };
     if (hasProtectedSessionMutationOwnership(ds)) {
         return { ok: false, error: 'codex_app_dispatch_pending' };
     }
@@ -5538,7 +5613,7 @@ targetScope, opts) {
     // Adopt sessions wrap a CLI process that botmux didn't spawn — the user
     // owns it inside their own tmux pane, so moving routing here would be
     // surprising and we don't control the tmux session's lifecycle. Refuse.
-    if (ds.session.adoptedFrom)
+    if (isSharedAdoptSession(ds))
         return { ok: false, error: 'adopt_not_relayable' };
     // Busy worker: refuse immediately rather than waiting. An idle-wait loop
     // (previously 60s) created an asymmetry with the peer-dispatch HTTP
@@ -5619,7 +5694,6 @@ targetScope, opts) {
         const persistedTargetConflicts = sessionStore.listSessions().filter(item => item.sessionId !== ds.session.sessionId
             && item.status === 'active'
             && (!item.larkAppId || item.larkAppId === ds.larkAppId)
-            && !item.vcMeetingReceiver
             && (item.scope === 'chat' ? item.chatId : item.rootMessageId) === targetAnchor
             && !runtimeIds.has(item.sessionId));
         if (persistedTargetConflicts.some(item => hasProtectedSessionMutationOwnership(item)
@@ -5809,6 +5883,12 @@ export function isForkCapableSession(ds) {
     const cliId = sessionCliId(ds, botCfg);
     if (!FORK_CAPABLE_CLI_IDS.has(cliId))
         return false;
+    // An external App Server thread is not a local rollout. `codex fork` would
+    // resolve against the terminal client's own CODEX_HOME and could fork an
+    // unrelated/empty local session, so refuse rather than claiming a copy was
+    // made. A future server-side thread/fork primitive can add an explicit path.
+    if (ds.session.existingAppServerEndpoint)
+        return false;
     // Codex terminal mode is forkable; Codex under Hybrid RPC input is not (the
     // thread is an app-server live session, no local rollout to `codex fork`).
     //
@@ -5856,13 +5936,11 @@ export async function forkSession(sessionId, targetChatId, targetRootMessageId,
         return { ok: false, error: 'fork_unsupported_backend' };
     // ── Front guards (mirror transferSession; a fork needs a clean, complete
     //    source node exactly as a relay does) ──
-    if (ds.session.vcMeetingReceiver)
-        return { ok: false, error: 'vc_receiver_not_forkable' };
     if (ds.pendingRepo)
         return { ok: false, error: 'not_started_yet' };
     if (!isRelayableRealSession(ds))
         return { ok: false, error: 'not_started_yet' };
-    if (ds.session.adoptedFrom)
+    if (isSharedAdoptSession(ds))
         return { ok: false, error: 'adopt_not_forkable' };
     if (isSessionLifecycleInFlight(ds))
         return { ok: false, error: 'worker_busy' };
@@ -6720,7 +6798,18 @@ export function mojoLivePatchForSession(ds) {
 /** Sessions with a quarantine notice send in flight, so it cannot double-post. */
 const mojoQuarantineNoticeInFlight = new Set();
 /**
- * THE auxiliary-UI suppression policy. One definition, two call sites.
+ * Auxiliary-UI suppression policy for the **mojo quarantine notice** path.
+ *
+ * NOTE (Plan B merge, 2026-08): setupWorkerHandlers' `managedAuxUiSuppressed`
+ * no longer delegates here — it keeps its own inline copy that gates on
+ * `isMeetingDrivenTurn` instead of this function's pre-Plan-B blanket
+ * `ds.session.vcMeetingReceiver` check. That blanket check would re-suppress a
+ * plain user turn on a meeting-agent chat session (the "手动@不回复" regression),
+ * which is exactly why the streaming/aux path had to diverge. This function is
+ * therefore currently the mojo-quarantine caller's policy only; migrating it to
+ * `isMeetingDrivenTurn` (so the two converge again without the regression) is a
+ * tracked follow-up. ordinaryTurnRecoveryEligible (below) carries the same
+ * pre-Plan-B blanket and is on the same follow-up.
  *
  * Previously setupWorkerHandlers held this as a closure and the quarantine notice
  * COPIED three of its four checks — dropping `ordinaryManagedSuppression`, so a
@@ -7312,6 +7401,32 @@ export function forkWorker(ds, promptInput, resumeOrTurnId = false) {
     const cb = requireCallbacks();
     const bot = getBot(ds.larkAppId);
     const botCfg = bot.config;
+    if (botCfg.existingAppServer
+        && botCfg.cliId === 'codex'
+        && ds.session.existingAppServerEndpoint === undefined) {
+        throw new Error('this BotMux bot attaches only to an existing Codex App conversation; '
+            + 'use /adopt to select the thread before sending task input');
+    }
+    let existingAppServerEndpoint;
+    if (ds.session.existingAppServerEndpoint !== undefined) {
+        existingAppServerEndpoint = normalizeExistingAppServerEndpoint(ds.session.existingAppServerEndpoint, `session ${ds.session.sessionId} existingAppServerEndpoint`);
+        if (ds.session.cliId !== 'codex') {
+            throw new Error('existing Codex App Server session must use cliId "codex"; '
+                + 'refusing to launch another CLI against this thread');
+        }
+        if (!ds.session.cliSessionId) {
+            throw new Error('existing Codex App Server session has no selected thread id; '
+                + 'use /adopt to select a Codex App conversation first');
+        }
+        if (ds.session.sandbox === true || botCfg.readIsolation === true) {
+            throw new Error('existing Codex App Server attachment cannot run under sandbox/readIsolation; '
+                + 'the external app-server would remain outside that boundary');
+        }
+        // Remote TUI attach always resumes the explicitly selected remote thread.
+        // Never let later cold-resume/restart policy demote it into a new local
+        // Codex session.
+        resume = true;
+    }
     // A bare /repo placeholder (and a non-Codex empty group-join setup) owns no
     // model turn. Starting its CLI with an empty prompt must not mint a queued
     // activation token: the worker has nothing to submit and could never ACK it.
@@ -7463,7 +7578,7 @@ export function forkWorker(ds, promptInput, resumeOrTurnId = false) {
         // worker left parked but couldn't clean (hard-killed while parked, daemon
         // still alive → next message reforks here). The fresh CLI spawns under the
         // real bmx-<sid>; without this, bmx-diag-<sid> + its .ansi file would leak.
-        if (!ds.initConfig?.adoptMode && !ds.adoptedFrom)
+        if (!isSharedAdoptSession(ds))
             reclaimParkedCrashDiagnostic(ds);
         agentCfg = sessionAgentConfig(ds, botCfg);
         if (!initTurnId && prompt.length > 0 && agentCfg.cliId === 'codex-app') {
@@ -7472,7 +7587,7 @@ export function forkWorker(ds, promptInput, resumeOrTurnId = false) {
         ensureCliEnv(agentCfg.cliId, agentCfg.cliPathOverride);
         let nativeSessionTitle;
         let nativeSessionTitlePrompt;
-        if (agentCfg.cliId === 'codex' && !ds.adoptedFrom) {
+        if (agentCfg.cliId === 'codex' && !isSharedAdoptSession(ds)) {
             const isFreshNativeSession = !resume && !ds.session.cliSessionId;
             const titlePrompt = extractBotmuxLarkNativeSessionTitlePrompt(promptPayload.codexAppInput?.text ?? prompt, bot.botName ? [{ name: bot.botName }] : undefined);
             if (isFreshNativeSession && !ds.session.nativeSessionTitleUserDefined) {
@@ -7708,17 +7823,28 @@ export function forkWorker(ds, promptInput, resumeOrTurnId = false) {
                 reason: 'worker_fork_error',
                 message: reason,
             });
-            // A dedicated VC receiver and a silent schedule have no auxiliary Lark
-            // output channel. Keep lifecycle/dashboard state above, but never leak a
-            // fork diagnostic into the chat.
-            if (ds.session.vcMeetingReceiver || isSilentScheduledTurn(ds, initAttributionTurnId)) {
+            // Plan B: a meeting agent is an ordinary chat-scope session. A fork
+            // diagnostic must stay out of the chat only for a genuinely meeting-driven
+            // opening — a durable transcript delivery (initDispatchAttempt set) or a
+            // stamped meeting @mention follow-up — because that path is fenced to the
+            // receipt/lease chain and could otherwise leak on a silent delivery. A plain
+            // user turn on this session gets its fork failure surfaced like any session
+            // (else the user's own turn fails silently). Silent scheduled turns stay
+            // suppressed as before.
+            const forkErrorMeetingDriven = !!ds.session.vcMeetingReceiver
+                && (initDispatchAttempt !== undefined
+                    || resolveVcMeetingImTurnOrigin(ds.session, initAttributionTurnId) !== undefined);
+            if (forkErrorMeetingDriven || isSilentScheduledTurn(ds, initAttributionTurnId)) {
                 logger.info(`[${t}] Managed/silent fork failure kept out of auxiliary Lark UI `
                     + `turn=${initAttributionTurnId?.slice(0, 12) ?? '-'} attempt=${initDispatchAttempt}: ${reason}`);
                 return;
             }
             const cliName = sessionCliDisplayName(ds, botCfg);
             const message = tr('worker.start_failed', { cliName, reason }, botLocale(botCfg));
-            void cb.sessionReply(sessionAnchorId(ds), message, 'text', ds.larkAppId, fallbackTurnId(ds, initAttributionTurnId), ds.session.vcMeetingReceiver
+            void cb.sessionReply(sessionAnchorId(ds), message, 'text', ds.larkAppId, fallbackTurnId(ds, initAttributionTurnId), 
+            // A meeting-driven turn (listener_thread delivery) that DOES surface must
+            // still attribute to the meeting session so the send policy resolves it.
+            forkErrorMeetingDriven
                 ? { sourceSessionId: ds.session.sessionId }
                 : undefined).catch(replyErr => logger.error(`[${t}] Failed to deliver worker fork error to Lark: ${replyErr}`));
         });
@@ -7761,8 +7887,16 @@ export function forkWorker(ds, promptInput, resumeOrTurnId = false) {
             // dsh runner turn timeout: read live from bot config so tuning bots.json
             // takes effect on the next worker fork without recreating the session.
             turnTimeoutMs: botCfg.turnTimeoutMs,
+            // dsh runtime variant (official runner vs dsh-tui PTY TUI).
+            dshRuntime: botCfg.dshRuntime,
             disableCliBypass: botCfg.disableCliBypass === true,
-            codexRpcInput: botCfg.codexRpcInput === true || config.codexRpcInputDefault,
+            // Existing App Server attachment owns neither an app-server nor a JSON-RPC
+            // input channel. It is a normal official remote TUI, so all user input goes
+            // through its terminal and must never trigger BotMux's self-owned RPC engine.
+            codexRpcInput: existingAppServerEndpoint
+                ? false
+                : botCfg.codexRpcInput === true || config.codexRpcInputDefault,
+            ...(existingAppServerEndpoint ? { existingAppServerEndpoint } : {}),
             // Startup commands run on every fresh spawn (incl. resume) so session-only
             // settings like `/effort ultracode` are re-established. Adopt sessions are
             // observed, not driven — forkAdoptWorker intentionally omits this.
@@ -8126,6 +8260,24 @@ function invalidateTuiPrompt(ds, reason, outcome = 'failed') {
     clearTuiPromptAuthority(ds);
     publishAttentionPatch(ds);
 }
+/**
+ * Plan B: a VC meeting agent is an ordinary chat-scope session that hosts BOTH
+ * meeting transcript deliveries and plain user IM turns. A turn is
+ * "meeting-driven" only when it is a durable transcript delivery (dispatchAttempt
+ * set) or a stamped meeting @mention follow-up (vcMeetingImTurnOrigin). Only
+ * meeting-driven turns are subject to the durable silent/listener_thread output
+ * policy and the receipt-fenced auxiliary-UI suppression; a plain user turn on
+ * this session is an ordinary turn and must post / notify normally (else the
+ * user's own reply is silently swallowed — the "手动@机器人也不回复" bug). Shared
+ * across setupWorkerHandlers and deliverFinalOutput so every gate stays aligned.
+ */
+function isMeetingDrivenTurn(ds, turnId, dispatchAttempt) {
+    if (!ds.session.vcMeetingReceiver)
+        return false;
+    if (dispatchAttempt !== undefined)
+        return true;
+    return resolveVcMeetingImTurnOrigin(ds.session, turnId) !== undefined;
+}
 function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureNotified: false }, reservedWorkerGeneration) {
     const cb = requireCallbacks();
     const t = tag(ds);
@@ -8191,13 +8343,35 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
     };
     /** Auxiliary worker UI is never an authorized output channel for a dedicated
      * VC receiver. Dashboard/audit state is still updated before these guards. */
-    // Delegates to the shared policy (auxUiSuppressedFor) so this and the mojo
-    // quarantine notice cannot drift apart. Suppressing here is the authoritative
-    // fix, NOT a fake "success" message id from sessionReply (a synthetic id would
-    // get stored as streamCardId and later scheduleCardPatch → updateMessage would
-    // still dial Feishu). Dashboard/web-terminal state is updated before these
-    // guards, so the terminal view is unaffected.
-    const managedAuxUiSuppressed = (turnId, dispatchAttempt) => auxUiSuppressedFor(ds, turnId, dispatchAttempt);
+    const managedAuxUiSuppressed = (turnId, dispatchAttempt) => {
+        // No-transport session (apiOnly bot or HTTP virtual chat): there is no real
+        // Feishu chat to render a card/reaction into. Suppress ALL auxiliary UI at
+        // the single source every aux-UI handler funnels through — this is the
+        // authoritative fix, NOT a fake "success" message id from sessionReply (a
+        // synthetic id would get stored as streamCardId and later scheduleCardPatch
+        // → updateMessage would still dial Feishu). Dashboard/web-terminal state is
+        // still updated before these guards, so the terminal view is unaffected.
+        if (!larkTransportEnabled({ chatId: ds.chatId, apiOnly: getBot(ds.larkAppId).config.apiOnly }))
+            return true;
+        if (isSilentScheduledTurn(ds, turnId))
+            return true;
+        // Plan B: a VC meeting agent is an ordinary chat-scope session, so the live
+        // STREAMING CARD is no longer gated here at all — it surfaces through the
+        // normal post/patch path like any group session (that was the "看不到流式
+        // 卡片" report; those sites dropped their VC guard). What remains funnelled
+        // through managedAuxUiSuppressed is out-of-band auxiliary UI (startup-failure
+        // notices, usage-limit patches, exit UI): for a genuinely meeting-driven turn
+        // — a durable transcript delivery (dispatchAttempt set) or a stamped meeting
+        // @mention follow-up — that diagnostic stays fenced to the receipt/retry
+        // chain and must never leak out-of-band (a silent delivery especially). A
+        // plain user turn on this session has neither marker and notifies normally.
+        // (isMeetingDrivenTurn supersedes the pre-Plan-B per-bot-receiver blanket
+        // check that master's auxUiSuppressedFor still uses — keeping this inline is
+        // the load-bearing "手动@不回复" fix.)
+        if (isMeetingDrivenTurn(ds, turnId, dispatchAttempt))
+            return true;
+        return ordinaryManagedSuppression(turnId, dispatchAttempt);
+    };
     /** final_output is the sole exception: listener_thread and exact IM replies
      * may proceed into the durable action ledger; silent/stale attempts do not. */
     const managedFinalOutputSuppressed = (turnId, dispatchAttempt) => {
@@ -8205,13 +8379,16 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
             return true;
         if (isTriggerFinalSuppressed(ds, turnId))
             return true;
-        if (!ds.session.vcMeetingReceiver) {
+        // Only a genuinely meeting-driven turn is subject to the durable meeting-send
+        // policy; a plain user turn on this session posts through the ordinary path
+        // (see isMeetingDrivenTurn).
+        if (!isMeetingDrivenTurn(ds, turnId, dispatchAttempt)) {
             return ordinaryManagedSuppression(turnId, dispatchAttempt);
         }
         // Resolve every Lark-facing worker event against durable origin state. The
         // receipt freezes responseMode, so terminal→idle updates and daemon restore
         // cannot become loud merely because an in-memory suppression map was
-        // cleared/lost. Missing attribution on a dedicated receiver fails closed.
+        // cleared/lost. Missing attribution on a meeting-driven turn fails closed.
         const decision = evaluateVcMeetingManagedSend(config.session.dataDir, {
             receiverSessionId: ds.session.sessionId,
             receiverSession: true,
@@ -8253,9 +8430,75 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
             logger.error(`[${t}] Failed to deliver worker startup failure to Lark: ${err?.message ?? err}`);
         }
     };
+    /**
+     * Daemon-side self-heal for TRANSIENT startup/relaunch failures (see
+     * worker-startup-retry.ts; 2026-08-23 tmux restart-storm incident). Returns
+     * true when a silent bounded retry was scheduled INSTEAD of a user-visible
+     * notify. Scope is deliberately narrow:
+     *   - only turn-less failures — a turn-carrying failure has a waiting sender
+     *     and (for durable VC/at-most-once turns) its own delivery state machine
+     *     that must keep owning retries;
+     *   - only reasons the classifier deems transient host/backend pressure;
+     *   - bounded by MAX_STARTUP_AUTO_RETRIES per failing streak (reset on a
+     *     worker generation reaching `ready`), so a persistent failure still
+     *     surfaces to the user with the standard card.
+     * The retry itself is a blank re-fork (`forkWorker(ds, '', true)`) — exactly
+     * what a daemon restart or the next inbound message would do: re-attach when
+     * the backing pane survived (the 08-23 case — pane and CLI were alive, only
+     * the worker had died), cold `--resume` otherwise.
+     */
+    const scheduleTransientStartupRetry = (reason, turnId, dispatchAttempt) => {
+        if (turnId !== undefined || dispatchAttempt !== undefined)
+            return false;
+        if (startupState.failureNotified)
+            return false;
+        if (!isTransientStartupFailure(reason))
+            return false;
+        if (ds.session.status !== 'active')
+            return false;
+        const attempts = (ds.startupAutoRetry?.attempts ?? 0) + 1;
+        if (attempts > MAX_STARTUP_AUTO_RETRIES)
+            return false;
+        // Mark this generation handled so the pre-ready exit guard cannot post a
+        // duplicate start_exited_early card behind the scheduled retry.
+        startupState.failureNotified = true;
+        const delayMs = startupAutoRetryDelayMs(ds.session.sessionId, attempts);
+        logger.warn(`[${t}] Transient worker startup failure (${reason}); `
+            + `auto-retry ${attempts}/${MAX_STARTUP_AUTO_RETRIES} in ${Math.round(delayMs / 1000)}s`);
+        const timer = setTimeout(() => {
+            if (ds.startupAutoRetry?.timer === timer)
+                ds.startupAutoRetry.timer = undefined;
+            // Lifecycle guards: the session may have been closed, replaced in the
+            // registry, or revived by an inbound message while the timer slept.
+            if (ds.session.status !== 'active')
+                return;
+            if (ds.worker && !ds.worker.killed)
+                return;
+            if (activeSessionsRegistry && activeSessionsRegistry.get(activeSessionKey(ds)) !== ds)
+                return;
+            logger.info(`[${t}] Auto-retrying worker start (${attempts}/${MAX_STARTUP_AUTO_RETRIES}) `
+                + 'after transient startup failure');
+            try {
+                forkWorker(ds, '', true);
+            }
+            catch (err) {
+                logger.error(`[${t}] Startup auto-retry fork failed: ${err?.message ?? err}`);
+            }
+        }, delayMs);
+        timer.unref?.();
+        // An inbound message can revive the session between two failing
+        // generations; if the replacement fails too, the previous generation's
+        // still-pending timer must not survive as an orphan (its guards make a
+        // double blank re-fork merely wasteful, not harmful — but one streak owns
+        // exactly one pending retry).
+        if (ds.startupAutoRetry?.timer)
+            clearTimeout(ds.startupAutoRetry.timer);
+        ds.startupAutoRetry = { attempts, timer };
+        return true;
+    };
     // Adopt mode flags — computed once, used in all buildStreamingCard calls.
     // Bridge mode (the v3 default for /adopt) hides the legacy takeover button.
-    const isAdopt = !!ds.adoptedFrom;
+    const isAdopt = isSharedAdoptSession(ds);
     const showTakeover = false;
     worker.on('message', async (msg) => {
         // Every IPC message is scoped to the child generation that emitted it.
@@ -8409,6 +8652,14 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                 }
                 startupState.ready = true;
                 ds.workerReady = true;
+                // A generation reached ready: the transient-startup failing streak is
+                // over. Clear the budget and any still-pending retry timer (an inbound
+                // message may have revived the session while a retry slept).
+                if (ds.startupAutoRetry) {
+                    if (ds.startupAutoRetry.timer)
+                        clearTimeout(ds.startupAutoRetry.timer);
+                    ds.startupAutoRetry = undefined;
+                }
                 // Restore the daemon-owned display mode BEFORE any card handling: a
                 // fresh worker always boots with displayMode='hidden', and every early
                 // break below (managed / replyAlreadySent / streamingCardDisabled /
@@ -8579,8 +8830,10 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                 // POST a second card; the in-flight POST becomes this turn's card.
                 if (ds.streamCardId === CARD_POSTING_SENTINEL)
                     break;
+                const pendingNewTurn = !!ds.streamCardPending;
                 const postingGeneration = ds.streamCardTurnGeneration ?? 0;
                 const cardReplyTarget = captureStreamingCardReplyTarget(ds, msg.turnId);
+                const statusRevisionAtPost = ds.streamCardStatusRevision ?? 0;
                 ds.streamCardId = CARD_POSTING_SENTINEL;
                 try {
                     ds.streamCardNonce = randomBytes(4).toString('hex');
@@ -8588,7 +8841,9 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                     // See PATCH-branch comment above re: lastScreenStatus preference.
                     // For relay (kill+fork with surviving tmux/CLI), this avoids the
                     // jarring "启动中" right after the M1 "已接力" announcement.
-                    const initStatus = ds.usageLimit ? 'limited' : (ds.lastScreenStatus ?? 'starting');
+                    const initStatus = pendingNewTurn
+                        ? turnStartingCardStatus(ds, effectiveCliId)
+                        : (ds.usageLimit ? 'limited' : (ds.lastScreenStatus ?? 'starting'));
                     const streamCardJson = buildStreamingCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, initTitle, 
                     // For /relay resume, ds.lastScreenContent is the cached pane
                     // from before the kill+fork — using it avoids a blank flash
@@ -8629,6 +8884,9 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                     // resume where the CLI kept running), arm here — same authorized arm
                     // point as the reuse branch, now that streamCardId is the real id.
                     syncUsageRefreshTimer(ds);
+                    if (!superseded) {
+                        reconcilePostedStartingCard(ds, cardReplyTarget.turnId, statusRevisionAtPost);
+                    }
                     if (superseded && ds.streamCardPendingTurnId) {
                         void postTurnStartingCard(ds, cb.sessionReply, ds.streamCardPendingTurnId);
                     }
@@ -8649,7 +8907,7 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                     // Fallback: send static session card
                     try {
                         const localCliReadyAtBuild = isLocalCliOpenReady(ds, { cliId: effectiveCliId });
-                        const cardJson = buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, undefined, !!ds.adoptedFrom, loc, localCliReadyAtBuild, sessionRuntimeDisplayName(ds, botCfg));
+                        const cardJson = buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, undefined, isSharedAdoptSession(ds), loc, localCliReadyAtBuild, sessionRuntimeDisplayName(ds, botCfg));
                         const fallbackCardId = await scopedReply(cardJson, 'interactive', msg.turnId);
                         if (!ownsLifecycleMutation()) {
                             void deleteMessage(ds.larkAppId, fallbackCardId).catch(() => { });
@@ -8657,7 +8915,7 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                         }
                         if (!localCliReadyAtBuild && isLocalCliOpenEnabled()
                             && isLocalCliOpenReady(ds, { cliId: effectiveCliId })) {
-                            const readyCardJson = buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, undefined, !!ds.adoptedFrom, loc, true, sessionRuntimeDisplayName(ds, botCfg));
+                            const readyCardJson = buildSessionCard(ds.session.sessionId, sessionAnchorId(ds), readOnlyUrl, ds.session.title || sessionCliDisplayName(ds, botCfg), effectiveCliId, undefined, isSharedAdoptSession(ds), loc, true, sessionRuntimeDisplayName(ds, botCfg));
                             try {
                                 await updateMessage(ds.larkAppId, fallbackCardId, readyCardJson);
                             }
@@ -8851,7 +9109,7 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                 const prevStatus = ds.lastScreenStatus;
                 updateUsageLimitState(ds, msg.usageLimit);
                 ds.lastScreenContent = msg.content;
-                ds.lastScreenStatus = (msg.usageLimit ?? ds.usageLimit) ? 'limited' : msg.status;
+                ds.lastScreenStatus = resolveUsageAwareScreenStatus(ds, msg.status, msg.usageLimit);
                 bumpStreamCardStatusRevision(ds);
                 // A suspend that arrived mid-turn parked itself here. Defer until this
                 // screen_update has finished using process state — suspendWorker nulls
@@ -9046,7 +9304,7 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                     break;
                 const prevStatus = ds.lastScreenStatus;
                 updateUsageLimitState(ds, msg.usageLimit);
-                ds.lastScreenStatus = (msg.usageLimit ?? ds.usageLimit) ? 'limited' : msg.status;
+                ds.lastScreenStatus = resolveUsageAwareScreenStatus(ds, msg.status, msg.usageLimit);
                 bumpStreamCardStatusRevision(ds);
                 // Same deferred-suspend checkpoint as the screen_update branch, and
                 // deferred for the same reason (see runPendingSuspendIfSettled).
@@ -9406,9 +9664,45 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                     break;
                 }
                 const suppressExitUi = managedAuxUiSuppressed(msg.turnId, msg.dispatchAttempt);
+                if (msg.codexAppActiveWriter === true && effectiveCliId === 'codex-app') {
+                    // `thread/resume` was explicitly rejected because another Codex
+                    // app-server currently owns the persisted thread. This is a safe,
+                    // expected handoff conflict — never spend restart budget or let the
+                    // generic second-restart policy drop cliSessionId and create a fresh
+                    // context. Park the logical Botmux session so its next message
+                    // retries the SAME thread after the external writer releases it.
+                    const thread = ds.session.cliSessionId ?? ds.session.sessionId;
+                    logger.warn(`[${t}] Codex App resume blocked by external active writer; preserving `
+                        + `thread ${thread.substring(0, 12)}`);
+                    const suspended = suspendWorker(ds, 'codex_app_active_writer');
+                    if (!suspended) {
+                        // The runner process already exited and there is no safe live
+                        // backend suspension path. Retire only this Node worker; never
+                        // destroy the external app-server that owns the thread.
+                        retireWorkerProcessOnly(ds, 'codex_app_active_writer');
+                        ds.hasHistory = true;
+                        ds.session.suspendedColdResume = true;
+                        sessionStore.updateSession(ds.session);
+                    }
+                    if (!suppressExitUi) {
+                        const threadLabel = `${thread.substring(0, 16)}…`;
+                        const message = loc === 'zh'
+                            ? `⚠️ Codex App 历史会话（${threadLabel}）当前正由另一个 Codex App / app-server 持有。`
+                                + 'BotMux 已保留原上下文，不会新建空会话；请在 App 侧释放该会话后，再发送一条消息重试恢复。'
+                            : `⚠️ Codex App thread (${threadLabel}) is currently held by another Codex App / app-server writer. `
+                                + 'BotMux preserved the original context and did not create a fresh session; release it in the App, then send another message to retry.';
+                        try {
+                            await scopedReply(message, 'text', msg.turnId);
+                        }
+                        catch (replyErr) {
+                            logger.error(`[${t}] Failed to report Codex App active-writer conflict: ${replyErr}`);
+                        }
+                    }
+                    break;
+                }
                 // Do NOT auto-restart in adopt mode — there's nothing to restart
-                if (ds.adoptedFrom) {
-                    logger.info(`[${t}] Adopted session ended`);
+                if (isSharedAdoptSession(ds)) {
+                    logger.info(`[${t}] Shared adopted session ended`);
                     // Freeze the streaming card
                     if (!suppressExitUi && ds.streamCardId && workerHasInitialized(ds)) {
                         const readUrl = readableTerminalUrlFor(ds);
@@ -9544,7 +9838,12 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
                 logger.error(`[${t}] Worker error: ${msg.message}`);
                 // `error` is a fatal launch-generation signal. It normally arrives
                 // during init, but can also follow a previously-ready worker whose CLI
-                // recovery/restart fails; that later failure must remain user-visible.
+                // recovery/restart fails; that later failure must remain user-visible —
+                // UNLESS it is a turn-less transient (post-outage restart storm), where
+                // a bounded silent re-fork self-heals without waking anyone (08-23:
+                // idle sessions got "会话启动失败" cards while their panes were alive).
+                if (scheduleTransientStartupRetry(msg.message, msg.turnId, msg.dispatchAttempt))
+                    break;
                 await notifyStartupFailure(msg.message, msg.turnId, msg.dispatchAttempt);
                 break;
             }
@@ -10376,14 +10675,19 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
             ds.worker = null;
             ds.workerReady = false;
             ds.workerPort = null;
+            // A dead worker can no longer refresh its card/usage view.
+            clearUsageRefreshTimer(ds);
+            // A worker owns the terminal HTTP listener. Persisting its former port
+            // after exit leaves the Dashboard proxy routing `/terminal/<session>` to
+            // a dead socket until some later ready event overwrites it. Clear both
+            // durable and aggregated state now so a persistent backend can be
+            // re-attached on demand instead of returning a stale 502.
+            ds.session.webPort = undefined;
             // A queued suspend for THIS generation is now moot — the worker it was
             // about is gone. Leaving it set would suspend the replacement on its
             // first idle (the deferred checkpoint's own "worker gone" branch cannot
             // help: it only runs on a screen update that will never arrive).
             clearPendingSuspendClaim(ds, 'worker exited');
-            // Dead worker generation — stop the periodic usage refresh immediately
-            // instead of waiting a tick for it to self-clear on !workerHasInitialized.
-            clearUsageRefreshTimer(ds);
             ds.workerToken = null;
             ds.workerViewToken = null;
             ds.managedTurnOrigin = undefined;
@@ -10411,6 +10715,13 @@ function setupWorkerHandlers(ds, worker, startupState = { ready: false, failureN
             sessionStore.updateSession(ds.session);
             if (exitedPreviewTarget !== undefined)
                 publishSessionPreviewCleared(ds.session.sessionId);
+            dashboardEventBus.publish({
+                type: 'session.update',
+                body: {
+                    sessionId: ds.session.sessionId,
+                    patch: { webPort: null, workerPid: null },
+                },
+            });
         }
         if (!transferRetirement) {
             try {
@@ -10541,10 +10852,11 @@ async function finishTurnReactions(ds) {
         return;
     // Detach the batch first so a second idle edge can't double-flip it.
     ds.pendingAckReactions = [];
-    // A dedicated receiver has no progress-reaction channel. Clear any stale
-    // in-memory entries restored from an older build without touching Lark.
-    if (ds.session.vcMeetingReceiver)
-        return;
+    // Plan B: a meeting agent is an ordinary chat-scope session. Pending ack
+    // reactions only ever exist for a real inbound user message (the ✋ is placed
+    // when that message arrives — transcript deliveries have no inbound message to
+    // react to), so a non-empty list here always belongs to a plain user turn and
+    // must settle to ✅ like any session. No VC special-case.
     const silent = silentTurnReactions(ds);
     const doneEmoji = doneReactionEmojiFor(ds);
     for (const ack of list) {
@@ -10728,7 +11040,14 @@ function deliverFinalOutput(ds, msg, t, attempt, onComplete, isStillOwned = () =
             const imOrigin = msg.dispatchAttempt === undefined
                 ? resolveVcMeetingImTurnOrigin(ds.session, msg.turnId)
                 : undefined;
-            const managedDecision = ds.session.vcMeetingReceiver
+            // Plan B: the meeting agent is an ordinary chat-scope session, so it also
+            // delivers plain user turns. Apply the durable meeting-send policy ONLY to
+            // a genuinely meeting-driven turn (a durable transcript delivery, or a
+            // stamped meeting @mention follow-up). A plain user turn is not
+            // meeting-driven → managedDecision stays undefined → it delivers through
+            // the ordinary path. Without this gate a plain user reply resolves
+            // `origin_unproven` and is silently dropped (the "手动@机器人也不回复" bug).
+            const managedDecision = isMeetingDrivenTurn(ds, msg.turnId, msg.dispatchAttempt)
                 ? evaluateVcMeetingManagedSend(config.session.dataDir, {
                     receiverSessionId: ds.session.sessionId,
                     receiverSession: true,
@@ -10746,7 +11065,7 @@ function deliverFinalOutput(ds, msg, t, attempt, onComplete, isStillOwned = () =
                 return;
             }
             const revalidateManagedSend = () => {
-                if (!ds.session.vcMeetingReceiver)
+                if (!isMeetingDrivenTurn(ds, msg.turnId, msg.dispatchAttempt))
                     return;
                 const current = evaluateVcMeetingManagedSend(config.session.dataDir, {
                     receiverSessionId: ds.session.sessionId,
@@ -10824,11 +11143,14 @@ function deliverFinalOutput(ds, msg, t, attempt, onComplete, isStillOwned = () =
             const feedbackRequesterSubjectId = recipientOpenId;
             const feedback = feedbackPolicy && feedbackRequesterSubjectId ? { policy: feedbackPolicy } : undefined;
             cardUsage ??= getDaemonReplyCardUsageSnapshot(ds, effectiveCliId);
+            const localTurnTitle = msg.kind === 'local-turn-headless'
+                ? tr('card.local_turn_resumed', undefined, localeForBot(ds.larkAppId))
+                : isExistingAppServerSharedAdoptPersistedSession(ds.session)
+                    ? tr('card.codex_app_shared_turn', undefined, localeForBot(ds.larkAppId))
+                    : tr('card.local_turn', undefined, localeForBot(ds.larkAppId));
             const cardJson = msg.kind === 'local-turn' || msg.kind === 'local-turn-headless'
                 ? buildContextualReplyCard({
-                    title: msg.kind === 'local-turn-headless'
-                        ? tr('card.local_turn_resumed', undefined, localeForBot(ds.larkAppId))
-                        : tr('card.local_turn', undefined, localeForBot(ds.larkAppId)),
+                    title: localTurnTitle,
                     userText: msg.kind === 'local-turn' ? safeUserText ?? '' : undefined,
                     assistantText: safeAssistantText,
                     assistantLabel: storedSessionCliDisplayName(ds),
@@ -11287,6 +11609,7 @@ export function forkAdoptWorker(ds, opts) {
         cliSessionId: isStructuredBridge ? adopted.sessionId : undefined,
         model: agentCfg.model,
         turnTimeoutMs: botCfg.turnTimeoutMs,
+        dshRuntime: botCfg.dshRuntime,
         disableCliBypass: botCfg.disableCliBypass === true,
         codexRpcInput: botCfg.codexRpcInput === true || config.codexRpcInputDefault,
         // Adopt is normally observe-only (prompt=''), driven later by 'message'
@@ -11501,7 +11824,20 @@ export function killStalePids(activeSessions_, runtimeSessions) {
         try {
             // Check if process exists (signal 0 doesn't kill, just checks)
             process.kill(session.pid, 0);
-            // Process exists — kill its process group
+            // Existing-App-Server share: the worker and its BotMux-owned remote TUI
+            // can be in one process group. Reap only the stale worker PID; killing
+            // the group would also terminate `codex --remote`, even though the
+            // replacement daemon is expected to reattach that client. The external
+            // App Server itself is never ours to signal.
+            if (isExistingAppServerSharedAdoptPersistedSession(session)) {
+                logger.info(`Killing stale shared-App-Server worker only (pid: ${session.pid}, session: ${session.sessionId})`);
+                try {
+                    process.kill(session.pid, 'SIGTERM');
+                }
+                catch { /* already gone */ }
+                continue;
+            }
+            // Ordinary managed sessions own their complete process group.
             logger.info(`Killing stale CLI process (pid: ${session.pid}, session: ${session.sessionId})`);
             try {
                 process.kill(-session.pid, 'SIGTERM');
@@ -11767,6 +12103,12 @@ function cleanupPersistentBackendSessions(backendType, activeSessions_, runtimeS
         for (const session of activeSessions_) {
             if (!belongsToBackend(session))
                 continue;
+            // The remote TUI deliberately uses cliId=codex even when the Bot's
+            // default/new-session runtime remains codex-app. This is a shared-adopt
+            // binding, not a stale CLI selection, so keep its bmx-* client alive for
+            // the restore path. Explicit /detach remains responsible for cleanup.
+            if (isExistingAppServerSharedAdoptPersistedSession(session))
+                continue;
             const sessionCliId = session.cliId;
             if (!sessionCliId || !session.larkAppId)
                 continue;