botmux 2.83.0 → 2.84.1

package/dist/core/worker-pool.js

@@ -16,10 +16,9 @@ import { config } from '../config.js';
 import * as sessionStore from '../services/session-store.js';
 import { persistStreamCardState, rememberLastCliInput } from './session-manager.js';
 import { fallbackTurnId } from './reply-target.js';
-import { updateMessage, deleteMessage, sendEphemeralCard, sendUserMessage, addReaction, MessageWithdrawnError } from '../im/lark/client.js';
+import { updateMessage, deleteMessage, sendEphemeralCard, sendUserMessage, addReaction, removeReaction, MessageWithdrawnError } from '../im/lark/client.js';
 import { buildStreamingCard, buildPrivateSnapshotCard, buildSessionCard, buildTuiPromptCard, buildTuiPromptResolvedCard, buildRelayedFrozenCard, getCliDisplayName } from '../im/lark/card-builder.js';
 import { loadFrozenCards, saveFrozenCards } from '../services/frozen-card-store.js';
-import { clearPendingResponsePatchMarker, markPendingResponsePatchMarkerPatched, writePendingResponsePatchMarker } from '../services/pending-response-transaction-store.js';
 import { logger } from '../utils/logger.js';
 import { createCliAdapterSync } from '../adapters/cli/registry.js';
 import { botLocale, localeForBot, t as tr } from '../i18n/index.js';
@@ -39,8 +38,10 @@ import { publishAttentionPatch } from './session-activity.js';
 import { knownBotOpenIdsFromCrossRef } from '../utils/bot-routing.js';
 import { emitSessionLifecycleHook, emitSessionStateTransitionHook } from '../services/session-lifecycle-hooks.js';
 import { anchorUsageForDaemonSession, recordOwnershipForDaemonSession, recordUsageForDaemonSession, reconcileUsageForDaemonSession } from '../services/usage-ledger.js';
+import { prepareSessionSkillPrompt } from './skills/session-runtime.js';
+import { prepareSkillDelivery } from './skills/delivery.js';
 import { sessionKey, sessionAnchorId } from './types.js';
-import { claimPendingResponseCard, COMPLETED_REACTION_EMOJI_TYPE, markPendingResponseCardPatchedIfCurrent, syncPendingResponseState } from './pending-response.js';
+import { DONE_REACTION_EMOJI_TYPE } from './pending-response.js';
 import { buildTerminalUrl } from './terminal-url.js';
 import { prependBotmuxBin } from './botmux-wrapper.js';
 import { usageLimitStateKey } from '../utils/cli-usage-limit.js';
@@ -185,13 +186,21 @@ function loadKnownBotOpenIdsForApp(larkAppId) {
     }
     return knownBotOpenIdsFromCrossRef(crossRef, botEntries, larkAppId);
 }
