@foxden-app/foxclaw 0.5.23 → 0.5.25

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 All notable FoxClaw changes are listed here. Each release note is bilingual so GitHub Releases and the npm package are useful to both Chinese and English readers.
 
+## 0.5.25 - 2026-06-09
+
+### 中文
+- FoxClaw 重启后会优先重新接管 Codex app-server 中仍在运行的 live turn，包括 turn id 已变化但线程仍有 live turn 的情况，避免误开第二个续跑任务。
+- 如果重启前记录的活动 turn 已被 app-server 中断且没有完成结果，FoxClaw 会自动在同一线程启动一个“继续中断工作”的新 turn，并复用原 Telegram 状态卡继续更新，不再要求用户手动发送“继续”。
+- 如果旧 turn 已经完成，FoxClaw 只收尾旧状态卡，不会误触发自动续跑。
+
+### English
+- After a FoxClaw restart, live Codex app-server turns are reattached first, including cases where the live turn id changed but the thread still has an active turn, avoiding a duplicate resume turn.
+- If the previously tracked active turn was interrupted by the app-server restart and has no completed result, FoxClaw automatically starts a continuation turn in the same thread and reuses the existing Telegram status card.
+- If the old turn already completed, FoxClaw only retires the old status card and does not auto-resume it.
+
+## 0.5.24 - 2026-06-09
+
+### 中文
+- 后台主动 auth 刷新不再向私聊推送开始、跳过、完成或失败消息；最近一次刷新状态会写入 runtime status，并可在 `/status` 和 `/auth sync status` 主动查看。
+- 本机 auth mirror 和跨节点 auth sync 的刷新/导入/同步摘要也默认静默，不再推送 `auth 刷新/同步汇总` 或候选已同步提示，减少后台维护对注意力的打扰。
+
+### English
+- Background proactive auth refresh no longer pushes private start, skipped, completed, or failed messages. The latest refresh state is stored in runtime status and can be checked with `/status` and `/auth sync status`.
+- Same-node auth mirroring and cross-node auth sync refresh/import/sync summaries are quiet by default, so background maintenance no longer pushes auth refresh/sync summaries or per-candidate synced notices.
+
 ## 0.5.23 - 2026-06-09
 
 ### 中文

package/dist/controller/controller.d.ts

@@ -6,6 +6,7 @@ import type { TelegramGateway, TelegramTextEvent } from '../telegram/gateway.js'
 import { BridgeMessagingRouter } from '../channels/bridge_messaging_router.js';
 import type { CodexAppClient } from '../codex_app/client.js';
 import type { SelfUpdateRuntime, SelfUpdateStatus } from '../update.js';
+type AuthProactiveRefreshStatus = NonNullable<RuntimeStatus['authProactiveRefresh']>;
 export interface CoreCoordinator {
     canSelfUpdate?: () => boolean;
     authCandidateUpdated?: (runtimeId: string, candidateName: string) => Promise<void>;
@@ -41,6 +42,7 @@ export interface CoreCoordinator {
         weixinRuntime?: RuntimeStatus['weixinRuntime'];
         authMirror?: RuntimeStatus['authMirror'];
         authSync?: RuntimeStatus['authSync'];
+        authProactiveRefresh?: AuthProactiveRefreshStatus | null;
         lastUpdate?: SelfUpdateStatus | null;
     }>;
     selfUpdateCompleted?: (status: SelfUpdateStatus) => void;
@@ -89,7 +91,7 @@ export declare class BridgeSessionCore {
     private selfUpdatePollTimer;
     private proactiveAuthRefreshTimer;
     private proactiveAuthRefreshInProgress;
-    private proactiveAuthRefreshStatusMessage;
+    private proactiveAuthRefreshStatus;
     private attachedThreads;
     private botUsername;
     private lastError;
@@ -290,8 +292,7 @@ export declare class BridgeSessionCore {
     private scheduleProactiveAuthRefresh;
     private clearProactiveAuthRefreshTimer;
     private runProactiveAuthRefresh;
-    private proactiveAuthRefreshLocale;
-    private notifyProactiveAuthRefresh;
+    private recordProactiveAuthRefreshStatus;
     private handleAuthCommand;
     private handleAuthSyncCommand;
     private runAuthSafeSyncAll;
@@ -418,6 +419,8 @@ export declare class BridgeSessionCore {
     private syncTurnStream;
     private cleanupStaleTurnPreviews;
     private recoverLiveTurnPreview;
+    private attachRecoveredTurnPreview;
+    private resumeInterruptedTurnAfterRestart;
     private interruptOrphanWaitingUserInput;
     private cleanupFinishedPreview;
     private cleanupStaleInterruptButton;

package/dist/controller/controller.js

@@ -139,7 +139,7 @@ export class BridgeSessionCore {
     selfUpdatePollTimer = null;
     proactiveAuthRefreshTimer = null;
     proactiveAuthRefreshInProgress = false;
-    proactiveAuthRefreshStatusMessage = null;
+    proactiveAuthRefreshStatus = null;
     attachedThreads = new Set();
     botUsername = null;
     lastError = null;
@@ -284,6 +284,7 @@ export class BridgeSessionCore {
                 telegram: this.ownsTelegramRuntime,
                 weixin: Boolean(this.config.wxEnabled && this.messaging.hasWeixinTransport),
             },
+            authProactiveRefresh: this.proactiveAuthRefreshStatus,
         };
     }
     async handleText(event) {
@@ -478,6 +479,11 @@ export class BridgeSessionCore {
                             }));
                         }
                     }
