botmux 3.12.0 → 3.12.1

package/dist/worker.js

@@ -28,7 +28,7 @@ import { readProcessStartIdentity } from './core/session-marker.js';
 import { roleLibraryRoot, roleLibrarySubtree } from './core/role-library.js';
 import { drainTranscript, joinAssistantText, trailingAssistantText, findJsonlContainingFingerprint, findJsonlsContainingExactContent, findLatestJsonl, extractLastAssistantTurn, extractTurnStartText, splitTranscriptEventsByCutoff, isTranscriptRateLimitEvent, apiErrorMessageText } from './services/claude-transcript.js';
 import { BridgeTurnQueue, makeFingerprint, normaliseForFingerprint } from './services/bridge-turn-queue.js';
-import { bridgePostText, shouldEmitEmptyCompletedBridgeFallback, shouldEmitFailedBridgeFallback, shouldSuppressBridgeEmit, stripTrailingBridgeSentinelLine } from './services/bridge-fallback-gate.js';
+import { bridgePostText, isBridgeNothingToSendFinal, shouldEmitEmptyCompletedBridgeFallback, shouldEmitFailedBridgeFallback, shouldSuppressBridgeEmit, stripTrailingBridgeSentinelLine } from './services/bridge-fallback-gate.js';
 import { buildSubmitMessagePreview } from './services/submit-notification.js';
 import { decideHardTimeoutAction, decidePostHookPromptEvidence, decideSettleMarkReady, shouldArmPostHookPromptEvidenceFallback, shouldReleaseFirstPromptTimeout, shouldWaitForPostSessionStartPromptEvidence, shouldWriteNow, POST_HOOK_EVIDENCE_FALLBACK_MS, POST_HOOK_EVIDENCE_RETRY_MS, } from './utils/input-gate.js';
 import { decideCodexRunnerFreshness, CodexRunnerFreshnessInputQueue, shouldHoldCodexRunnerInput, } from './services/codex-runner-freshness.js';
@@ -128,7 +128,7 @@ import { mergeHerdrWebSnapshot, renderHerdrWebHistory, } from './utils/herdr-web
 import { parseWorkerRequestUrl } from './utils/worker-http.js';
 import { detectCliUsageLimit, usageLimitStateKey, structuredRateLimitState, isStructuredRateLimitAuthoritative } from './utils/cli-usage-limit.js';
 import { uploadImageBuffer } from './utils/lark-upload.js';
-import { redactChildEnv, scrubClaudeSessionMarkerEnv, scrubSessionCliHomeEnv } from './utils/child-env.js';
+import { applySessionOwnerEnv, redactChildEnv, scrubClaudeSessionMarkerEnv, scrubSessionCliHomeEnv } from './utils/child-env.js';
 import { decideSubmitConfirmationAction, settleDeferredSubmitConfirmation, settleStaleWriteContinuation, } from './services/submit-confirmation.js';
 import { runAdoptQueuedWriteSequence, runAdoptRawInputSequence, runAdoptSessionRenameSequence, } from './services/adopt-input-sequence.js';
 import { config, resolveChatBotDiscoveryConfig } from './config.js';
