@foxden-app/foxclaw 0.5.9 → 0.5.11

package/dist/controller/controller.js

@@ -35,6 +35,7 @@ const CODEX_AUTH_PROACTIVE_REFRESH_INTERVAL_MS = 60 * 60_000;
 const CODEX_AUTH_PROACTIVE_REFRESH_INITIAL_DELAY_MS = 5 * 60_000;
 const USER_INPUT_SUBMITTED_NOTICE_MS = 90_000;
 const SELF_UPDATE_STATUS_POLL_MS = 1000;
+const ATTACHMENT_BATCH_MERGE_WINDOW_MS = 120_000;
 const PLAN_IMPLEMENTATION_CODING_MESSAGE = 'Implement the plan.';
 const PLAN_IMPLEMENTATION_CLEAR_CONTEXT_PREFIX = 'A previous agent produced the plan below to accomplish the user\'s task. Implement the plan in a fresh context. Treat the plan as the source of user intent, re-read files as needed, and carry the work through implementation and verification.';
 const PINNED_HELP_COMMANDS = [
@@ -105,11 +106,9 @@ export class BridgeSessionCore {
     activeTurns = new Map();
     activeTurnsByTurnId = new Map();
     observedThreadWatchers = new Map();
-    queuedPrompts = new Map();
     pendingTurnErrors = new Map();
     pendingUserInputs = new Map();
     pendingMcpElicitations = new Map();
-    pendingPlanImplementations = new Map();
     pendingLoginsByScope = new Map();
     pendingLoginScopesById = new Map();
     pendingAuthAddsByLoginId = new Map();
@@ -195,7 +194,6 @@ export class BridgeSessionCore {
         });
         this.app.on('disconnected', () => {
             this.attachedThreads.clear();
-            this.queuedPrompts.clear();
             this.threadTokenUsageAlerts.clear();
             this.clearObservedThreadWatchers();
             void this.abandonActiveTurns().catch((error) => {
@@ -204,8 +202,13 @@ export class BridgeSessionCore {
             this.updateStatus();
         });
         await this.app.start();
+        this.store.requeueInterruptedQueuedTurnInputs();
         await this.restorePendingUserInputs();
+        await this.restoreGuidedPlanSessions();
         await this.cleanupStaleTurnPreviews();
+        void this.recoverQueuedTurns().catch((error) => {
+            this.logger.warn('codex.queued_turn_recovery_failed', { error: toErrorMeta(error) });
+        });
         void this.refreshCodexLocalUsageIfNeeded().catch((error) => {
             this.logger.warn('codex.local_usage_background_refresh_failed', { error: formatUserError(error) });
         });
@@ -226,11 +229,9 @@ export class BridgeSessionCore {
         await this.startTelegramPolling();
     }
     async stop() {
-        this.queuedPrompts.clear();
         this.pendingTurnErrors.clear();
         this.pendingUserInputs.clear();
         this.pendingMcpElicitations.clear();
-        this.pendingPlanImplementations.clear();
         this.pendingLoginsByScope.clear();
         this.pendingLoginScopesById.clear();
         this.pendingAuthAddsByLoginId.clear();
@@ -269,6 +270,7 @@ export class BridgeSessionCore {
             currentBindings: this.store.countBindings(),
             pendingApprovals: this.store.countPendingApprovals(),
             pendingUserInputs: this.store.countPendingUserInputs(),
+            queuedTurns: this.store.countQueuedTurnInputs(),
             activeTurns: this.activeTurns.size,
             lastError: this.lastError,
             updatedAt: new Date().toISOString(),
@@ -351,6 +353,13 @@ export class BridgeSessionCore {
             await this.handleCommand(event, locale, decision.command.name, decision.command.args);
             return;
         }
+        if (event.attachments.length > 0) {
+            await this.handleTelegramAttachmentBatch(event, locale, decision.text);
+            return;
+        }
+        if (await this.consumePendingAttachmentBatchWithText(event, locale, decision.text)) {
+            return;
+        }
         if (this.findActiveTurn(scopeId)) {
             await this.handleActiveTurnInboundMessage(event, locale, decision.text);
             return;
@@ -408,6 +417,7 @@ export class BridgeSessionCore {
                     t(locale, 'status_sync_on_turn_complete', { value: t(locale, this.config.codexAppSyncOnTurnComplete ? 'yes' : 'no') }),
                     t(locale, 'status_pending_approvals', { value: this.store.countPendingApprovals() }),
                     t(locale, 'status_pending_user_inputs', { value: this.store.countPendingUserInputs() }),
+                    t(locale, 'status_queued_turns', { value: this.store.countQueuedTurnInputs(scopeId) }),
                     t(locale, 'status_active_turns', { value: this.activeTurns.size }),
                 ];
                 if (serviceStatus) {
@@ -582,7 +592,7 @@ export class BridgeSessionCore {
                     await this.sendMessage(scopeId, t(locale, 'thread_is_archived_use_unarchive'));
                     return;
                 }
-                this.queuedPrompts.delete(scopeId);
+                this.store.cancelQueuedTurnInputs(scopeId);
                 await this.stopWatchingScopeThread(scopeId, thread.threadId);
                 let binding;
                 try {
@@ -1055,7 +1065,7 @@ export class BridgeSessionCore {
             await this.handleAuthListViewCallback(event, authClearSearchMatch[1], 'clear_search', locale);
             return;
         }
-        const authActionMatch = /^auth:([a-f0-9]+):(login_device|reload|refresh_all_confirm|refresh_all_cancel|refresh_all)$/.exec(event.data);
+        const authActionMatch = /^auth:([a-f0-9]+):(login_device|reload|safe_sync|refresh_all_confirm|refresh_all_cancel|refresh_all)$/.exec(event.data);
         if (authActionMatch) {
             await this.handleAuthPanelActionCallback(event, authActionMatch[1], authActionMatch[2], locale);
             return;
@@ -1075,6 +1085,11 @@ export class BridgeSessionCore {
             await this.handlePlanImplementationCallback(event, planImplMatch[1], planImplMatch[2], locale);
             return;
         }
+        const attachmentBatchMatch = /^attach:([a-f0-9]+):(analyze|clear)$/.exec(event.data);
+        if (attachmentBatchMatch) {
+            await this.handleAttachmentBatchCallback(event, attachmentBatchMatch[1], attachmentBatchMatch[2], locale);
+            return;
+        }
         const mcpElicitationMatch = /^mcpel:([a-f0-9]+):(accept|decline|cancel)$/.exec(event.data);
         if (mcpElicitationMatch) {
             await this.handleMcpElicitationCallback(event, mcpElicitationMatch[1], mcpElicitationMatch[2], locale);
@@ -1782,6 +1797,7 @@ export class BridgeSessionCore {
             await this.completeTurn(active);
             await this.cleanupObservedTransientMessages(active);
             await this.finalizeUserInputsForTurn(active, 'resolved');
+            this.markQueuedTurnCompleted(active);
         }
         finally {
             if (active.isObserved) {
@@ -2076,7 +2092,7 @@ export class BridgeSessionCore {
         return turn?.status === 'inProgress' && snapshot.activeFlags.includes('waitingOnUserInput');
     }
     async maybeSendPlanImplementationPrompt(active) {
-        if (active.interruptRequested || this.queuedPrompts.has(active.scopeId)) {
+        if (active.interruptRequested || this.store.countQueuedTurnInputs(active.scopeId) > 0) {
             return false;
         }
         if (this.hasPendingUserInputForTurn(active.scopeId, active.turnId)) {
@@ -2092,8 +2108,8 @@ export class BridgeSessionCore {
             return false;
         }
         const binding = this.store.getBinding(active.scopeId);
-        const record = {
-            localId: crypto.randomBytes(8).toString('hex'),
+        const session = {
+            sessionId: crypto.randomBytes(8).toString('hex'),
             scopeId: active.scopeId,
             chatId: active.chatId,
             chatType: active.chatType,
@@ -2103,31 +2119,68 @@ export class BridgeSessionCore {
             cwd: binding?.cwd ?? null,
             planMarkdown,
             messageId: null,
+            state: 'awaiting_confirmation',
             createdAt: Date.now(),
+            updatedAt: Date.now(),
+            resolvedAt: null,
         };
-        this.pendingPlanImplementations.set(record.localId, record);
+        this.store.saveGuidedPlanSession(session);
+        const record = this.pendingPlanImplementationFromSession(session);
         const locale = this.localeForChat(active.scopeId);
         const messageId = await this.sendMessage(active.scopeId, renderPlanImplementationPrompt(locale, record), planImplementationKeyboard(locale, record.localId));
-        record.messageId = messageId;
+        this.store.updateGuidedPlanSessionMessage(session.sessionId, messageId);
         return true;
     }
     findPendingPlanImplementation(scopeId, turnId) {
-        for (const record of this.pendingPlanImplementations.values()) {
-            if (record.scopeId !== scopeId) {
-                continue;
-            }
-            if (turnId !== undefined && record.turnId !== turnId) {
-                continue;
-            }
-            return record;
-        }
-        return null;
+        const session = this.store.findOpenGuidedPlanSession(scopeId, turnId);
+        return session ? this.pendingPlanImplementationFromSession(session) : null;
     }
     clearPlanImplementationPromptsForScope(scopeId) {
-        for (const [localId, record] of this.pendingPlanImplementations.entries()) {
-            if (record.scopeId === scopeId) {
-                this.pendingPlanImplementations.delete(localId);
+        const record = this.store.findOpenGuidedPlanSession(scopeId);
+        if (record) {
+            this.store.updateGuidedPlanSessionState(record.sessionId, 'cancelled');
+        }
+    }
+    pendingPlanImplementationFromSession(session) {
+        return {
+            localId: session.sessionId,
+            scopeId: session.scopeId,
+            chatId: session.chatId,
+            chatType: session.chatType,
+            topicId: session.topicId,
+            threadId: session.threadId,
+            turnId: session.turnId,
+            cwd: session.cwd,
+            planMarkdown: session.planMarkdown,
+            messageId: session.messageId,
+            createdAt: session.createdAt,
+        };
+    }
+    async restoreGuidedPlanSessions() {
+        for (const session of this.store.listOpenGuidedPlanSessions()) {
+            if (!this.messaging.canSendToScope(session.scopeId)) {
+                continue;
             }
+            const locale = this.localeForChat(session.scopeId);
+            const record = this.pendingPlanImplementationFromSession(session);
+            if (session.messageId !== null) {
+                try {
+                    await this.editMessage(session.scopeId, session.messageId, renderPlanImplementationPrompt(locale, record), planImplementationKeyboard(locale, record.localId));
+                    continue;
+                }
+                catch (error) {
+                    if (!isTelegramMessageGone(error)) {
+                        this.logger.warn('telegram.plan_impl_restore_edit_failed', {
+                            sessionId: session.sessionId,
+                            scopeId: session.scopeId,
+                            messageId: session.messageId,
+                            error: toErrorMeta(error),
+                        });
+                    }
+                }
+            }
+            const messageId = await this.sendMessage(session.scopeId, renderPlanImplementationPrompt(locale, record), planImplementationKeyboard(locale, record.localId));
+            this.store.updateGuidedPlanSessionMessage(session.sessionId, messageId);
         }
     }
     hasPendingUserInputForTurn(scopeId, turnId) {
@@ -2180,17 +2233,18 @@ export class BridgeSessionCore {
         }
     }
     async handlePlanImplementationCallback(event, localId, action, locale) {
-        const record = this.pendingPlanImplementations.get(localId);
-        if (!record) {
+        const session = this.store.getGuidedPlanSession(localId);
+        if (!session || session.state !== 'awaiting_confirmation') {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'plan_impl_expired'));
             return;
         }
+        const record = this.pendingPlanImplementationFromSession(session);
         if (record.scopeId !== event.scopeId || (record.messageId !== null && record.messageId !== event.messageId)) {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'plan_impl_mismatch'));
             return;
         }
         if (action === 'stay') {
-            this.pendingPlanImplementations.delete(localId);
+            this.store.updateGuidedPlanSessionState(localId, 'cancelled');
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
             if (record.messageId !== null) {
                 await this.editMessage(record.scopeId, record.messageId, t(locale, 'plan_impl_staying'), []);
@@ -2201,9 +2255,9 @@ export class BridgeSessionCore {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'wait_current_turn'));
             return;
         }
-        this.pendingPlanImplementations.delete(localId);
         await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
         const turn = await this.startPlanImplementationTurn(record, action === 'fresh');
+        this.store.updateGuidedPlanSessionState(localId, 'completed');
         if (record.messageId !== null) {
             await this.editMessage(record.scopeId, record.messageId, t(locale, action === 'fresh' ? 'plan_impl_started_fresh' : 'plan_impl_started', {
                 threadId: turn.threadId,
@@ -2218,17 +2272,18 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'usage_planimpl'));
             return;
         }
-        const record = this.pendingPlanImplementations.get(localId);
-        if (!record) {
+        const session = this.store.getGuidedPlanSession(localId);
+        if (!session || session.state !== 'awaiting_confirmation') {
             await this.sendMessage(scopeId, t(locale, 'plan_impl_expired'));
             return;
         }
+        const record = this.pendingPlanImplementationFromSession(session);
         if (record.scopeId !== scopeId) {
             await this.sendMessage(scopeId, t(locale, 'plan_impl_mismatch'));
             return;
         }
         if (action === 'stay') {
-            this.pendingPlanImplementations.delete(localId);
+            this.store.updateGuidedPlanSessionState(localId, 'cancelled');
             if (record.messageId !== null) {
                 await this.editMessage(record.scopeId, record.messageId, t(locale, 'plan_impl_staying'), []);
             }
@@ -2241,8 +2296,8 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'wait_current_turn'));
             return;
         }
-        this.pendingPlanImplementations.delete(localId);
         const turn = await this.startPlanImplementationTurn(record, action === 'fresh');
+        this.store.updateGuidedPlanSessionState(localId, 'completed');
         const message = t(locale, action === 'fresh' ? 'plan_impl_started_fresh' : 'plan_impl_started', {
             threadId: turn.threadId,
             turnId: turn.turnId,
@@ -2497,6 +2552,22 @@ export class BridgeSessionCore {
         }
         return input;
     }
+    buildTurnInputFromStagedAttachments(text, attachments) {
+        const input = [{
+                type: 'text',
+                text: buildAttachmentPrompt(text, attachments),
+                text_elements: [],
+            }];
+        for (const attachment of attachments) {
+            if (!attachment.nativeImage)
+                continue;
+            input.push({
+                type: 'localImage',
+                path: attachment.localPath,
+            });
+        }
+        return input;
+    }
     async resolveServiceTierForTurn(scopeId, settings) {
         if (!settings) {
             return undefined;
@@ -2582,8 +2653,174 @@ export class BridgeSessionCore {
         }
         return staged;
     }
-    async registerActiveTurn(scopeId, chatId, chatType, topicId, threadId, turnId, previewMessageId, authRetry = null, collaborationMode = DEFAULT_COLLABORATION_MODE) {
-        const active = this.createActiveTurnState(scopeId, chatId, chatType, topicId, threadId, turnId, previewMessageId, false, collaborationMode);
+    async handleTelegramAttachmentBatch(event, locale, text) {
+        const active = this.findActiveTurn(event.scopeId);
+        if (active?.isObserved) {
+            await this.sendMessage(event.scopeId, t(locale, 'watch_read_only_active'));
+            return;
+        }
+        const existingBinding = this.store.getBinding(event.scopeId);
+        const binding = active
+            ? {
+                threadId: active.threadId,
+                cwd: existingBinding?.cwd ?? this.config.defaultCwd,
+            }
+            : existingBinding
+                ? await this.ensureThreadReady(event.scopeId, existingBinding)
+                : await this.createBinding(event.scopeId, null);
+        const cwd = binding.cwd ?? this.config.defaultCwd;
+        const stagedAttachments = await this.stageAttachments(cwd, binding.threadId, event.attachments, locale);
+        const mediaGroupId = event.mediaGroupId ?? null;
+        const now = Date.now();
+        const existingBatch = mediaGroupId
+            ? this.store.findPendingAttachmentBatchByMediaGroup(event.scopeId, mediaGroupId)
+            : findReusableStandaloneAttachmentBatch(this.store.getLatestPendingAttachmentBatch(event.scopeId), now);
+        const existingAttachments = existingBatch ? parseStagedTelegramAttachments(existingBatch.attachmentsJson) : [];
+        const record = {
+            batchId: existingBatch?.batchId ?? crypto.randomBytes(8).toString('hex'),
+            scopeId: event.scopeId,
+            chatId: event.chatId,
+            chatType: event.chatType,
+            topicId: event.topicId,
+            threadId: binding.threadId,
+            cwd,
+            mediaGroupId,
+            attachmentsJson: JSON.stringify([...existingAttachments, ...stagedAttachments]),
+            caption: mergeAttachmentBatchCaption(existingBatch?.caption ?? '', text.trim()),
+            messageId: existingBatch?.messageId ?? null,
+            status: 'pending',
+            createdAt: existingBatch?.createdAt ?? now,
+            updatedAt: now,
+            resolvedAt: null,
+        };
+        this.store.savePendingAttachmentBatch(record);
+        await this.renderAttachmentBatchCard(record, locale);
+    }
+    async consumePendingAttachmentBatchWithText(event, locale, text) {
+        const prompt = text.trim();
+        if (!prompt) {
+            return false;
+        }
+        const batch = this.store.getLatestPendingAttachmentBatch(event.scopeId);
+        if (!batch) {
+            return false;
+        }
+        await this.consumePendingAttachmentBatch(batch, locale, prompt, event.messageId);
+        return true;
+    }
+    async handleAttachmentBatchCallback(event, batchId, action, locale) {
+        const batch = this.store.getPendingAttachmentBatch(batchId);
+        if (!batch || batch.status !== 'pending') {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'attachment_batch_missing'));
+            return;
+        }
+        if (batch.scopeId !== event.scopeId || (batch.messageId !== null && batch.messageId !== event.messageId)) {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'attachment_batch_mismatch'));
+            return;
+        }
+        if (action === 'clear') {
+            this.store.resolvePendingAttachmentBatch(batch.batchId, 'cleared');
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
+            if (batch.messageId !== null) {
+                await this.editMessage(batch.scopeId, batch.messageId, t(locale, 'attachment_batch_cleared'), []);
+            }
+            return;
+        }
+        const prompt = batch.caption.trim() || t(locale, 'attachment_batch_default_prompt');
+        await this.consumePendingAttachmentBatch(batch, locale, prompt, batch.messageId);
+        await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
+    }
+    async consumePendingAttachmentBatch(batch, locale, prompt, sourceMessageId) {
+        const active = this.findActiveTurn(batch.scopeId);
+        if (active?.isObserved) {
+            await this.sendMessage(batch.scopeId, t(locale, 'watch_read_only_active'));
+            return;
+        }
+        const attachments = parseStagedTelegramAttachments(batch.attachmentsJson);
+        const input = this.buildTurnInputFromStagedAttachments(prompt, attachments);
+        if (active) {
+            const queueId = this.enqueuePreparedTurnInput({
+                scopeId: batch.scopeId,
+                chatId: batch.chatId,
+                chatType: batch.chatType,
+                topicId: batch.topicId,
+                threadId: active.threadId,
+                input,
+                sourceSummary: summarizeStagedAttachmentInput(prompt, attachments),
+                messageId: sourceMessageId,
+            });
+            this.store.resolvePendingAttachmentBatch(batch.batchId, 'consumed');
+            if (batch.messageId !== null) {
+                await this.editMessage(batch.scopeId, batch.messageId, t(locale, 'attachment_batch_queued', {
+                    id: shortId(queueId),
+                    position: this.store.countQueuedTurnInputs(batch.scopeId),
+                }), []);
+            }
+            else {
+                await this.sendMessage(batch.scopeId, t(locale, 'attachment_batch_queued', {
+                    id: shortId(queueId),
+                    position: this.store.countQueuedTurnInputs(batch.scopeId),
+                }));
+            }
+            return;
+        }
+        this.store.resolvePendingAttachmentBatch(batch.batchId, 'consumed');
+        if (batch.messageId !== null) {
+            await this.editMessage(batch.scopeId, batch.messageId, t(locale, 'attachment_batch_consumed'), []);
+        }
+        await this.startTurnFromPreparedAttachmentBatch(batch, input);
+    }
+    async startTurnFromPreparedAttachmentBatch(batch, input) {
+        this.clearPlanImplementationPromptsForScope(batch.scopeId);
+        await this.stopWatchingScopeThread(batch.scopeId);
+        const existingBinding = this.store.getBinding(batch.scopeId);
+        const binding = await this.ensureThreadReady(batch.scopeId, {
+            chatId: batch.scopeId,
+            threadId: batch.threadId,
+            cwd: existingBinding?.cwd ?? batch.cwd,
+            updatedAt: Date.now(),
+        });
+        this.store.setBinding(batch.scopeId, binding.threadId, binding.cwd);
+        await this.sendTyping(batch.scopeId);
+        const turnState = await this.startTurnWithRecovery(batch.scopeId, binding, input);
+        if (turnState.collaborationMode === 'plan') {
+            this.store.setChatCollaborationMode(batch.scopeId, DEFAULT_COLLABORATION_MODE);
+        }
+        await this.registerActiveTurn(batch.scopeId, batch.chatId, batch.chatType, batch.topicId, turnState.threadId, turnState.turnId, 0, {
+            input,
+            threadId: turnState.threadId,
+            cwd: this.store.getBinding(batch.scopeId)?.cwd ?? binding.cwd ?? this.config.defaultCwd,
+            chatId: batch.chatId,
+            chatType: batch.chatType,
+            topicId: batch.topicId,
+            collaborationMode: turnState.collaborationMode,
+            failedAuthTargets: new Set(),
+        }, turnState.collaborationMode);
+    }
+    async renderAttachmentBatchCard(record, locale) {
+        const text = renderAttachmentBatchMessage(locale, record);
+        const keyboard = attachmentBatchKeyboard(locale, record.batchId);
+        if (record.messageId !== null) {
+            try {
+                await this.editMessage(record.scopeId, record.messageId, text, keyboard);
+                return;
+            }
+            catch (error) {
+                if (!isTelegramMessageGone(error)) {
+                    this.logger.warn('telegram.attachment_batch_edit_failed', {
+                        batchId: record.batchId,
+                        scopeId: record.scopeId,
+                        messageId: record.messageId,
+                        error: toErrorMeta(error),
+                    });
+                }
+            }
+        }
+        const messageId = await this.sendMessage(record.scopeId, text, keyboard);
+        this.store.updatePendingAttachmentBatchMessage(record.batchId, messageId);
+    }
+    async registerActiveTurn(scopeId, chatId, chatType, topicId, threadId, turnId, previewMessageId, authRetry = null, collaborationMode = DEFAULT_COLLABORATION_MODE, queuedInputId = null) {
+        const active = this.createActiveTurnState(scopeId, chatId, chatType, topicId, threadId, turnId, previewMessageId, false, collaborationMode, queuedInputId);
         active.authRetry = authRetry;
         this.setActiveTurn(scopeId, turnId, active);
         const pendingError = this.pendingTurnErrors.get(turnId);
@@ -2607,7 +2844,7 @@ export class BridgeSessionCore {
             this.logger.warn('telegram.preview_keyboard_attach_failed', { error: String(error), turnId });
         }
     }
-    createActiveTurnState(scopeId, chatId, chatType, topicId, threadId, turnId, previewMessageId, isObserved = false, collaborationMode = DEFAULT_COLLABORATION_MODE) {
+    createActiveTurnState(scopeId, chatId, chatType, topicId, threadId, turnId, previewMessageId, isObserved = false, collaborationMode = DEFAULT_COLLABORATION_MODE, queuedInputId = null) {
         let resolver = () => { };
         const completion = new Promise((resolve) => {
             resolver = resolve;
@@ -2621,6 +2858,7 @@ export class BridgeSessionCore {
             isObserved,
             threadId,
             turnId,
+            queuedInputId,
             previewMessageId,
             previewActive: previewMessageId > 0,
             draftId: null,
@@ -2718,7 +2956,7 @@ export class BridgeSessionCore {
     authDisplayBotLabel() {
         if (!this.config.tgScopeBotId)
             return null;
-        return this.botUsername ? `@${this.botUsername}` : this.config.tgScopeBotId;
+        return this.botUsername ? `@${this.botUsername} (${this.config.tgScopeBotId})` : this.config.tgScopeBotId;
     }
     ownsScope(scopeId) {
         if (scopeId.startsWith(BRIDGE_SCOPE_WEIXIN_PREFIX)) {
@@ -2889,6 +3127,7 @@ export class BridgeSessionCore {
                     await this.cleanupObservedTransientMessages(active);
                     await this.finalizeUserInputsForTurn(active, active.interruptRequested ? 'interrupted' : 'resolved');
                     await this.maybeSendPlanImplementationPrompt(active);
+                    this.markQueuedTurnCompleted(active);
                     if (this.config.codexAppSyncOnTurnComplete) {
                         const revealError = await this.tryRevealThread(active.scopeId, active.threadId, 'turn-complete');
                         if (revealError) {
@@ -3595,7 +3834,7 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'usage_takeover'));
             return;
         }
-        this.queuedPrompts.delete(scopeId);
+        this.store.cancelQueuedTurnInputs(scopeId);
         const active = this.findActiveTurn(scopeId);
         if (active) {
             if (active.isObserved) {
@@ -3626,9 +3865,7 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'watch_read_only_active'));
             return;
         }
-        const replaced = this.queuedPrompts.has(scopeId);
-        this.queuedPrompts.set(scopeId, { event, text: nextPrompt });
-        await this.sendMessage(scopeId, t(locale, replaced ? 'queued_prompt_replaced' : 'queued_prompt_set'));
+        await this.queuePromptAfterActiveTurn(event, locale, nextPrompt);
     }
     async handleActiveTurnInboundMessage(event, locale, text) {
         const active = this.findActiveTurn(event.scopeId);
@@ -3663,9 +3900,29 @@ export class BridgeSessionCore {
         }
     }
     async queuePromptAfterActiveTurn(event, locale, text) {
-        const replaced = this.queuedPrompts.has(event.scopeId);
-        this.queuedPrompts.set(event.scopeId, { event, text });
-        await this.sendMessage(event.scopeId, t(locale, replaced ? 'queued_prompt_replaced' : 'queued_prompt_set'));
+        const active = this.findActiveTurn(event.scopeId);
+        if (!active) {
+            await this.startBoundTurnFromEvent(event, locale, text);
+            return;
+        }
+        const input = await this.buildTurnInput({
+            threadId: active.threadId,
+            cwd: this.store.getBinding(event.scopeId)?.cwd ?? this.config.defaultCwd,
+        }, { ...event, text }, locale);
+        const queueId = this.enqueuePreparedTurnInput({
+            scopeId: event.scopeId,
+            chatId: event.chatId,
+            chatType: event.chatType,
+            topicId: event.topicId,
+            threadId: active.threadId,
+            input,
+            sourceSummary: summarizeTelegramInput(text, event.attachments),
+            messageId: event.messageId,
+        });
+        await this.sendMessage(event.scopeId, t(locale, 'queued_prompt_set', {
+            id: shortId(queueId),
+            position: this.store.countQueuedTurnInputs(event.scopeId),
+        }));
     }
     async steerActiveTurn(active, event, locale, text) {
         const binding = {
@@ -3678,16 +3935,87 @@ export class BridgeSessionCore {
         await this.queueTurnRender(active, { forceStatus: true });
         await this.sendMessage(event.scopeId, t(locale, 'steer_sent', { turnId: active.turnId }));
     }
+    enqueuePreparedTurnInput(params) {
+        const now = Date.now();
+        const queueId = crypto.randomBytes(8).toString('hex');
+        this.store.saveQueuedTurnInput({
+            queueId,
+            scopeId: params.scopeId,
+            chatId: params.chatId,
+            chatType: params.chatType,
+            topicId: params.topicId,
+            threadId: params.threadId,
+            inputJson: JSON.stringify(params.input),
+            sourceSummary: params.sourceSummary,
+            messageId: params.messageId,
+            status: 'queued',
+            error: null,
+            createdAt: now,
+            updatedAt: now,
+            resolvedAt: null,
+        });
+        return queueId;
+    }
+    async startBoundTurnFromQueuedInput(record) {
+        const scopeId = record.scopeId;
+        this.clearPlanImplementationPromptsForScope(scopeId);
+        await this.stopWatchingScopeThread(scopeId);
+        const existingBinding = this.store.getBinding(scopeId);
+        const binding = await this.ensureThreadReady(scopeId, {
+            chatId: scopeId,
+            threadId: record.threadId,
+            cwd: existingBinding?.cwd ?? null,
+            updatedAt: Date.now(),
+        });
+        this.store.setBinding(scopeId, binding.threadId, binding.cwd);
+        await this.sendTyping(scopeId);
+        const input = parseStoredTurnInput(record.inputJson);
+        const turnState = await this.startTurnWithRecovery(scopeId, binding, input);
+        if (turnState.collaborationMode === 'plan') {
+            this.store.setChatCollaborationMode(scopeId, DEFAULT_COLLABORATION_MODE);
+        }
+        await this.registerActiveTurn(scopeId, record.chatId, record.chatType, record.topicId, turnState.threadId, turnState.turnId, 0, {
+            input,
+            threadId: turnState.threadId,
+            cwd: this.store.getBinding(scopeId)?.cwd ?? binding.cwd ?? this.config.defaultCwd,
+            chatId: record.chatId,
+            chatType: record.chatType,
+            topicId: record.topicId,
+            collaborationMode: turnState.collaborationMode,
+            failedAuthTargets: new Set(),
+        }, turnState.collaborationMode, record.queueId);
+    }
     async startQueuedPromptIfPresent(scopeId) {
         if (this.findActiveTurn(scopeId)) {
             return;
         }
-        const queued = this.queuedPrompts.get(scopeId);
+        const queued = this.store.peekQueuedTurnInput(scopeId);
         if (!queued) {
             return;
         }
-        this.queuedPrompts.delete(scopeId);
-        await this.startBoundTurnFromEvent(queued.event, this.localeForChat(scopeId, queued.event.languageCode), queued.text);
+        this.store.updateQueuedTurnInputStatus(queued.queueId, 'processing');
+        try {
+            await this.startBoundTurnFromQueuedInput(queued);
+        }
+        catch (error) {
+            this.store.updateQueuedTurnInputStatus(queued.queueId, 'failed', formatUserError(error));
+            throw error;
+        }
+    }
+    async recoverQueuedTurns() {
+        const scopeIds = new Set(this.store.listQueuedTurnInputs().map((record) => record.scopeId));
+        for (const scopeId of scopeIds) {
+            if (!this.messaging.canSendToScope(scopeId)) {
+                continue;
+            }
+            await this.withLock(scopeId, async () => this.startQueuedPromptIfPresent(scopeId));
+        }
+    }
+    markQueuedTurnCompleted(active) {
+        if (!active.queuedInputId) {
+            return;
+        }
+        this.store.updateQueuedTurnInputStatus(active.queuedInputId, 'completed');
     }
     async handleModeCommand(scopeId, locale, args) {
         const raw = args.join(' ').trim();
@@ -3954,16 +4282,28 @@ export class BridgeSessionCore {
     }
     formatSelfUpdateResult(status) {
         const codexUpdateLine = this.formatCodexUpdateResult(status);
+        const releaseNotes = this.formatSelfUpdateReleaseNotes(status);
         if (status.state === 'succeeded') {
             const result = t(status.locale, 'update_succeeded', {
                 from: status.fromVersion,
                 to: status.toVersion ?? t(status.locale, 'unknown'),
             });
-            return codexUpdateLine ? `${result}\n${codexUpdateLine}` : result;
+            return [result, releaseNotes, codexUpdateLine].filter(Boolean).join('\n');
         }
         const result = t(status.locale, 'update_failed', { error: status.error ?? t(status.locale, 'unknown') });
         return codexUpdateLine ? `${result}\n${codexUpdateLine}` : result;
     }
+    formatSelfUpdateReleaseNotes(status) {
+        const notes = status.releaseNotes?.filter(note => note.trim()) ?? [];
+        if (status.state !== 'succeeded' || notes.length === 0) {
+            return null;
+        }
+        return [
+            '',
+            t(status.locale, 'update_changes_title'),
+            ...notes.map(note => `- ${note}`),
+        ].join('\n');
+    }
     formatCodexUpdateResult(status) {
         if (status.codexFromVersion || status.codexToVersion) {
             return t(status.locale, 'update_codex_result', {
@@ -4127,17 +4467,19 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, message);
             return;
         }
-        if (action === 'push' && args[1]?.toLowerCase() === 'all') {
+        if (action === 'safe' || (action === 'push' && args[1]?.toLowerCase() === 'all')) {
             if (!this.canRunGlobalAuthRefresh()) {
                 await this.sendMessage(scopeId, t(locale, 'auth_sync_push_blocked_active'));
                 return;
             }
-            const result = await this.coordinator?.authSyncPushAll?.();
+            const result = await this.runAuthSafeSyncAll();
             if (!result) {
                 await this.sendMessage(scopeId, t(locale, 'auth_sync_disabled'));
                 return;
             }
-            await this.sendMessage(scopeId, t(locale, 'auth_sync_push_done', {
+            await this.sendMessage(scopeId, t(locale, 'auth_sync_safe_done', {
+                localSynced: result.localSynced,
+                localSkipped: result.localSkipped,
                 sent: result.sent,
                 skipped: result.skipped,
             }));
@@ -4145,6 +4487,16 @@ export class BridgeSessionCore {
         }
         await this.sendMessage(scopeId, t(locale, 'usage_auth_sync'));
     }
+    async runAuthSafeSyncAll() {
+        const safeResult = await this.coordinator?.authSyncSafeAll?.();
+        if (safeResult) {
+            return safeResult;
+        }
+        const pushResult = await this.coordinator?.authSyncPushAll?.();
+        return pushResult
+            ? { localSynced: 0, localSkipped: 0, sent: pushResult.sent, skipped: pushResult.skipped }
+            : null;
+    }
     async handleAuthRefreshAllCommand(scopeId, locale, confirmed = false) {
         if (!this.canRunGlobalAuthRefresh()) {
             await this.sendMessage(scopeId, t(locale, 'auth_refresh_all_blocked_active'));
@@ -4653,6 +5005,37 @@ export class BridgeSessionCore {
             await this.handleLoginDeviceCommand(event.scopeId, locale);
             return;
         }
+        if (action === 'safe_sync') {
+            if (!this.canRunGlobalAuthRefresh()) {
+                await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'auth_sync_push_blocked_active'));
+                return;
+            }
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'auth_sync_safe_starting'));
+            if (record.messageId !== null) {
+                await this.editMessage(event.scopeId, record.messageId, t(locale, 'auth_sync_safe_starting'), []);
+            }
+            const result = await this.runAuthSafeSyncAll();
+            if (!result) {
+                if (record.messageId !== null) {
+                    await this.editMessage(event.scopeId, record.messageId, t(locale, 'auth_sync_disabled'), authChoiceKeyboard(locale, record));
+                }
+                return;
+            }
+            const state = await this.listCodexAuthState();
+            await this.applySharedCodexAuthQuotaSnapshots(state);
+            record.candidates = state.candidates;
+            record.createdAt = Date.now();
+            clampCodexAuthListOffset(record);
+            if (record.messageId !== null) {
+                await this.editMessage(event.scopeId, record.messageId, `${t(locale, 'auth_sync_safe_done', {
+                    localSynced: result.localSynced,
+                    localSkipped: result.localSkipped,
+                    sent: result.sent,
+                    skipped: result.skipped,
+                })}\n\n${renderAuthListMessage(locale, state, this.authDisplayBotLabel(), parseWeixinBridgeScope(event.scopeId) !== null, record)}`, authChoiceKeyboard(locale, record));
+            }
+            return;
+        }
         if (action === 'refresh_all') {
             if (!this.canRunGlobalAuthRefresh()) {
                 await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'auth_refresh_all_blocked_active'));
@@ -5707,7 +6090,7 @@ export class BridgeSessionCore {
         await this.createAndBindNewThread(scopeId, locale, cwd, panelMessageId);
     }
     async createAndBindNewThread(scopeId, locale, cwd, panelMessageId) {
-        this.queuedPrompts.delete(scopeId);
+        this.store.cancelQueuedTurnInputs(scopeId);
         await this.stopWatchingScopeThread(scopeId);
         const binding = await this.createBinding(scopeId, cwd);
         await this.sendNewThreadStartedMessage(scopeId, locale, binding, cwd);
@@ -6453,6 +6836,9 @@ export class BridgeSessionCore {
             if (active.previewActive) {
                 await this.retirePreviewMessage(active.scopeId, active.previewMessageId, t(this.localeForChat(active.scopeId), 'stale_preview_expired'), active.turnId);
             }
+            if (active.queuedInputId) {
+                this.store.updateQueuedTurnInputStatus(active.queuedInputId, 'queued');
+            }
             active.resolver();
             this.deleteActiveTurnRecord(active);
         }
@@ -8066,7 +8452,7 @@ function renderAuthListMessage(locale, state, botLabel = null, includeWeixinCopy
     if (state.candidates.length === 0) {
         lines.push(t(locale, 'auth_no_candidates'));
         if (includeWeixinCopyPaste) {
-            lines.push('', t(locale, 'weixin_copy_paste_divider'), t(locale, 'weixin_copy_auth_title'), '/login_device', '/auth reload', '/permissions');
+            lines.push('', t(locale, 'weixin_copy_paste_divider'), t(locale, 'weixin_copy_auth_title'), '/login_device', '/auth sync safe', '/auth reload', '/permissions');
         }
         return lines.join('\n');
     }
@@ -8099,7 +8485,7 @@ function renderAuthListMessage(locale, state, botLabel = null, includeWeixinCopy
     if (includeWeixinCopyPaste) {
         lines.push('', t(locale, 'weixin_copy_paste_divider'), t(locale, 'weixin_copy_auth_title'), ...page.visible.map(({ index }) => `/auth use ${index + 1}`), ...page.visible.map(({ candidate, index }) => candidate.disabled
             ? `/auth enable ${index + 1}`
-            : `/auth disable ${index + 1}`), '/auth filter all', '/auth filter enabled', '/auth filter attention', '/auth list <keyword>', '/login_device', '/auth reload', '/permissions');
+            : `/auth disable ${index + 1}`), '/auth filter all', '/auth filter enabled', '/auth filter attention', '/auth list <keyword>', '/login_device', '/auth sync safe', '/auth reload', '/permissions');
     }
     return lines.join('\n');
 }
@@ -8137,7 +8523,10 @@ function authChoiceKeyboard(locale, record) {
         { text: t(locale, 'button_permissions'), callback_data: 'nav:permissions' },
         { text: t(locale, 'button_login_device'), callback_data: `auth:${record.localId}:login_device` },
     ]);
-    rows.push([{ text: t(locale, 'button_auth_reload'), callback_data: `auth:${record.localId}:reload` }]);
+    rows.push([
+        { text: t(locale, 'button_auth_safe_sync'), callback_data: `auth:${record.localId}:safe_sync` },
+        { text: t(locale, 'button_auth_reload'), callback_data: `auth:${record.localId}:reload` },
+    ]);
     return rows;
 }
 function formatCodexAuthCandidateDisplayName(name) {
@@ -8743,6 +9132,78 @@ function userInputKeyboard(record) {
     });
     return rows;
 }
+function parseStoredTurnInput(inputJson) {
+    const value = JSON.parse(inputJson);
+    if (!Array.isArray(value)) {
+        throw new Error('Queued turn input is not an array');
+    }
+    return value;
+}
+function parseStagedTelegramAttachments(attachmentsJson) {
+    const value = JSON.parse(attachmentsJson);
+    if (!Array.isArray(value)) {
+        throw new Error('Attachment batch payload is not an array');
+    }
+    return value.map((entry) => {
+        if (!entry || typeof entry !== 'object') {
+            throw new Error('Attachment batch contains an invalid entry');
+        }
+        const attachment = entry;
+        if (typeof attachment.localPath !== 'string' || typeof attachment.relativePath !== 'string') {
+            throw new Error('Attachment batch entry is missing a local path');
+        }
+        return attachment;
+    });
+}
+function findReusableStandaloneAttachmentBatch(batch, now) {
+    if (!batch || batch.mediaGroupId !== null) {
+        return null;
+    }
+    return now - batch.updatedAt <= ATTACHMENT_BATCH_MERGE_WINDOW_MS ? batch : null;
+}
+function mergeAttachmentBatchCaption(existing, next) {
+    const normalizedNext = next.trim();
+    if (!normalizedNext) {
+        return existing;
+    }
+    const normalizedExisting = existing.trim();
+    if (!normalizedExisting) {
+        return normalizedNext;
+    }
+    return normalizedExisting === normalizedNext ? normalizedExisting : `${normalizedExisting}\n\n${normalizedNext}`;
+}
+function summarizeStagedAttachmentInput(text, attachments) {
+    const lines = [text.trim() || '(no text)'];
+    if (attachments.length > 0) {
+        lines.push(`[attachments: ${attachments.map((attachment) => `${attachment.kind}:${attachment.fileName}`).join(', ')}]`);
+    }
+    return lines.join('\n');
+}
+function renderAttachmentBatchMessage(locale, record) {
+    const attachments = parseStagedTelegramAttachments(record.attachmentsJson);
+    const lines = [
+        t(locale, 'attachment_batch_staged', { count: attachments.length }),
+    ];
+    if (record.caption.trim()) {
+        lines.push('', t(locale, 'attachment_batch_caption', { value: truncateInline(record.caption.trim(), 600) }));
+    }
+    lines.push('');
+    for (const [index, attachment] of attachments.entries()) {
+        const name = attachment.fileName || attachment.fileUniqueId;
+        const size = attachment.fileSize === null ? '' : `, ${attachment.fileSize} bytes`;
+        lines.push(`${index + 1}. ${attachment.kind}: ${name}${size}`);
+    }
+    return lines.join('\n');
+}
+function attachmentBatchKeyboard(locale, batchId) {
+    return [[
+            { text: t(locale, 'attachment_batch_button_analyze'), callback_data: `attach:${batchId}:analyze` },
+            { text: t(locale, 'attachment_batch_button_clear'), callback_data: `attach:${batchId}:clear` },
+        ]];
+}
+function shortId(value) {
+    return value.slice(0, 8);
+}
 function renderPlanImplementationPrompt(locale, record) {
     const lines = [
         t(locale, 'plan_impl_title'),