+                    if (serviceStatus.authProactiveRefresh) {
+                        lines.push(t(locale, 'status_auth_proactive_refresh', {
+                            value: formatAuthProactiveRefreshStatus(locale, serviceStatus.authProactiveRefresh),
+                        }));
+                    }
                     if (serviceStatus.lastUpdate) {
                         lines.push(t(locale, 'status_last_update', {
                             from: serviceStatus.lastUpdate.fromVersion,
@@ -4423,65 +4429,72 @@ export class BridgeSessionCore {
             return;
         }
         this.proactiveAuthRefreshInProgress = true;
-        const locale = this.proactiveAuthRefreshLocale();
-        await this.notifyProactiveAuthRefresh(locale, t(locale, 'auth_proactive_refresh_starting', {
-            value: dueCandidates.map(candidate => candidate.name).join(', '),
-        }));
+        const startedAt = new Date().toISOString();
+        const dueCandidateNames = dueCandidates.map(candidate => candidate.name);
+        this.recordProactiveAuthRefreshStatus({
+            state: 'running',
+            startedAt,
+            finishedAt: null,
+            candidates: dueCandidateNames,
+            refreshed: 0,
+            skipped: 0,
+            failed: 0,
+            error: null,
+            details: [],
+        });
         let lease;
         try {
-            lease = await this.coordinator?.acquireAuthRefreshLease?.(`proactive auth refresh: ${dueCandidates.map(candidate => candidate.name).join(', ')}`);
+            lease = await this.coordinator?.acquireAuthRefreshLease?.(`proactive auth refresh: ${dueCandidateNames.join(', ')}`);
             if (lease && !lease.ok) {
                 this.logger.warn('codex.auth_proactive_refresh_lease_failed', { reason: lease.reason });
-                await this.notifyProactiveAuthRefresh(locale, t(locale, 'auth_proactive_refresh_lease_failed', {
-                    error: lease.reason ?? t(locale, 'unknown'),
-                }), true);
+                this.recordProactiveAuthRefreshStatus({
+                    state: 'lease_failed',
+                    startedAt,
+                    finishedAt: new Date().toISOString(),
+                    candidates: dueCandidateNames,
+                    refreshed: 0,
+                    skipped: 0,
+                    failed: 0,
+                    error: lease.reason ?? 'unknown',
+                    details: [],
+                });
                 return;
             }
-            const result = await this.refreshCodexAuthCandidates(new Set(dueCandidates.map(candidate => candidate.name)));
-            await this.notifyProactiveAuthRefresh(locale, formatAuthRefreshAllResult(locale, result, 'proactive'), true);
+            const result = await this.refreshCodexAuthCandidates(new Set(dueCandidateNames));
+            this.recordProactiveAuthRefreshStatus({
+                state: 'completed',
+                startedAt,
+                finishedAt: new Date().toISOString(),
+                candidates: dueCandidateNames,
+                refreshed: result.refreshed.length,
+                skipped: result.skipped.length,
+                failed: result.failed.length,
+                error: result.failed.length > 0 ? `${result.failed.length} failed` : null,
+                details: result.failed.slice(0, 5).map(failure => `${failure.name}: ${failure.error}`),
+            });
+        }
+        catch (error) {
+            this.recordProactiveAuthRefreshStatus({
+                state: 'failed',
+                startedAt,
+                finishedAt: new Date().toISOString(),
+                candidates: dueCandidateNames,
+                refreshed: 0,
+                skipped: 0,
+                failed: dueCandidateNames.length,
+                error: formatUserError(error),
+                details: [],
+            });
+            throw error;
         }
         finally {
             await this.coordinator?.releaseAuthRefreshLease?.(lease?.leaseId ?? null);
             this.proactiveAuthRefreshInProgress = false;
         }
     }
-    proactiveAuthRefreshLocale() {
-        const identity = this.bot.identity;
-        if (!identity)
-            return 'en';
-        const privateScope = this.store.getTelegramPrivateScope(identity);
-        if (!privateScope)
-            return 'en';
-        return this.localeForChat(privateScope.scopeId);
-    }
-    async notifyProactiveAuthRefresh(locale, message, final = false) {
-        const identity = this.bot.identity;
-        if (!identity)
-            return;
-        const privateScope = this.store.getTelegramPrivateScope(identity);
-        if (!privateScope)
-            return;
-        const previous = this.proactiveAuthRefreshStatusMessage;
-        if (previous?.chatId === privateScope.chatId) {
-            try {
-                await this.bot.editMessage(privateScope.chatId, previous.messageId, message, []);
-                if (final) {
-                    this.proactiveAuthRefreshStatusMessage = null;
-                }
-                return;
-            }
-            catch (error) {
-                this.logger.warn('codex.auth_proactive_refresh_notify_edit_failed', { error: toErrorMeta(error) });
-            }
-        }
-        await this.bot.sendMessage(privateScope.chatId, message).then((messageId) => {
-            this.proactiveAuthRefreshStatusMessage = final ? null : { chatId: privateScope.chatId, messageId };
-        }).catch((error) => {
-            if (final) {
-                this.proactiveAuthRefreshStatusMessage = null;
-            }
-            this.logger.warn('codex.auth_proactive_refresh_notify_failed', { error: toErrorMeta(error) });
-        });
+    recordProactiveAuthRefreshStatus(status) {
+        this.proactiveAuthRefreshStatus = status;
+        this.updateStatus();
     }
     async handleAuthCommand(scopeId, locale, args) {
         const action = args[0]?.toLowerCase() ?? 'list';
@@ -4532,7 +4545,7 @@ export class BridgeSessionCore {
     async handleAuthSyncCommand(scopeId, locale, args) {
         const action = args[0]?.toLowerCase() ?? 'status';
         if (action === 'status') {
-            await this.sendMessage(scopeId, formatAuthSyncStatus(locale, this.coordinator?.getAuthSyncStatus?.() ?? null));
+            await this.sendMessage(scopeId, formatAuthSyncStatus(locale, this.coordinator?.getAuthSyncStatus?.() ?? null, this.getRuntimeStatus().authProactiveRefresh ?? null));
             return;
         }
         if (action === 'events') {
@@ -7216,16 +7229,35 @@ export class BridgeSessionCore {
             return false;
         }
         const liveTurn = findLiveTurn(snapshot);
-        if (!liveTurn || liveTurn.turnId !== preview.turnId) {
-            return false;
+        if (liveTurn) {
+            if (liveTurn.turnId === preview.turnId
+                && snapshot.activeFlags.includes('waitingOnUserInput')
+                && !this.hasPendingUserInputForTurn(preview.scopeId, preview.turnId)) {
+                return this.interruptOrphanWaitingUserInput(preview);
+            }
+            return this.attachRecoveredTurnPreview(preview, target, snapshot, liveTurn);
+        }
+        const previousTurn = snapshot.turns.find(turn => turn.turnId === preview.turnId) ?? null;
+        if (previousTurn && previousTurn.status !== 'inProgress') {
+            await this.retirePreviewMessage(preview.scopeId, preview.messageId, t(this.localeForChat(preview.scopeId), 'completed_see_reply_below'), preview.turnId);
+            return true;
         }
-        if (snapshot.activeFlags.includes('waitingOnUserInput')
-            && !this.hasPendingUserInputForTurn(preview.scopeId, preview.turnId)) {
-            return this.interruptOrphanWaitingUserInput(preview);
+        if (preview.isObserved) {
+            return false;
         }
+        return this.resumeInterruptedTurnAfterRestart(preview, target);
+    }
+    async attachRecoveredTurnPreview(preview, target, snapshot, liveTurn) {
         await this.stopWatchingScopeThread(preview.scopeId, preview.threadId);
-        const active = this.createActiveTurnState(preview.scopeId, target.chatId, target.chatType, target.topicId, preview.threadId, preview.turnId, preview.messageId, preview.isObserved);
-        this.setActiveTurn(preview.scopeId, preview.turnId, active);
+        const active = this.createActiveTurnState(preview.scopeId, target.chatId, target.chatType, target.topicId, preview.threadId, liveTurn.turnId, preview.messageId, preview.isObserved);
+        this.setActiveTurn(preview.scopeId, liveTurn.turnId, active);
+        this.store.saveActiveTurnPreview({
+            turnId: liveTurn.turnId,
+            scopeId: preview.scopeId,
+            threadId: preview.threadId,
+            messageId: preview.messageId,
+            isObserved: preview.isObserved,
+        });
         const watcher = {
             scopeId: preview.scopeId,
             chatId: target.chatId,
@@ -7235,7 +7267,7 @@ export class BridgeSessionCore {
             mode: 'app_snapshot',
             timer: null,
             cursor: seedObservedTurnCursor(liveTurn),
-            activeTurnId: preview.turnId,
+            activeTurnId: liveTurn.turnId,
             waitingOnApproval: snapshot.activeFlags.includes('waitingOnApproval'),
             sessionPath: null,
             sessionOffset: -1,
@@ -7250,11 +7282,59 @@ export class BridgeSessionCore {
         this.logger.info('telegram.preview_recovered', {
             scopeId: preview.scopeId,
             threadId: preview.threadId,
-            turnId: preview.turnId,
+            turnId: liveTurn.turnId,
+            previousTurnId: preview.turnId,
             isObserved: preview.isObserved,
         });
         return true;
     }
+    async resumeInterruptedTurnAfterRestart(preview, target) {
+        const locale = this.localeForChat(preview.scopeId);
+        const binding = {
+            threadId: preview.threadId,
+            cwd: this.store.getBinding(preview.scopeId)?.cwd ?? this.config.defaultCwd,
+        };
+        const input = [{
+                type: 'text',
+                text: t(locale, 'restart_auto_resume_prompt'),
+                text_elements: [],
+            }];
+        try {
+            await this.sendTyping(preview.scopeId);
+            const turnState = await this.startTurnWithRecovery(preview.scopeId, binding, input, {
+                recoverMissingThread: false,
+            });
+            if (turnState.collaborationMode === 'plan') {
+                this.store.setChatCollaborationMode(preview.scopeId, DEFAULT_COLLABORATION_MODE);
+            }
+            await this.registerActiveTurn(preview.scopeId, target.chatId, target.chatType, target.topicId, turnState.threadId, turnState.turnId, preview.messageId, {
+                input,
+                threadId: turnState.threadId,
+                cwd: binding.cwd,
+                chatId: target.chatId,
+                chatType: target.chatType,
+                topicId: target.topicId,
+                collaborationMode: turnState.collaborationMode,
+                failedAuthTargets: new Set(),
+            }, turnState.collaborationMode);
+            this.logger.info('telegram.preview_auto_resumed_after_restart', {
+                scopeId: preview.scopeId,
+                threadId: preview.threadId,
+                previousTurnId: preview.turnId,
+                turnId: turnState.turnId,
+            });
+            return true;
+        }
+        catch (error) {
+            this.logger.warn('telegram.preview_auto_resume_after_restart_failed', {
+                scopeId: preview.scopeId,
+                threadId: preview.threadId,
+                turnId: preview.turnId,
+                error: toErrorMeta(error),
+            });
+            return false;
+        }
+    }
     async interruptOrphanWaitingUserInput(preview) {
         try {
             await this.app.interruptTurn(preview.threadId, preview.turnId);
@@ -9180,7 +9260,7 @@ function formatAuthRefreshAllResult(locale, result, mode = 'manual') {
     }
     return lines.join('\n');
 }
-function formatAuthSyncStatus(locale, status) {
+function formatAuthSyncStatus(locale, status, proactiveRefresh = null) {
     if (!status?.enabled) {
         return t(locale, 'auth_sync_disabled');
     }
@@ -9209,6 +9289,11 @@ function formatAuthSyncStatus(locale, status) {
     if (status.lastError) {
         lines.push(t(locale, 'auth_sync_status_error', { value: status.lastError }));
     }
+    if (proactiveRefresh) {
+        lines.push(t(locale, 'auth_sync_status_proactive_refresh', {
+            value: formatAuthProactiveRefreshStatus(locale, proactiveRefresh),
+        }));
+    }
     if (status.peerStatuses?.length) {
         lines.push(t(locale, 'auth_sync_status_peer_activity'));
         for (const peer of status.peerStatuses.slice(0, 5)) {
@@ -9239,6 +9324,52 @@ function formatAuthSyncStatus(locale, status) {
     }
     return lines.join('\n');
 }
+function formatAuthProactiveRefreshStatus(locale, status) {
+    const time = status.finishedAt ?? status.startedAt;
+    const candidates = formatLimitedList(status.candidates, 3);
+    const state = formatAuthProactiveRefreshState(locale, status.state);
+    const result = locale === 'zh'
+        ? `已刷新 ${status.refreshed}，已跳过 ${status.skipped}，失败 ${status.failed}`
+        : `refreshed ${status.refreshed}, skipped ${status.skipped}, failed ${status.failed}`;
+    const parts = [
+        `${state} @ ${time}`,
+        locale === 'zh' ? `候选 ${candidates}` : `candidates ${candidates}`,
+        result,
+    ];
+    if (status.error) {
+        parts.push(locale === 'zh'
+            ? `原因 ${formatShortStatusError(status.error)}`
+            : `reason ${formatShortStatusError(status.error)}`);
+    }
+    if (status.details.length > 0) {
+        parts.push(locale === 'zh'
+            ? `明细 ${formatLimitedList(status.details.map(formatShortStatusError), 2)}`
+            : `details ${formatLimitedList(status.details.map(formatShortStatusError), 2)}`);
+    }
+    return parts.join('; ');
+}
+function formatAuthProactiveRefreshState(locale, state) {
+    if (locale === 'zh') {
+        switch (state) {
+            case 'running': return '进行中';
+            case 'completed': return '已完成';
+            case 'lease_failed': return '锁未授予';
+            case 'failed': return '失败';
+        }
+    }
+    switch (state) {
+        case 'running': return 'running';
+        case 'completed': return 'completed';
+        case 'lease_failed': return 'lease not granted';
+        case 'failed': return 'failed';
+    }
+}
+function formatLimitedList(values, limit) {
+    if (values.length === 0)
+        return '-';
+    const shown = values.slice(0, limit).join(', ');
+    return values.length > limit ? `${shown}, +${values.length - limit}` : shown;
+}
 function formatAuthSyncEvents(locale, status, filter) {
     if (!status?.enabled) {
         return t(locale, 'auth_sync_disabled');

package/dist/i18n.d.ts

@@ -129,6 +129,7 @@ declare const MESSAGES: {
         readonly status_auth_sync: "Cross-node auth sync: node {node}, contact {contact}, peers {peers}, pending imports {pending}";
         readonly status_auth_sync_error: "Cross-node auth sync error: {value}";
         readonly status_auth_sync_candidate_failures: "Auth sync candidate failures: {value}";
+        readonly status_auth_proactive_refresh: "Recent proactive auth refresh: {value}";
         readonly status_last_update_none: "Last service update: none recorded";
         readonly status_last_update: "Last service update: {from} -> {to} at {time}";
         readonly status_last_codex_update: "Last Codex update: {value}";
@@ -255,6 +256,7 @@ declare const MESSAGES: {
         readonly auth_sync_status_pull: "Last pull: {value}";
         readonly auth_sync_status_lease: "Active refresh lease: {value}";
         readonly auth_sync_status_error: "Last error: {value}";
+        readonly auth_sync_status_proactive_refresh: "Recent proactive refresh: {value}";
         readonly auth_sync_status_candidate_failures: "Candidate failures:";
         readonly auth_sync_status_candidate_failure: "- {candidate}: {reason} (source {source}, peer {peer}, at {time})";
         readonly auth_sync_status_peer_activity: "Peer activity:";
@@ -416,6 +418,7 @@ declare const MESSAGES: {
         readonly stale_preview_restarted: "The bridge restarted while turn {threadId} was still live. This status card is no longer live. Open the thread in Codex.app or send another message to continue.";
         readonly stale_preview_expired: "This live preview expired after the bridge stopped tracking the turn. If a final reply arrived, see below. Otherwise send the message again.";
         readonly stale_user_input_interrupted: "The bridge found a stale Codex input request for thread {threadId} with no recoverable Telegram question. It interrupted that stuck turn; send the message again to continue.";
+        readonly restart_auto_resume_prompt: "FoxClaw restarted while the previous turn was running. Continue the interrupted work from where it left off.";
         readonly streaming_reply_below: "Streaming reply below...";
         readonly interrupt_requested_preview: "Interrupt requested...";
         readonly interrupt_requested_waiting: "Interrupt requested. Waiting for Codex to stop...";
@@ -823,6 +826,7 @@ declare const MESSAGES: {
         readonly status_auth_sync: "跨节点 auth 同步：节点 {node}，联系人 {contact}，peer {peers}，待导入 {pending}";
         readonly status_auth_sync_error: "跨节点 auth 同步错误：{value}";
         readonly status_auth_sync_candidate_failures: "auth 同步候选失败：{value}";
+        readonly status_auth_proactive_refresh: "最近主动 auth 刷新：{value}";
         readonly status_last_update_none: "最近服务升级：暂无记录";
         readonly status_last_update: "最近服务升级：{from} -> {to}（{time}）";
         readonly status_last_codex_update: "最近 Codex 升级：{value}";
@@ -949,6 +953,7 @@ declare const MESSAGES: {
         readonly auth_sync_status_pull: "最近拉取：{value}";
         readonly auth_sync_status_lease: "当前刷新锁：{value}";
         readonly auth_sync_status_error: "最近错误：{value}";
+        readonly auth_sync_status_proactive_refresh: "最近主动刷新：{value}";
         readonly auth_sync_status_candidate_failures: "候选失败：";
         readonly auth_sync_status_candidate_failure: "- {candidate}：{reason}（来源 {source}，peer {peer}，时间 {time}）";
         readonly auth_sync_status_peer_activity: "Peer 活动：";
@@ -1110,6 +1115,7 @@ declare const MESSAGES: {
         readonly stale_preview_restarted: "桥接在该线程 {threadId} 仍处于活动状态时重启了。这张状态卡已经不再实时更新。你可以去 Codex.app 打开线程，或重新发一条消息继续。";
         readonly stale_preview_expired: "之前的实时预览在桥接停止跟踪这轮回复后已经失效。如果下方已有最终回复，请以最终回复为准；否则请重新发送消息。";
         readonly stale_user_input_interrupted: "桥接发现线程 {threadId} 有一条已经无法恢复到 Telegram 的 Codex 输入请求，已中断这条卡住的回复。请重新发送消息继续。";
+        readonly restart_auto_resume_prompt: "FoxClaw 重启时上一轮回复仍在运行。请从中断处继续完成刚才的工作。";
         readonly streaming_reply_below: "回复正在下方持续输出...";
         readonly interrupt_requested_preview: "已请求中断...";
         readonly interrupt_requested_waiting: "已请求中断，正在等待 Codex 停止...";

package/dist/i18n.js

@@ -127,6 +127,7 @@ const MESSAGES = {
         status_auth_sync: 'Cross-node auth sync: node {node}, contact {contact}, peers {peers}, pending imports {pending}',
         status_auth_sync_error: 'Cross-node auth sync error: {value}',
         status_auth_sync_candidate_failures: 'Auth sync candidate failures: {value}',
+        status_auth_proactive_refresh: 'Recent proactive auth refresh: {value}',
         status_last_update_none: 'Last service update: none recorded',
         status_last_update: 'Last service update: {from} -> {to} at {time}',
         status_last_codex_update: 'Last Codex update: {value}',
@@ -253,6 +254,7 @@ const MESSAGES = {
         auth_sync_status_pull: 'Last pull: {value}',
         auth_sync_status_lease: 'Active refresh lease: {value}',
         auth_sync_status_error: 'Last error: {value}',
+        auth_sync_status_proactive_refresh: 'Recent proactive refresh: {value}',
         auth_sync_status_candidate_failures: 'Candidate failures:',
         auth_sync_status_candidate_failure: '- {candidate}: {reason} (source {source}, peer {peer}, at {time})',
         auth_sync_status_peer_activity: 'Peer activity:',
@@ -414,6 +416,7 @@ const MESSAGES = {
         stale_preview_restarted: 'The bridge restarted while turn {threadId} was still live. This status card is no longer live. Open the thread in Codex.app or send another message to continue.',
         stale_preview_expired: 'This live preview expired after the bridge stopped tracking the turn. If a final reply arrived, see below. Otherwise send the message again.',
         stale_user_input_interrupted: 'The bridge found a stale Codex input request for thread {threadId} with no recoverable Telegram question. It interrupted that stuck turn; send the message again to continue.',
+        restart_auto_resume_prompt: 'FoxClaw restarted while the previous turn was running. Continue the interrupted work from where it left off.',
         streaming_reply_below: 'Streaming reply below...',
         interrupt_requested_preview: 'Interrupt requested...',
         interrupt_requested_waiting: 'Interrupt requested. Waiting for Codex to stop...',
@@ -821,6 +824,7 @@ const MESSAGES = {
         status_auth_sync: '跨节点 auth 同步：节点 {node}，联系人 {contact}，peer {peers}，待导入 {pending}',
         status_auth_sync_error: '跨节点 auth 同步错误：{value}',
         status_auth_sync_candidate_failures: 'auth 同步候选失败：{value}',
+        status_auth_proactive_refresh: '最近主动 auth 刷新：{value}',
         status_last_update_none: '最近服务升级：暂无记录',
         status_last_update: '最近服务升级：{from} -> {to}（{time}）',
         status_last_codex_update: '最近 Codex 升级：{value}',
@@ -947,6 +951,7 @@ const MESSAGES = {
         auth_sync_status_pull: '最近拉取：{value}',
         auth_sync_status_lease: '当前刷新锁：{value}',
         auth_sync_status_error: '最近错误：{value}',
+        auth_sync_status_proactive_refresh: '最近主动刷新：{value}',
         auth_sync_status_candidate_failures: '候选失败：',
         auth_sync_status_candidate_failure: '- {candidate}：{reason}（来源 {source}，peer {peer}，时间 {time}）',
         auth_sync_status_peer_activity: 'Peer 活动：',
@@ -1108,6 +1113,7 @@ const MESSAGES = {
         stale_preview_restarted: '桥接在该线程 {threadId} 仍处于活动状态时重启了。这张状态卡已经不再实时更新。你可以去 Codex.app 打开线程，或重新发一条消息继续。',
         stale_preview_expired: '之前的实时预览在桥接停止跟踪这轮回复后已经失效。如果下方已有最终回复，请以最终回复为准；否则请重新发送消息。',
         stale_user_input_interrupted: '桥接发现线程 {threadId} 有一条已经无法恢复到 Telegram 的 Codex 输入请求，已中断这条卡住的回复。请重新发送消息继续。',
+        restart_auto_resume_prompt: 'FoxClaw 重启时上一轮回复仍在运行。请从中断处继续完成刚才的工作。',
         streaming_reply_below: '回复正在下方持续输出...',
         interrupt_requested_preview: '已请求中断...',
         interrupt_requested_waiting: '已请求中断，正在等待 Codex 停止...',

package/dist/main.js

@@ -255,6 +255,7 @@ async function runServeCli() {
                 validate: async (context) => validateRefreshedAuthCandidate(runtime, context.candidateName),
                 notify: createAuthMirrorNotifier(store, runtime.id, runtime.bot, authNotificationAggregator, {
                     quietAuthPoolMode: () => config.authAutoDeleteNeedsRepair,
+                    suppressBackgroundNotifications: () => true,
                 }),
             })), logger, path.join(APP_HOME, 'runtime', 'auth-mirror.json'), {
                 onSynced: async (event) => {
@@ -279,6 +280,7 @@ async function runServeCli() {
             const writeAggregateStatus = (running = true) => {
                 const statuses = runtimes.map((runtime) => runtime.core.getRuntimeStatus());
                 const weixinStatus = activeWeixinCore?.getRuntimeStatus() ?? null;
+                const authProactiveRefresh = newestAuthProactiveRefreshStatus([...statuses, ...(weixinStatus ? [weixinStatus] : [])]);
                 const first = statuses[0] ?? null;
                 writeRuntimeStatus(config.statusPath, {
                     running,
@@ -316,6 +318,7 @@ async function runServeCli() {
                     } : {}),
                     authMirror: mirror.getStatus(),
                     authSync: authSync?.getStatus() ?? null,
+                    authProactiveRefresh,
                     lastUpdate: lastSelfUpdate,
                 });
             };
@@ -384,6 +387,10 @@ async function runServeCli() {
                     } : {}),
                     authMirror: mirror.getStatus(),
                     authSync: authSync?.getStatus() ?? null,
+                    authProactiveRefresh: newestAuthProactiveRefreshStatus([
+                        ...runtimes.map(runtime => runtime.core.getRuntimeStatus()),
+                        ...(activeWeixinCore ? [activeWeixinCore.getRuntimeStatus()] : []),
+                    ]),
                     lastUpdate: lastSelfUpdate,
                 }),
                 selfUpdateCompleted: (status) => {
@@ -444,6 +451,7 @@ async function runServeCli() {
                     isIdle: authSyncLocalIdle,
                     notify: createAuthSyncNotifier(store, authSyncTransportBot.bot, authNotificationAggregator, {
                         quietAuthPoolMode: () => config.authAutoDeleteNeedsRepair,
+                        suppressBackgroundNotifications: () => true,
                     }),
                 });
                 await authSync.initialize();
@@ -604,6 +612,7 @@ async function runServeCli() {
                 isIdle: singleAuthSyncLocalIdle,
                 notify: createAuthSyncNotifier(store, bot, authNotificationAggregator, {
                     quietAuthPoolMode: () => config.authAutoDeleteNeedsRepair,
+                    suppressBackgroundNotifications: () => true,
                 }),
             });
             await singleAuthSync.initialize();
@@ -676,6 +685,8 @@ async function runServeCli() {
 }
 function createAuthMirrorNotifier(store, botId, bot, aggregator, options = {}) {
     return async (event) => {
+        if (options.suppressBackgroundNotifications?.())
+            return;
         if (options.quietAuthPoolMode?.())
             return;
         const privateScope = store.getTelegramPrivateScope(botId);
@@ -711,6 +722,8 @@ function createAuthSyncNotifier(store, bot, aggregator, options = {}) {
         });
     };
     return async (event) => {
+        if (options.suppressBackgroundNotifications?.())
+            return;
         if (!bot.identity)
             return;
         const privateScope = store.getTelegramPrivateScope(bot.identity);
@@ -742,6 +755,18 @@ function formatAuthPoolSummary(locale, stats) {
         ? `auth 池：历史 ${stats.totalSeen}，存活 ${stats.alive}，因失效剔除 ${stats.deletedInvalid}。`
         : `Auth pool: total seen ${stats.totalSeen}, alive ${stats.alive}, invalid-deleted ${stats.deletedInvalid}.`;
 }
+function newestAuthProactiveRefreshStatus(statuses) {
+    const entries = statuses
+        .map(status => status.authProactiveRefresh ?? null)
+        .filter((status) => status !== null);
+    if (entries.length === 0)
+        return null;
+    return entries.reduce((newest, status) => {
+        const newestTime = newest.finishedAt ?? newest.startedAt;
+        const statusTime = status.finishedAt ?? status.startedAt;
+        return Date.parse(statusTime) >= Date.parse(newestTime) ? status : newest;
+    });
+}
 function isQuietAuthPoolNotification(event) {
     switch (event.kind) {
         case 'candidate_publish_started':

package/dist/types.d.ts

@@ -452,6 +452,17 @@ export interface RuntimeStatus {
             detail: string | null;
         }>;
     } | null;
+    authProactiveRefresh?: {
+        state: 'running' | 'completed' | 'lease_failed' | 'failed';
+        startedAt: string;
+        finishedAt: string | null;
+        candidates: string[];
+        refreshed: number;
+        skipped: number;
+        failed: number;
+        error: string | null;
+        details: string[];
+    } | null;
     lastUpdate?: {
         state: string;
         fromVersion: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.5.23",
+  "version": "0.5.25",
   "description": "Foxden local execution claw for controlling Codex from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",