@@ -770,10 +770,6 @@ async function engageCodexRpc(cfg) {
         engineEnv.BOTMUX_LARK_APP_ID = cfg.larkAppId;
         engineEnv.BOTMUX_ROOT_MESSAGE_ID = cfg.rootMessageId;
         engineEnv.BOTMUX_SESSION_SCOPE = cfg.rootMessageId?.startsWith('om_') ? 'thread' : 'chat';
-        if (cfg.ownerOpenId)
-            engineEnv.BOTMUX_OWNER_OPEN_ID = cfg.ownerOpenId;
-        else
-            delete engineEnv.BOTMUX_OWNER_OPEN_ID;
         // The app-server owns model execution in RPC mode. Its MCP gateway child
         // must inherit the trusted host socket just like a native CLI process does.
         if (sessionMcpGatewayHost) {
@@ -789,6 +785,9 @@ async function engageCodexRpc(cfg) {
         // injects into the TUI — else a 3rd-party-provider bot's app-server silently
         // falls back to the default provider. Re-sanitized (crossed IPC).
         Object.assign(engineEnv, sanitizePerBotEnv(cfg.env));
+        // Session identity is host-owned. Pin it after the config-controlled merge,
+        // matching every other backend and preventing stale owner resurrection.
+        applySessionOwnerEnv(engineEnv, cfg.ownerOpenId);
         engine = new CodexRpcEngine({
             cliBin, cwd: cfg.workingDir, env: engineEnv, sessionId: cfg.sessionId,
             model: cfg.model, reasoningEffort: cfg.reasoningEffort, log: (m) => log(m),
@@ -4619,6 +4618,10 @@ function emitReadyTurns(opts = {}) {
     const remainingPending = bridgeQueue.peek();
     const nextPendingMarkTimeMs = remainingPending.length > 0 ? remainingPending[0].markTimeMs : undefined;
     const cache = new Map();
+    // Turns suppressed as GENUINE SILENCE — see emitReadyCodexTurns for the full
+    // rationale. Tracked by object identity across this function's two loops so
+    // the terminal can carry positive silence evidence for a durable/async caller.
+    const nothingToSendTurns = new Set();
     for (let i = 0; i < ready.length; i++) {
         const turn = ready[i];
         const nextBoundaryMs = (i + 1 < ready.length ? ready[i + 1].markTimeMs : nextPendingMarkTimeMs);
@@ -4651,6 +4654,11 @@ function emitReadyTurns(opts = {}) {
         if (shouldSuppressBridgeEmit(gateInput, nextBoundaryMs, markers, adoptMode)) {
             const reason = turn.isLocal ? 'local-typed' : 'model called botmux send within window';
             log(`Bridge fallback suppressed for turn ${turn.turnId.substring(0, 8)} (${reason})`);
+            // Positive silence evidence for the terminal — only a bare nothing-to-send
+            // sentinel (no prose, no send), never "already sent" / local-typed.
+            if (!adoptMode && isBridgeNothingToSendFinal(assistantText)) {
+                nothingToSendTurns.add(turn);
+            }
             notifyExplicitReplyObserved(turn.turnId, explicitReplyMarkerForTurnWindow(gateInput, nextBoundaryMs, markers, adoptMode));
             continue;
         }
@@ -4719,7 +4727,7 @@ function emitReadyTurns(opts = {}) {
     // only after all corresponding final_output IPC messages have been queued so
     // the daemon observes a stable per-turn ordering.
     for (const turn of ready)
-        emitTurnTerminal(turn.turnId, 'completed', undefined, turn.dispatchAttempt);
+        emitTurnTerminal(turn.turnId, 'completed', undefined, turn.dispatchAttempt, nothingToSendTurns.has(turn) ? 'nothing_to_send' : undefined);
 }
 /** Drain `path` from `fromOffset` and feed the events to the bridge queue
  *  with that path as the source stamp. Pure side-effects on bridgeQueue +
@@ -5977,6 +5985,14 @@ function emitReadyCodexTurns() {
     const ready = codexBridgeQueue.drainEmittable();
     if (ready.length === 0)
         return;
+    // Turns suppressed as GENUINE SILENCE (model terminated with a bare
+    // nothing-to-send sentinel, no `botmux send`). Tracked by object identity —
+    // both the emit loop and the terminal loop below iterate this same `ready`
+    // array — so the terminal for such a turn can carry positive silence evidence
+    // (outputDisposition: 'nothing_to_send'). A durable/async caller uses ONLY
+    // that flag to settle completed-with-empty; a bare `completed` terminal (e.g.
+    // the RPC-hydration timeout path) must never be read as silence.
+    const nothingToSendTurns = new Set();
     const adoptMode = lastInitConfig?.adoptMode === true;
     // Adopt mode: model is the user's external Codex, no botmux send to
     // gate against — every assistant turn (Lark-driven OR locally typed)
@@ -6016,6 +6032,16 @@ function emitReadyCodexTurns() {
             continue;
         if (shouldSuppressBridgeEmit(gateInput, nextBoundaryMs, markers, adoptMode)) {
             log(`Codex bridge fallback suppressed for turn ${turn.turnId.substring(0, 8)} (gate)`);
+            // Distinguish DELIBERATE SILENCE (bare nothing-to-send sentinel, no prose,
+            // no send) from other suppression reasons (already `botmux send`-ed this
+            // turn, local-typed). Only the former is positive evidence that the model
+            // chose to produce no output — the terminal below carries it so a durable/
+            // async caller can settle completed-with-empty. "Already sent" is NOT
+            // silence: its content went out via final_output/botmux send and the async
+            // result is captured there, so it must not be stamped.
+            if (!adoptMode && isBridgeNothingToSendFinal(turn.finalText)) {
+                nothingToSendTurns.add(turn);
+            }
             notifyExplicitReplyObserved(turn.turnId, explicitReplyMarkerForTurnWindow(gateInput, nextBoundaryMs, markers, adoptMode));
             continue;
         }
@@ -6065,7 +6091,7 @@ function emitReadyCodexTurns() {
                 ? { dispatchAttempt: turn.dispatchAttempt }
                 : {}),
         });
-        emitTurnTerminal(turn.turnId, turn.terminalStatus ?? 'completed', turn.terminalErrorCode, turn.dispatchAttempt);
+        emitTurnTerminal(turn.turnId, turn.terminalStatus ?? 'completed', turn.terminalErrorCode, turn.dispatchAttempt, nothingToSendTurns.has(turn) ? 'nothing_to_send' : undefined);
     }
 }
 function stopCodexBridge() {
@@ -10700,9 +10726,6 @@ async function spawnCli(cfg, opts = {}) {
                 sessionEnv.BOTMUX_DEFERRED_SCHEDULE_TOPIC_TITLE = cfg.deferredScheduleRun.topicTitle;
             }
         }
-        // Turn sender so `--mention-back` can resolve an @ target in the sandbox.
-        if (cfg.ownerOpenId)
-            sessionEnv.BOTMUX_OWNER_OPEN_ID = cfg.ownerOpenId;
         // Lark credentials so `botmux send` works inside the riff sandbox without a
         // local daemon or bots.json. The sandbox has no session data / bot config,
         // so cmdSend falls back to these env vars to call the Lark API directly.
@@ -10732,6 +10755,10 @@ async function spawnCli(cfg, opts = {}) {
             mergedEnv.BOTMUX_API_ONLY = '1';
             mergedEnv.BOTMUX_CHAT_ID = cfg.chatId; // host-owned; never from config
         }
+        // Session identity is host-owned. Re-freeze it AFTER per-bot/riff config
+        // merge so a stale or user-supplied backend env cannot impersonate another
+        // owner (or resurrect an owner on an ownerless session).
+        applySessionOwnerEnv(mergedEnv, cfg.ownerOpenId);
         riffBackendConfig = Object.assign({}, cfg.backendConfig, { env: mergedEnv, resumeParentTaskId: cfg.riffParentTaskId });
         // 复用本地仓库+分支：多仓只认会话上的显式 stamp（仓库选择卡多选流按用户
         // 顺序写入 cfg.riffRepoDirs，首仓=primary）；否则仅对 workingDir 本身做单仓
@@ -11629,6 +11656,7 @@ async function spawnCli(cfg, opts = {}) {
     else
         delete childEnv.BOTMUX_API_ONLY;
     childEnv.BOTMUX_ROOT_MESSAGE_ID = cfg.rootMessageId;
+    applySessionOwnerEnv(childEnv, cfg.ownerOpenId);
     // This bot's resolved brandLabel template, injected so a SANDBOXED `botmux
     // send` renders the role-name footer without reading bots.json (deny-by-
     // default → EPERM → role footer would silently fall back to the default
@@ -12917,8 +12945,19 @@ async function spawnCli(cfg, opts = {}) {
                     log('Screen settle barrier degraded after bounded retries; finalizing from the last successful snapshot');
                 }
             }
-            if (evidenceSource === 'screen' && idleBackend
-                && deferPromptReadyWhileBusy(`${cliName()} screen-idle`, idleBackend))
+            // Pi's transcript final (assistant_final) is persisted asynchronously
+            // from the TUI clearing its `Working...` busy marker — either order
+            // occurs. An external idle landing while the authoritative viewport
+            // still shows busy must defer exactly like a screen idle, or the card
+            // flips to 等待输入 mid-turn. Scoped to Pi: Grok/Codex own their idle
+            // via reliableTurnTerminal / lifecycle blocking, and their busy markers
+            // legitimately lag behind the transcript final. deferPromptReadyWhileBusy
+            // itself fail-opens on non-authoritative screens (ZMX), so a stale
+            // `Working...` in ZMX history can never block a structured terminal.
+            const busyGuardedIdle = evidenceSource === 'screen'
+                || (evidenceSource === 'external' && structuredBridgeIsPi());
+            if (busyGuardedIdle && idleBackend
+                && deferPromptReadyWhileBusy(`${cliName()} ${evidenceSource}-idle`, idleBackend))
                 return;
             drainBridgesThenMarkReady(evidenceSource);
         });
@@ -14709,7 +14748,7 @@ const emittedTurnTerminals = new TurnTerminalDeduper();
 /** Report CLI processing completion independently from user-visible output.
  *  Keep a bounded worker-local dedup set because transcript watchers and app
  *  runners may surface the same final boundary more than once. */
-function emitTurnTerminal(turnId, status, errorCode, dispatchAttempt) {
+function emitTurnTerminal(turnId, status, errorCode, dispatchAttempt, outputDisposition) {
     if (!sessionId || !turnId)
         return;
     if (!emittedTurnTerminals.claim(sessionId, turnId, dispatchAttempt))
@@ -14730,6 +14769,7 @@ function emitTurnTerminal(turnId, status, errorCode, dispatchAttempt) {
         status,
         ...(dispatchAttempt !== undefined ? { dispatchAttempt } : {}),
         ...(errorCode ? { errorCode } : {}),
+        ...(outputDisposition ? { outputDisposition } : {}),
     });
     if (terminalReleasesDurableTurn({ turnId: currentBotmuxTurnId, dispatchAttempt: currentBotmuxDispatchAttempt }, { turnId, dispatchAttempt })) {
         // Durable replay ownership moves back to the receiver/hub at terminal.
@@ -14942,8 +14982,7 @@ process.on('message', async (raw) => {
             sessionId = msg.sessionId;
             refreshTerminalViewToken();
             refreshTerminalWriteToken();
-            if (msg.ownerOpenId)
-                process.env.__OWNER_OPEN_ID = msg.ownerOpenId;
+            applySessionOwnerEnv(process.env, msg.ownerOpenId);
             // Pin this worker's i18n locale early so every t() call below resolves
             // against the bot's chosen language without each callsite needing to
             // re-thread it.