@foxden-app/foxclaw 0.7.1 → 0.7.3

package/dist/controller/controller.js

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
+import { externalWriterControl } from '../codex_app/force_takeover.js';
 import { TELEGRAM_VOICE_MAX_BYTES, TELEGRAM_VOICE_SUPPORTED_EXTENSIONS, telegramVoiceContentType, } from '../voice/files.js';
 import { normalizeLocale, t } from '../i18n.js';
 import { chatGptAuthMetadataMatchesCandidateName, parseChatGptAuthMetadata, readChatGptAuthRecord, readChatGptAuthMetadata, } from '../auth/mirror.js';
@@ -64,6 +65,8 @@ const DYNAMIC_HELP_COMMANDS = [
     { key: 'quota', line: '/quota' },
     { key: 'update', line: '/update' },
     { key: 'login_device', line: '/login_device' },
+    { key: 'login_cancel', line: '/login_cancel' },
+    { key: 'cli', line: '/cli' },
     { key: 'threads_archived', line: '/threads archived [query]' },
     { key: 'open', line: '/open <n>' },
     { key: 'goal', line: '/goal [objective|pause|resume|done|budget <tokens|off>|clear confirm]' },
@@ -122,6 +125,9 @@ export class BridgeSessionCore {
     pendingUserInputs = new Map();
     pendingMcpElicitations = new Map();
     pendingLoginsByScope = new Map();
+    externalWriterControl = externalWriterControl;
+    forceTakeoversInProgress = new Set();
+    pendingForceTakeovers = new Map();
     pendingLoginScopesById = new Map();
     pendingAuthAddsByLoginId = new Map();
     latestTurnDiffs = new Map();
@@ -182,9 +188,7 @@ export class BridgeSessionCore {
             this.updateStatus();
         });
         this.bot.on('text', (event) => {
-            void this.withLock(event.scopeId, async () => this.handleText(event)).catch((error) => {
-                void this.handleAsyncError('telegram.text', error, event.scopeId);
-            });
+            this.dispatchInboundLikeTelegramText(event);
         });
         this.bot.on('callback', (event) => {
             void this.handleCallback(event).catch((error) => {
@@ -197,7 +201,14 @@ export class BridgeSessionCore {
      * (used by the Weixin adapter).
      */
     dispatchInboundLikeTelegramText(event) {
-        void this.withLock(event.scopeId, async () => this.handleText(event)).catch((error) => {
+        const command = event.attachments.length === 0 ? parseCommand(event.text) : null;
+        const name = command?.name;
+        // Recovery commands must remain reachable while a normal command is waiting.
+        // handleText still performs normal addressing and authorization checks.
+        const urgent = name && (['status', 'cli', 'login_cancel', 'interrupt'].includes(name)
+            || (name === 'auth' && command?.args[0] === 'sync' && ['status', 'events', 'trace'].includes(command.args[1] ?? 'status')));
+        const task = urgent ? this.handleText(event) : this.withLock(event.scopeId, async () => this.handleText(event));
+        void task.catch((error) => {
             void this.handleAsyncError('channel.text', error, event.scopeId);
         });
     }
@@ -230,6 +241,15 @@ export class BridgeSessionCore {
             this.attachedThreads.clear();
             this.threadTokenUsageAlerts.clear();
             if (!this.stopping) {
+                if (!this.codexReconnectPending) {
+                    for (const scopeId of new Set([...this.activeTurns.values()].filter(active => !active.isObserved).map(active => active.scopeId))) {
+                        const locale = this.localeForChat(scopeId);
+                        void this.sendMessage(scopeId, locale === 'zh'
+                            ? 'Codex 连接中断，正在重连。任务结果尚未确认，请先用 /status 检查；也可用 /cli 从本机继续。'
+                            : 'Codex disconnected; reconnecting. The task result is unconfirmed. Check /status or use /cli locally.')
+                            .catch(error => this.logger.warn('codex.disconnect_notice_failed', { scopeId, error: toErrorMeta(error) }));
+                    }
+                }
                 this.codexReconnectPending = true;
                 this.pauseAppSnapshotWatchers();
             }
@@ -359,6 +379,9 @@ export class BridgeSessionCore {
                 await this.sendMessage(scopeId, t(locale, 'auth_sync_validation_busy'));
                 return;
             }
+            if (await this.queueObservedThreadMessage(event, locale, event.text.trim())) {
+                return;
+            }
             await this.startBoundTurnFromEvent(event, locale, event.text.trim());
             return;
         }
@@ -417,6 +440,9 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'auth_sync_validation_busy'));
             return;
         }
+        if (await this.queueObservedThreadMessage(event, locale, decision.text)) {
+            return;
+        }
         await this.startBoundTurnFromEvent(event, locale, decision.text);
     }
     async handleCommand(event, locale, name, args) {
@@ -576,6 +602,20 @@ export class BridgeSessionCore {
                 await this.handleLoginCancelCommand(scopeId, locale, args);
                 return;
             }
+            case 'cli': {
+                const binding = this.store.getBinding(scopeId);
+                const server = this.app.getServerStatus();
+                if (!server.running || !server.port) {
+                    await this.sendMessage(scopeId, locale === 'zh' ? 'Codex 服务不可用，请在本机检查 foxclaw status。' : 'Codex server unavailable. Check foxclaw status locally.');
+                    return;
+                }
+                const threadArg = binding ? ` ${JSON.stringify(binding.threadId)}` : '';
+                await this.sendMessage(scopeId, (locale === 'zh'
+                    ? '在运行桥的这台机器上执行，进入同一个 Codex 服务后可中断或继续会话：\n'
+                    : 'Run on the bridge host to interrupt or continue in the same Codex server:\n')
+                    + `codex resume --remote ws://127.0.0.1:${server.port}${threadArg}`);
+                return;
+            }
             case 'logout': {
                 await this.handleLogoutCommand(scopeId, locale, args);
                 return;
@@ -1066,6 +1106,21 @@ export class BridgeSessionCore {
     async handleCallback(event) {
         const scopeId = event.scopeId;
         const locale = this.localeForChat(scopeId, event.languageCode);
+        if (this.forceTakeoversInProgress.has(scopeId)) {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'force_takeover_busy'));
+            return;
+        }
+        const forceTakeoverMatch = /^takeover:(confirm|cancel):([a-f0-9]+)$/.exec(event.data);
+        if (forceTakeoverMatch) {
+            await this.handleForceTakeoverCallback(event, locale, forceTakeoverMatch[1], forceTakeoverMatch[2]);
+            return;
+        }
+        const loginCancelMatch = /^login:cancel:(.+)$/.exec(event.data);
+        if (loginCancelMatch) {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'button_cancel'));
+            await this.handleLoginCancelCommand(scopeId, locale, [loginCancelMatch[1]]);
+            return;
+        }
         const interruptMatch = /^turn:interrupt:(.+)$/.exec(event.data);
         if (interruptMatch) {
             await this.handleTurnInterruptCallback(event, interruptMatch[1], locale);
@@ -3648,7 +3703,9 @@ export class BridgeSessionCore {
         if (!scopeId)
             return;
         try {
-            await this.sendMessage(scopeId, t(this.localeForChat(scopeId), 'bridge_error', { error: formatUserError(error) }));
+            const locale = this.localeForChat(scopeId);
+            const hint = isThreadActiveWriterError(error) ? `\n${t(locale, 'force_takeover_hint')}` : '';
+            await this.sendMessage(scopeId, t(locale, 'bridge_error', { error: formatUserError(error) }) + hint);
         }
         catch (notifyError) {
             this.logger.error('telegram.error_notification_failed', { error: toErrorMeta(notifyError), scopeId });
@@ -3881,7 +3938,7 @@ export class BridgeSessionCore {
             }
         }
         for (const active of [...this.activeTurns.values()]) {
-            if (recoveredScopes.has(active.scopeId) || !this.getActiveTurn(active.scopeId, active.turnId)) {
+            if (active.isObserved || recoveredScopes.has(active.scopeId) || !this.getActiveTurn(active.scopeId, active.turnId)) {
                 continue;
             }
             try {
@@ -3894,6 +3951,10 @@ export class BridgeSessionCore {
                     turnId: active.turnId,
                     error: toErrorMeta(error),
                 });
+                await this.sendMessage(active.scopeId, this.localeForChat(active.scopeId) === 'zh'
+                    ? '连接已恢复，但无法确认原任务状态。任务未自动重发，请用 /cli 检查原会话后再继续。'
+                    : 'Connected again, but the original task state could not be confirmed. It was not resent. Use /cli to inspect the session.')
+                    .catch(notifyError => this.logger.warn('codex.recovery_notice_failed', { error: toErrorMeta(notifyError) }));
             }
         }
         await this.recoverQueuedTurns();
@@ -4240,6 +4301,10 @@ export class BridgeSessionCore {
         }
     }
     async handleTakeoverCommand(event, locale, args) {
+        if (args[0] === '--force') {
+            await this.prepareForceTakeover(event, locale, args.slice(1).join(' ').trim());
+            return;
+        }
         const scopeId = event.scopeId;
         const nextPrompt = args.join(' ').trim();
         if (!nextPrompt) {
@@ -4257,10 +4322,113 @@ export class BridgeSessionCore {
                 await this.requestInterrupt(active);
             }
             await this.sendMessage(scopeId, t(locale, 'interrupt_requested_waiting'));
-            await active.completion;
+            let timer;
+            try {
+                await Promise.race([
+                    active.completion,
+                    new Promise((_, reject) => {
+                        timer = setTimeout(() => reject(new Error(locale === 'zh'
+                            ? '等待中断完成超时，尚未发送新任务。请用 /status 检查，或用 /cli 从终端恢复。'
+                            : 'Interrupt confirmation timed out. No replacement task was sent. Check /status or use /cli to recover.')), 30_000);
+                    }),
+                ]);
+            }
+            finally {
+                clearTimeout(timer);
+            }
         }
         await this.startBoundTurnFromEvent(event, locale, nextPrompt);
     }
+    async prepareForceTakeover(event, locale, prompt) {
+        const scopeId = event.scopeId;
+        this.pendingForceTakeovers.delete(scopeId);
+        if (!prompt) {
+            await this.sendMessage(scopeId, t(locale, 'usage_takeover'));
+            return;
+        }
+        if (!scopeId.startsWith('telegram:') || event.userId !== this.config.tgAllowedUserId) {
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_trusted_telegram_only'));
+            return;
+        }
+        const binding = this.store.getBinding(scopeId);
+        if (!binding) {
+            await this.sendMessage(scopeId, t(locale, 'watch_no_thread_bound'));
+            return;
+        }
+        const home = this.config.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex');
+        try {
+            const writer = await this.externalWriterControl.inspect(home, binding.threadId);
+            const id = crypto.randomBytes(8).toString('hex');
+            this.pendingForceTakeovers.set(scopeId, {
+                id, expiresAt: Date.now() + 60_000, event, threadId: binding.threadId, home, prompt, writer,
+            });
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_confirm', {
+                threadId: binding.threadId, pid: String(writer.pid), cwd: writer.cwd, prompt,
+            }), [[
+                    { text: t(locale, 'button_force_takeover'), callback_data: `takeover:confirm:${id}` },
+                    { text: t(locale, 'button_cancel'), callback_data: `takeover:cancel:${id}` },
+                ]]);
+        }
+        catch (error) {
+            this.pendingForceTakeovers.delete(scopeId);
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_failed', { error: formatUserError(error) }));
+        }
+    }
+    async handleForceTakeoverCallback(event, locale, action, id) {
+        const scopeId = event.scopeId;
+        const pending = this.pendingForceTakeovers.get(scopeId);
+        if (!pending || pending.id !== id || pending.event.userId !== event.userId
+            || event.userId !== this.config.tgAllowedUserId || pending.expiresAt <= Date.now()) {
+            await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'force_takeover_expired'));
+            return;
+        }
+        // Claim before any await: duplicate callbacks cannot stop or submit twice.
+        this.pendingForceTakeovers.delete(scopeId);
+        await this.messaging.answerCallback(event.callbackQueryId, t(locale, action === 'cancel' ? 'button_cancel' : 'button_force_takeover'));
+        if (action === 'cancel') {
+            await this.sendMessage(scopeId, t(locale, 'force_takeover_cancelled'));
+            return;
+        }
+        await this.withLock(scopeId, async () => {
+            if (pending.expiresAt <= Date.now() || this.store.getBinding(scopeId)?.threadId !== pending.threadId) {
+                await this.sendMessage(scopeId, t(locale, 'force_takeover_expired'));
+                return;
+            }
+            if (this.externalAuthValidationInProgress) {
+                await this.sendMessage(scopeId, t(locale, 'auth_sync_validation_busy'));
+                return;
+            }
+            this.forceTakeoversInProgress.add(scopeId);
+            this.turnStartInProgress += 1;
+            try {
+                try {
+                    await this.sendMessage(scopeId, t(locale, 'force_takeover_stopping', { pid: String(pending.writer.pid) }));
+                    await this.externalWriterControl.stop(pending.home, pending.threadId, pending.writer);
+                    this.logger.warn('codex.external_writer_stopped', { scopeId, threadId: pending.threadId, pid: pending.writer.pid });
+                    await this.stopWatchingScopeThread(scopeId);
+                    this.attachedThreads.delete(attachedThreadKey(scopeId, pending.threadId));
+                    // Never replace a missing thread with an unrelated new conversation.
+                    const binding = this.store.getBinding(scopeId);
+                    if (binding?.threadId !== pending.threadId)
+                        throw new Error(t(locale, 'force_takeover_expired'));
+                    await this.ensureThreadReady(scopeId, binding, { recoverMissingThread: false });
+                }
+                catch (error) {
+                    await this.sendMessage(scopeId, t(locale, 'force_takeover_failed', { error: formatUserError(error) }));
+                    return;
+                }
+                this.store.cancelQueuedTurnInputs(scopeId);
+                await this.sendMessage(scopeId, t(locale, 'force_takeover_acquired', { threadId: pending.threadId }));
+                // Normal turn-start error handling preserves ambiguous submission failures;
+                // do not automatically retry a possibly accepted prompt.
+                await this.startBoundTurnFromEvent(pending.event, locale, pending.prompt);
+            }
+            finally {
+                this.forceTakeoversInProgress.delete(scopeId);
+                this.turnStartInProgress -= 1;
+            }
+        });
+    }
     async handleQueueCommand(event, locale, args) {
         const scopeId = event.scopeId;
         const nextPrompt = args.join(' ').trim();
@@ -4269,12 +4437,15 @@ export class BridgeSessionCore {
             return;
         }
         const active = this.findActiveTurn(scopeId);
-        if (!active) {
-            await this.startBoundTurnFromEvent(event, locale, nextPrompt);
+        const observedThreadId = active?.isObserved
+            ? active.threadId
+            : this.observedThreadWatchers.get(scopeId)?.threadId ?? null;
+        if (observedThreadId) {
+            await this.queueObservedThreadMessage(event, locale, nextPrompt, observedThreadId);
             return;
         }
-        if (active.isObserved) {
-            await this.sendMessage(scopeId, t(locale, 'watch_read_only_active'));
+        if (!active) {
+            await this.startBoundTurnFromEvent(event, locale, nextPrompt);
             return;
         }
         await this.queuePromptAfterActiveTurn(event, locale, nextPrompt);
@@ -4285,7 +4456,7 @@ export class BridgeSessionCore {
             return;
         }
         if (active.isObserved) {
-            await this.sendMessage(event.scopeId, t(locale, 'watch_read_only_active'));
+            await this.queueObservedThreadMessage(event, locale, text, active.threadId);
             return;
         }
         const settings = this.store.getChatSettings(event.scopeId);
@@ -4311,6 +4482,34 @@ export class BridgeSessionCore {
             await this.startBoundTurnFromEvent(event, locale, text);
         }
     }
+    async queueObservedThreadMessage(event, locale, text, threadId = this.observedThreadWatchers.get(event.scopeId)?.threadId ?? null) {
+        if (!threadId) {
+            return false;
+        }
+        const input = await this.buildTurnInput({
+            threadId,
+            cwd: this.store.getBinding(event.scopeId)?.cwd ?? this.config.defaultCwd,
+        }, { ...event, text }, locale);
+        const clientUserMessageId = `foxclaw:${event.scopeId}:${event.messageId}`;
+        try {
+            const queued = await this.app.queueThreadInput(threadId, clientUserMessageId, input);
+            await this.sendMessage(event.scopeId, t(locale, 'watch_prompt_queued', {
+                id: shortId(queued.queuedSubmissionId),
+            }));
+        }
+        catch (error) {
+            if (!isThreadQueueUnsupportedError(error)) {
+                throw error;
+            }
+            this.logger.warn('codex.observed_thread_queue_unsupported', {
+                scopeId: event.scopeId,
+                threadId,
+                error: toErrorMeta(error),
+            });
+            await this.sendMessage(event.scopeId, t(locale, 'watch_queue_unsupported'));
+        }
+        return true;
+    }
     async queuePromptAfterActiveTurn(event, locale, text) {
         const active = this.findActiveTurn(event.scopeId);
         if (!active) {
@@ -5339,7 +5538,7 @@ export class BridgeSessionCore {
                 t(locale, 'login_code', { value: login.userCode }),
                 t(locale, 'login_id', { value: login.loginId }),
                 t(locale, 'login_cancel_hint', { value: login.loginId }),
-            ].join('\n'));
+            ].join('\n'), this.loginCancelKeyboard(login.loginId, locale));
         }
         catch (error) {
             await this.restoreAuthAfterAddFailure(state.authDir, state.authPath, state.currentTargetPath);
@@ -5382,7 +5581,7 @@ export class BridgeSessionCore {
                 t(locale, 'login_code', { value: login.userCode }),
                 t(locale, 'login_id', { value: login.loginId }),
                 t(locale, 'login_cancel_hint', { value: login.loginId }),
-            ].join('\n'));
+            ].join('\n'), this.loginCancelKeyboard(login.loginId, locale));
         }
         catch (error) {
             await this.restoreAuthAfterAddFailure(state.authDir, state.authPath, state.currentTargetPath);
@@ -5547,6 +5746,11 @@ export class BridgeSessionCore {
         }
     }
     async handleLoginDeviceCommand(scopeId, locale) {
+        const pendingLoginId = this.pendingLoginsByScope.get(scopeId);
+        if (pendingLoginId) {
+            await this.sendMessage(scopeId, t(locale, 'login_cancel_hint', { value: pendingLoginId }), this.loginCancelKeyboard(pendingLoginId, locale));
+            return;
+        }
         const login = await this.app.startDeviceLogin();
         const oldLoginId = this.pendingLoginsByScope.get(scopeId);
         if (oldLoginId) {
@@ -5561,24 +5765,41 @@ export class BridgeSessionCore {
             t(locale, 'login_code', { value: login.userCode }),
             t(locale, 'login_id', { value: login.loginId }),
             t(locale, 'login_cancel_hint', { value: login.loginId }),
-        ].join('\n'));
+        ].join('\n'), this.loginCancelKeyboard(login.loginId, locale));
+    }
+    loginCancelKeyboard(loginId, locale) {
+        return [[{ text: t(locale, 'button_cancel'), callback_data: `login:cancel:${loginId}` }]];
     }
     async handleLoginCancelCommand(scopeId, locale, args) {
         const loginId = args[0]?.trim() || this.pendingLoginsByScope.get(scopeId) || null;
-        if (!loginId) {
+        if (!loginId || this.pendingLoginsByScope.get(scopeId) !== loginId) {
             await this.sendMessage(scopeId, t(locale, 'login_cancel_no_pending'));
             return;
         }
         const pendingAuthAdd = this.pendingAuthAddsByLoginId.get(loginId) ?? null;
-        await this.app.cancelLogin(loginId);
+        // Claim cancellation before awaiting RPC: completion notifications may arrive first.
         this.pendingLoginsByScope.delete(scopeId);
         this.pendingLoginScopesById.delete(loginId);
         this.pendingAuthAddsByLoginId.delete(loginId);
+        let cancelError;
+        try {
+            await this.app.cancelLogin(loginId);
+        }
+        catch (error) {
+            cancelError = error;
+            this.logger.warn('codex.login_cancel_failed', { error: toErrorMeta(error) });
+        }
         if (pendingAuthAdd) {
             await this.restorePendingAuthAdd(pendingAuthAdd);
             await this.sendMessage(scopeId, t(locale, 'auth_add_cancelled'));
             return;
         }
+        if (cancelError) {
+            await this.sendMessage(scopeId, locale === 'zh'
+                ? '已退出本地登录流程，但未能确认服务端取消。请勿继续使用旧验证码；可重新登录或用 /codex_restart 重置登录服务。'
+                : 'Local login flow cleared, but server cancellation is unconfirmed. Do not use the old code; start a new login or use /codex_restart.');
+            return;
+        }
         await this.sendMessage(scopeId, t(locale, 'login_cancelled'));
     }
     async handleLogoutCommand(scopeId, locale, args) {
@@ -5601,6 +5822,10 @@ export class BridgeSessionCore {
             await this.sendMessage(scopeId, t(locale, 'no_active_turn'));
             return;
         }
+        if (active.isObserved) {
+            await this.sendMessage(scopeId, t(locale, 'watch_read_only_active'));
+            return;
+        }
         await this.app.steerTurn(active.threadId, active.turnId, [{
                 type: 'text',
                 text,
@@ -6121,6 +6346,20 @@ export class BridgeSessionCore {
             await this.editAuthPanelMessage(event.scopeId, record.messageId, renderAuthListMessage(locale, state, this.authDisplayBotLabel(), parseWeixinBridgeScope(event.scopeId) !== null, record), authChoiceKeyboard(locale, record));
         }
     }
+    async refreshRepairedAuthChoice(event, record, candidateName, locale) {
+        const state = await this.listCodexAuthState();
+        if (state.candidates.find(candidate => candidate.name === candidateName)?.state === 'needs_repair')
+            return false;
+        record.candidates = state.candidates;
+        record.createdAt = Date.now();
+        clampCodexAuthListOffset(record);
+        await this.messaging.answerCallback(event.callbackQueryId, locale === 'zh'
+            ? '授权状态已变化，已刷新面板。' : 'Auth state changed; panel refreshed.');
+        if (record.messageId !== null) {
+            await this.editAuthPanelMessage(event.scopeId, record.messageId, renderAuthListMessage(locale, state, this.authDisplayBotLabel(), parseWeixinBridgeScope(event.scopeId) !== null, record), authChoiceKeyboard(locale, record));
+        }
+        return true;
+    }
     async handleAuthRepairMenuCallback(event, localId, index, locale) {
         const record = this.pendingAuthChoiceLists.get(localId);
         if (!record) {
@@ -6136,6 +6375,8 @@ export class BridgeSessionCore {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'unsupported_action'));
             return;
         }
+        if (await this.refreshRepairedAuthChoice(event, record, candidate.name, locale))
+            return;
         await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'auth_repair_actions_short'));
         if (record.messageId !== null) {
             await this.editAuthPanelMessage(event.scopeId, record.messageId, t(locale, 'auth_repair_actions_message', { value: formatCodexAuthCandidateDisplayName(candidate.name) }), authRepairKeyboard(locale, record, index));
@@ -6156,6 +6397,8 @@ export class BridgeSessionCore {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'unsupported_action'));
             return;
         }
+        if (action !== 'cancel' && await this.refreshRepairedAuthChoice(event, record, candidate.name, locale))
+            return;
         if (action === 'cancel') {
             await this.messaging.answerCallback(event.callbackQueryId, t(locale, 'decision_recorded'));
             const state = await this.listCodexAuthState();
@@ -11811,6 +12054,12 @@ function isThreadActiveWriterError(error) {
 function isNoActiveTurnToSteerError(error) {
     return error instanceof Error && /no active turn to steer/i.test(error.message);
 }
+function isThreadQueueUnsupportedError(error) {
+    const message = formatUserError(error).toLowerCase();
+    return message.includes('method not found')
+        || message.includes('unknown method')
+        || message.includes('thread/queue/add') && message.includes('not supported');
+}
 function isThreadNewCwdCreateConfirmation(text) {
     return /^(y|yes|ok|okay|confirm|create|mkdir|确定|确认|创建|新建|好)$/i.test(text.trim());
 }

package/dist/i18n.d.ts

@@ -52,6 +52,8 @@ declare const MESSAGES: {
         readonly cmd_desc_account: "Codex account";
         readonly cmd_desc_quota: "Codex quota";
         readonly cmd_desc_login_device: "ChatGPT device login";
+        readonly cmd_desc_login_cancel: "Cancel the pending login";
+        readonly cmd_desc_cli: "Continue this session in the local CLI";
         readonly cmd_desc_threads: "Recent threads";
         readonly cmd_desc_open: "Open a cached thread";
         readonly cmd_desc_goal: "Thread goal";
@@ -246,13 +248,13 @@ declare const MESSAGES: {
         readonly auth_sync_test_sent: "Auth sync test complete: sent {sent}, replies {replied}.";
         readonly auth_sync_test_missing: "Missing replies: {value}";
         readonly auth_sync_push_blocked_active: "Cannot push auth sync while any runtime, approval, input, login, or auth mirror write is active.";
-        readonly auth_sync_safe_starting: "Auditing every node, selecting the newest valid auth, and safely synchronizing the cluster...";
+        readonly auth_sync_safe_starting: "Auditing every node and distributing valid auth. An unreachable peer can add up to 5 minutes per audit phase. Use /auth sync status to check progress.";
         readonly auth_sync_safe_done: "Safe auth sync complete: local synced {localSynced}, local skipped {localSkipped}; cross-node sent {sent}, skipped {skipped}.";
         readonly auth_cluster_audit_starting: "Asking all auth-sync peers to validate accounts, reconcile the newest usable credentials, and refresh credentials at least 8 days old...";
         readonly auth_cluster_audit_blocked_active: "Cluster auth check requires every local runtime, approval, input, login, and auth mirror write to be idle.";
         readonly auth_cluster_audit_failed: "Cluster auth check failed: {error}";
         readonly auth_cluster_audit_summary: "Cluster auth check: nodes {responded}/{expected}; accounts checked {checked}, usable {valid}, unusable {invalid}.";
-        readonly auth_cluster_audit_synced: "Newest usable auth distributed: {value}";
+        readonly auth_cluster_audit_synced: "Valid auth selected and sent (remote import not confirmed): {value}";
         readonly auth_cluster_audit_repair: "Marked for manual repair after multi-node consensus: {value}";
         readonly auth_cluster_audit_missing: "No response: {value}";
         readonly auth_cluster_audit_busy: "Busy nodes: {value}";
@@ -301,7 +303,17 @@ declare const MESSAGES: {
         readonly working: "Working...";
         readonly usage_open: "Usage: /open <n>";
         readonly usage_watch: "Usage: /watch [n]";
-        readonly usage_takeover: "Usage: /takeover <message>";
+        readonly usage_takeover: "Usage: /takeover <message> or /takeover --force <message> (confirm stopping a local CLI)";
+        readonly force_takeover_trusted_telegram_only: "Force takeover is only available to the configured trusted Telegram user.";
+        readonly force_takeover_confirm: "Force takeover of thread {threadId}?\nLocal Codex CLI PID: {pid}\nWorking directory: {cwd}\nNext prompt: {prompt}\nThis will terminate that CLI (SIGTERM, then SIGKILL after 5 seconds if needed). Unfinished work may be interrupted; child commands may continue running. No edits are rolled back. Confirmation expires in 60 seconds.";
+        readonly button_force_takeover: "Confirm force takeover";
+        readonly force_takeover_busy: "Force takeover is in progress. Please wait before switching threads.";
+        readonly force_takeover_hint: "Use /watch then /queue <message> to queue for that CLI. To stop a local CLI and hand the thread to this bridge, use /takeover --force <message> and confirm.";
+        readonly force_takeover_expired: "Confirmation expired or thread changed. Send /takeover --force <message> again.";
+        readonly force_takeover_cancelled: "Force takeover cancelled. Nothing was stopped or submitted.";
+        readonly force_takeover_stopping: "Stopping the confirmed CLI PID {pid} and checking its writer lock...";
+        readonly force_takeover_failed: "Force takeover not completed; no new prompt was sent. If stopping already began, the CLI may have exited. Check /status before retrying. Reason: {error}";
+        readonly force_takeover_acquired: "Bridge acquired thread {threadId}. Preparing the requested prompt; this is not task completion.";
         readonly usage_queue: "Usage: /queue <message>";
         readonly unknown_cached_thread: "Unknown cached thread. Run /threads first.";
         readonly cached_thread_unavailable: "That cached thread is no longer available. Run /threads again.";
@@ -309,7 +321,9 @@ declare const MESSAGES: {
         readonly watch_already_enabled: "Already watching thread {threadId}.";
         readonly watch_started_active: "Watching thread {threadId}. Live Codex updates from the current turn will appear here.";
         readonly watch_started_idle: "Watching thread {threadId}. I will mirror the next live turn from Codex CLI here.";
-        readonly watch_read_only_active: "This chat is watching that turn read-only. Use approval commands if needed, or /unwatch before sending a new prompt.";
+        readonly watch_read_only_active: "This chat is watching that turn read-only, so this operation cannot take ownership. Send plain text or use /queue to queue the next prompt, or /unwatch to start separately.";
+        readonly watch_prompt_queued: "Queued for the watched Codex CLI session ({id}). The CLI will continue with it after the current turn.";
+        readonly watch_queue_unsupported: "This Codex version does not support cross-client session queues. Update Codex to 0.151.0 or later.";
         readonly watch_not_enabled: "This chat is not watching any thread.";
         readonly watch_stopped: "Stopped watching thread {threadId}.";
         readonly queued_prompt_set: "Queued #{position} ({id}). I will send it after the current turn finishes.";
@@ -778,6 +792,8 @@ declare const MESSAGES: {
         readonly cmd_desc_account: "Codex 账号";
         readonly cmd_desc_quota: "Codex 用量";
         readonly cmd_desc_login_device: "ChatGPT 设备登录";
+        readonly cmd_desc_login_cancel: "取消当前登录流程";
+        readonly cmd_desc_cli: "从本机 CLI 继续当前会话";
         readonly cmd_desc_threads: "最近线程";
         readonly cmd_desc_open: "打开缓存线程";
         readonly cmd_desc_goal: "线程目标";
@@ -972,13 +988,13 @@ declare const MESSAGES: {
         readonly auth_sync_test_sent: "auth sync 测试完成：已发送 {sent}，收到回应 {replied}。";
         readonly auth_sync_test_missing: "未回应：{value}";
         readonly auth_sync_push_blocked_active: "当前有任一 runtime、审批、待输入、登录或 auth 镜像写入在进行中，不能推送 auth 同步。";
-        readonly auth_sync_safe_starting: "正在自检全部节点、选择最新有效 auth，并安全同步整个集群...";
+        readonly auth_sync_safe_starting: "正在自检各节点并分发有效授权。节点未回应时，每轮自检最多等待 5 分钟；可用 /auth sync status 查看进展。";
         readonly auth_sync_safe_done: "安全 auth 同步完成：本机同步 {localSynced}，本机跳过 {localSkipped}；跨节点发送 {sent}，跳过 {skipped}。";
         readonly auth_cluster_audit_starting: "正在通知所有 auth sync 节点逐账号自检，协商最新有效凭据，并由本节点刷新已满 8 天的 auth...";
         readonly auth_cluster_audit_blocked_active: "集群 auth 自检要求本机所有 runtime、审批、待输入、登录和 auth 镜像写入均为空闲。";
         readonly auth_cluster_audit_failed: "集群 auth 自检失败：{error}";
         readonly auth_cluster_audit_summary: "集群 auth 自检：节点 {responded}/{expected}；检查账号 {checked}，有效 {valid}，无有效副本 {invalid}。";
-        readonly auth_cluster_audit_synced: "已采用并分发最新有效 auth：{value}";
+        readonly auth_cluster_audit_synced: "已选出并发送有效授权（远端导入尚未确认）：{value}";
         readonly auth_cluster_audit_repair: "多节点确认无效，已标记问号等待人工处理：{value}";
         readonly auth_cluster_audit_missing: "未回应节点：{value}";
         readonly auth_cluster_audit_busy: "忙碌节点：{value}";
@@ -1027,7 +1043,17 @@ declare const MESSAGES: {
         readonly working: "处理中...";
         readonly usage_open: "用法：/open <编号>";
         readonly usage_watch: "用法：/watch [编号]";
-        readonly usage_takeover: "用法：/takeover <消息>";
+        readonly usage_takeover: "用法：/takeover <消息>；或 /takeover --force <消息>（确认后停止本机 CLI）";
+        readonly force_takeover_trusted_telegram_only: "强制接管仅对配置中的可信 Telegram 用户开放。";
+        readonly force_takeover_confirm: "强制接管 thread {threadId}？\n本机 Codex CLI PID：{pid}\n工作目录：{cwd}\n接管后消息：{prompt}\n将终止这个 CLI（先 SIGTERM，5 秒后仍未退出则 SIGKILL）。未完成任务可能被中断，已启动的子命令可能继续运行；不会回滚文件修改。确认 60 秒内有效。";
+        readonly button_force_takeover: "确认强制接管";
+        readonly force_takeover_busy: "正在强制接管，请等待结果后再切换会话。";
+        readonly force_takeover_hint: "可先 /watch 再 /queue <消息> 排队给原 CLI；如需停止本机 CLI、让桥接管，请发送 /takeover --force <消息> 并确认。";
+        readonly force_takeover_expired: "确认已过期或 thread 已切换，请重新发送 /takeover --force <消息>。";
+        readonly force_takeover_cancelled: "已取消强制接管，没有停止进程或发送新任务。";
+        readonly force_takeover_stopping: "正在停止已确认的 CLI PID {pid}，并检查写入锁是否释放…";
+        readonly force_takeover_failed: "强制接管未完成，没有发送新任务。如果已开始停止，CLI 可能已经退出。请先 /status 检查再重试。原因：{error}";
+        readonly force_takeover_acquired: "桥已取得 thread {threadId} 的写入权，准备发送指定消息；这不代表任务已完成。";
         readonly usage_queue: "用法：/queue <消息>";
         readonly unknown_cached_thread: "找不到这个缓存线程，请先运行 /threads。";
         readonly cached_thread_unavailable: "这个缓存线程已经不可用，请重新运行 /threads。";
@@ -1035,7 +1061,9 @@ declare const MESSAGES: {
         readonly watch_already_enabled: "已经在观察线程 {threadId}。";
         readonly watch_started_active: "已开始观察线程 {threadId}。当前这轮 Codex 更新会同步到这里。";
         readonly watch_started_idle: "已开始观察线程 {threadId}。之后 CLI 里这条线程一旦有新 live turn，我会同步到这里。";
-        readonly watch_read_only_active: "当前聊天正在只读观察这轮。需要审批时可用审批命令；要发送新 prompt 请先 /unwatch。";
+        readonly watch_read_only_active: "当前聊天正在只读观察这轮，不能接管这项操作。直接发送文字或使用 /queue 可排入下一轮；要另行启动请先 /unwatch。";
+        readonly watch_prompt_queued: "已排入正在观察的 Codex CLI 会话（{id}）。当前轮结束后，CLI 会自动接着执行。";
+        readonly watch_queue_unsupported: "当前 Codex 不支持跨客户端会话队列，请升级到 Codex 0.151.0 或更高版本。";
         readonly watch_not_enabled: "当前没有正在观察的线程。";
         readonly watch_stopped: "已停止观察线程 {threadId}。";
         readonly queued_prompt_set: "已排队 #{position}（{id}）。当前回复结束后我会自动发送。";