+/** CLIs whose model→Lark delivery is the daemon's stdout-runner fallback card
+ *  (NOT the model calling `botmux send`): mira (Web API runner) and mir (local
+ *  mircli runner). They can't @-trigger a peer bot themselves, so for bot-to-bot
+ *  handoffs the fallback card must carry the real <at> back to the dispatcher. */
+function isRunnerDeliveryCli(cliId) {
+    return cliId === 'mira' || cliId === 'mir';
+}
 function daemonCardFooterRecipientOpenId(ds, effectiveCliId) {
     const owner = ds.session.ownerOpenId;
     if (!owner) {
-        // Mira runs through botmux's API runner and cannot execute `botmux send`
-        // itself. For bot-to-bot handoffs, address the daemon fallback card back
-        // to the original dispatcher so orchestration resumes.
-        if (effectiveCliId === 'mira' && ds.session.quoteTargetSenderIsBot && ds.session.creatorOpenId) {
+        // Mira / Mir run through botmux's stdout-runner and cannot execute
+        // `botmux send` to @-trigger a peer bot. For bot-to-bot handoffs, address
+        // the daemon fallback card back to the original dispatcher so orchestration
+        // resumes (the card's real <at> is what re-wakes the dispatching bot).
+        if (isRunnerDeliveryCli(effectiveCliId) && ds.session.quoteTargetSenderIsBot && ds.session.creatorOpenId) {
             return ds.session.creatorOpenId;
         }
         return undefined;
@@ -200,9 +209,10 @@ function daemonCardFooterRecipientOpenId(ds, effectiveCliId) {
         if (loadKnownBotOpenIdsForApp(ds.larkAppId).has(owner)) {
             // `/repo`-primed dispatch records the dispatching bot as owner (unlike
             // the @-mention auto-create path, which nulls ownerOpenId for bot
-            // senders). Same Mira constraint applies: the daemon fallback is Mira's
-            // only reply channel, so address the dispatcher bot here too.
-            return effectiveCliId === 'mira' ? owner : undefined;
+            // senders). Same constraint for the stdout-runner CLIs (mira/mir): the
+            // daemon fallback card is their only @-trigger channel, so address the
+            // dispatcher bot here too.
+            return isRunnerDeliveryCli(effectiveCliId) ? owner : undefined;
         }
         return owner;
     }
@@ -1348,6 +1358,16 @@ export function forkWorker(ds, prompt, resume = false) {
     const cwd = rawCwd && existsSync(rawCwd) ? rawCwd : homedir();
     if (cwd !== rawCwd)
         logger.warn(`[${t}] workingDir "${rawCwd}" does not exist — falling back to ${cwd}`);
+    // Materialise the resolved launch dir on the live session. getSessionWorkingDir()
+    // falls back to the bot-default workingDir, but the usage ledger and dashboard read
+    // `ds.workingDir ?? s.workingDir` RAW (without that fallback). A session that inherits
+    // the bot-default workingDir — i.e. one never pinned via /repo or /cd — therefore leaves
+    // ds.workingDir undefined, so getSessionTokenUsage() is handed cwd=undefined, cannot
+    // locate the CLI transcript, and the session's token usage silently never records.
+    // Pinning the resolved cwd here (it equals what the worker actually forked into) closes
+    // that gap without touching the persisted session.workingDir "unset = follow default"
+    // semantics: this is re-derived on every fork/restore.
+    ds.workingDir = cwd;
     // Sandbox decision is RECORDED ON THE SESSION at creation and reused on
     // restore — so toggling the live bot flag never retroactively (un)sandboxes a
     // historical session. A brand-new session (resume=false) with no recorded
@@ -1395,6 +1415,33 @@ export function forkWorker(ds, prompt, resume = false) {
     const familyAdapter = createCliAdapterSync(botCfg.cliId, botCfg.cliPathOverride);
     if (familyAdapter.claudeStateJsonPath)
         ensureClaudeFolderTrust(cwd, familyAdapter.claudeStateJsonPath);
+    let skillPluginDir;
+    let skillReadonlyRoots;
+    if (!resume && prompt.trim().length > 0) {
+        const preparedSkills = prepareSessionSkillPrompt({
+            sessionId: ds.session.sessionId,
+            cliId: botCfg.cliId,
+            workingDir: cwd,
+            prompt,
+            botPolicy: botCfg.skills,
+        });
+        prompt = preparedSkills.prompt;
+        const delivery = prepareSkillDelivery(familyAdapter, preparedSkills.manifest, preparedSkills.manifest?.delivery ?? 'auto');
+        skillPluginDir = delivery.pluginDir;
+        skillReadonlyRoots = delivery.readonlyRoots.length ? delivery.readonlyRoots : undefined;
+        for (const diagnostic of delivery.diagnostics)
+            logger.warn(`[${t}] skill delivery: ${diagnostic}`);
+        if (delivery.fatal) {
+            const reason = delivery.diagnostics.join(', ') || 'unknown';
+            const message = tr('worker.skill_delivery_failed', { reason }, botLocale(botCfg));
+            logger.warn(`[${t}] Skill delivery blocked session start: ${reason}`);
+            void cb.sessionReply(sessionAnchorId(ds), message, undefined, ds.larkAppId, fallbackTurnId(ds, undefined))
+                .catch((err) => logger.warn(`[${t}] Failed to notify skill delivery error: ${err?.message ?? err}`));
+            void closeSession(ds.session.sessionId)
+                .catch((err) => logger.warn(`[${t}] Failed to close skill delivery error session: ${err?.message ?? err}`));
+            return;
+        }
+    }
     // Prepend ~/.botmux/bin to PATH so CLIs can call `botmux send` etc.
     // The wrapper script there is written by the daemon at startup.
     const botmuxBinDir = join(homedir(), '.botmux', 'bin');
@@ -1409,6 +1456,7 @@ export function forkWorker(ds, prompt, resume = false) {
             CLAUDECODE: undefined,
             BOTMUX: '1', // Marker so user scripts/skills can detect a botmux-spawned CLI
             SESSION_DATA_DIR: config.session.dataDir,
+            BOTMUX_SESSION_ID: ds.session.sessionId,
             LARK_APP_ID: botCfg.larkAppId,
             LARK_APP_SECRET: botCfg.larkAppSecret,
         },
@@ -1465,6 +1513,8 @@ export function forkWorker(ds, prompt, resume = false) {
         botOpenId: bot.botOpenId,
         locale: botLocale(botCfg),
         turnId: ds.currentReplyTarget?.turnId,
+        skillPluginDir,
+        skillReadonlyRoots,
     };
     worker.send(initMsg);
     ds.initConfig = initMsg;
@@ -1727,10 +1777,12 @@ function setupWorkerHandlers(ds, worker) {
                         source: 'screen_update',
                         content: msg.content,
                     });
-                    // Usage ledger: idle/limited edges are turn boundaries — append the
-                    // token delta accrued during the turn that just finished.
+                    // Usage ledger + turn reactions: idle/limited edges are turn
+                    // boundaries. Append the token delta, and flip this turn's pending ✋
+                    // reactions to ✅ (best-effort, never blocks the status pipeline).
                     if (ds.lastScreenStatus === 'idle' || ds.lastScreenStatus === 'limited') {
                         recordUsageForDaemonSession(ds);
+                        void finishTurnReactions(ds);
                     }
                 }
                 // Bot opted out of the streaming card — dashboard SSE above already got
@@ -2038,18 +2090,50 @@ function setupWorkerHandlers(ds, worker) {
 }
 // ─── Bridge final-output delivery (with retry) ──────────────────────────────
 const FINAL_OUTPUT_RETRY_BACKOFF_MS = [0, 5000, 15000]; // immediate, +5s, +15s
+/**
+ * Turn-end half of the two-phase turn reactions (auto-on for card-off sessions,
+ * i.e. streaming card disabled). The 冲! "received" reactions are added per-message at the daemon
+ * acceptance point (`noteTurnReceived`); when the worker next returns to idle we
+ * flip every pending ✋ on this session to ✅ DONE and clear the list. Binding the
+ * start to the message (not a status edge) means type-ahead / busy-batched
+ * messages each get their own reaction and all settle together here.
+ *
+ * Every Feishu call is best-effort — a failure only means a missing emoji, so it
+ * must never throw into the status pipeline (callers invoke as `void`).
+ */
+async function finishTurnReactions(ds) {
+    const list = ds.pendingAckReactions;
+    if (!list || list.length === 0)
+        return;
+    // Detach the batch first so a second idle edge can't double-flip it.
+    ds.pendingAckReactions = [];
+    for (const ack of list) {
+        if (ack.reactionId) {
+            try {
+                await removeReaction(ds.larkAppId, ack.messageId, ack.reactionId);
+            }
+            catch (err) {
+                logger.debug(`[reaction] failed to remove received reaction ${ack.reactionId}: ${err?.message ?? err}`);
+            }
+        }
+        try {
+            await addReaction(ds.larkAppId, ack.messageId, DONE_REACTION_EMOJI_TYPE);
+        }
+        catch (err) {
+            logger.debug(`[reaction] failed to add done reaction to ${ack.messageId}: ${err?.message ?? err}`);
+        }
+    }
+}
 /** Deliver a bridge `final_output` to Lark. The worker emits each turn
  *  exactly once (it pops the turn off its queue at emit time), so the
  *  daemon owns retries on transient failures. After 3 attempts we log
  *  and give up — the user's answer is lost; better than leaking memory
  *  via an unbounded retry loop. */
-function deliverFinalOutput(ds, msg, t, attempt, lockedPendingCardId, lockedQuoteTargetId) {
+function deliverFinalOutput(ds, msg, t, attempt) {
     const cb = requireCallbacks();
     const effectiveCliId = ds.session.cliId ?? getBot(ds.larkAppId).config.cliId;
     const scopedReply = (content, msgType, turnId) => cb.sessionReply(sessionAnchorId(ds), content, msgType, ds.larkAppId, fallbackTurnId(ds, turnId));
     setTimeout(async () => {
-        let pendingCardId;
-        let pendingQuoteTargetId;
         // Guard: if the user closed the session (or it was torn down for any
         // other reason) between attempts, don't post a stale final answer to
         // a closed thread.
@@ -2062,28 +2146,12 @@ function deliverFinalOutput(ds, msg, t, attempt, lockedPendingCardId, lockedQuot
             // 发表为文档评论（而非飞书卡片），状态卡/占位卡仍留在飞书会话起点。
             const docTurn = ds.docCommentTurns?.get(msg.turnId);
             if (docTurn) {
-                const loc = localeForBot(ds.larkAppId);
                 // 嵌套回复到用户那条评论 thread（已挂在其下，无需再 ↪ 前缀）。这是兜底路径
                 // （模型没显式 botmux send），默认 @ 回原评论人，仅首块加。
                 const chunks = chunkCommentText(msg.content);
                 for (let i = 0; i < chunks.length; i++) {
                     await replyToDocComment(ds.larkAppId, { fileToken: docTurn.fileToken, fileType: docTurn.fileType }, docTurn.commentId, chunks[i], i === 0 ? docTurn.replyToOpenId : undefined);
                 }
-                // 收尾飞书侧占位卡（streaming-disabled 会话），避免停在「处理中」。
-                // streaming 卡（若开启）会在 idle 自行冻结，无需在此处理。
-                const donePendingId = lockedPendingCardId ?? claimPendingResponseCard(ds.session);
-                if (donePendingId) {
-                    try {
-                        await updateMessage(ds.larkAppId, donePendingId, buildMarkdownCard(tr('daemon.doc_comment_replied_card', undefined, loc), daemonCardFooterRecipientOpenId(ds, effectiveCliId), resolveBrandLabel(ds.larkAppId), loc));
-                        markPendingResponseCardPatchedIfCurrent(ds.session, donePendingId);
-                        syncPendingResponseState(ds, ds.session);
-                        sessionStore.updateSession(ds.session);
-                    }
-                    catch (err) {
-                        if (!(err instanceof MessageWithdrawnError))
-                            logger.warn(`[${t}] failed to finalize 飞书 pending card for doc-comment turn: ${err?.message ?? err}`);
-                    }
-                }
                 ds.docCommentTurns?.delete(msg.turnId);
                 ds.lastBridgeEmittedUuid = msg.lastUuid;
                 logger.info(`[${t}] doc-comment final_output → posted ${chunks.length} comment(s) on file=${docTurn.fileToken.slice(0, 12)} (turn ${msg.turnId.substring(0, 8)})`);
@@ -2114,41 +2182,10 @@ function deliverFinalOutput(ds, msg, t, attempt, lockedPendingCardId, lockedQuot
                     locale: localeForBot(ds.larkAppId),
                 })
                 : buildMarkdownCard(msg.content, recipientOpenId, resolveBrandLabel(ds.larkAppId), localeForBot(ds.larkAppId));
-            pendingCardId = lockedPendingCardId ?? claimPendingResponseCard(ds.session);
-            pendingQuoteTargetId = lockedQuoteTargetId ?? ds.session.quoteTargetId;
-            if (pendingCardId) {
-                try {
-                    if (ds.session.pendingResponseCardId !== pendingCardId) {
-                        await scopedReply(cardJson, 'interactive', msg.turnId);
-                    }
-                    else {
-                        writePendingResponsePatchMarker(ds.session.sessionId, pendingCardId);
-                        await updateMessage(ds.larkAppId, pendingCardId, cardJson);
-                        markPendingResponsePatchMarkerPatched(ds.session.sessionId);
-                        markPendingResponseCardPatchedIfCurrent(ds.session, pendingCardId);
-                        syncPendingResponseState(ds, ds.session);
-                        sessionStore.updateSession(ds.session);
-                        clearPendingResponsePatchMarker(ds.session.sessionId);
-                        if (pendingQuoteTargetId && ds.session.lastPatchedResponseCardId === pendingCardId) {
-                            addReaction(ds.larkAppId, pendingQuoteTargetId, COMPLETED_REACTION_EMOJI_TYPE)
-                                .catch((err) => logger.warn(`[${t}] failed to add completion reaction to ${pendingQuoteTargetId}: ${err?.message ?? err}`));
-                        }
-                    }
-                }
-                catch (err) {
-                    clearPendingResponsePatchMarker(ds.session.sessionId);
-                    if (!(err instanceof MessageWithdrawnError))
-                        throw err;
-                    logger.warn(`[${t}] Pending response card withdrawn while forwarding final_output; sending a new reply`);
-                    await scopedReply(cardJson, 'interactive', msg.turnId);
-                    markPendingResponseCardPatchedIfCurrent(ds.session, pendingCardId);
-                    syncPendingResponseState(ds, ds.session);
-                    sessionStore.updateSession(ds.session);
-                }
-            }
-            else {
-                await scopedReply(cardJson, 'interactive', msg.turnId);
-            }
+            // Always deliver the answer as a fresh message — never PATCH a card in
+            // place. message.patch is silent (no Feishu notification / unread), which
+            // used to swallow the answer; a brand-new message always pings.
+            await scopedReply(cardJson, 'interactive', msg.turnId);
             ds.lastBridgeEmittedUuid = msg.lastUuid;
             logger.info(`[${t}] Bridge final_output forwarded (turn ${msg.turnId.substring(0, 8)}, ${msg.content.length} chars, kind=${msg.kind ?? 'bridge'}, attempt ${attempt + 1})`);
         }
@@ -2161,8 +2198,6 @@ function deliverFinalOutput(ds, msg, t, attempt, lockedPendingCardId, lockedQuot
                 cb.closeSession(ds);
                 return;
             }
-            if (pendingCardId)
-                clearPendingResponsePatchMarker(ds.session.sessionId);
             const next = attempt + 1;
             if (next >= FINAL_OUTPUT_RETRY_BACKOFF_MS.length) {
                 logger.error(`[${t}] Bridge final_output gave up after ${next} attempts (turn ${msg.turnId.substring(0, 8)}): ${err.message}`);
@@ -2171,7 +2206,7 @@ function deliverFinalOutput(ds, msg, t, attempt, lockedPendingCardId, lockedQuot
                 return;
             }
             logger.warn(`[${t}] Bridge final_output attempt ${next} failed (${err.message}); retrying in ${FINAL_OUTPUT_RETRY_BACKOFF_MS[next]}ms`);
-            deliverFinalOutput(ds, msg, t, next, pendingCardId, pendingQuoteTargetId);
+            deliverFinalOutput(ds, msg, t, next);
         }
     }, FINAL_OUTPUT_RETRY_BACKOFF_MS[attempt] ?? 0);
 }
@@ -2179,6 +2214,7 @@ function deliverFinalOutput(ds, msg, t, attempt, lockedPendingCardId, lockedQuot
  *  fork. Intentionally underscored to discourage non-test callers. */
 export const __testOnly_deliverFinalOutput = deliverFinalOutput;
 export const __testOnly_setupWorkerHandlers = setupWorkerHandlers;
+export const __testOnly_finishTurnReactions = finishTurnReactions;
 // ─── Fork adopt worker ──────────────────────────────────────────────────────
 export function forkAdoptWorker(ds, opts) {
     const cb = requireCallbacks();