@foxden-app/foxclaw 0.5.24 → 0.5.26

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.26 - 2026-06-09
+
+### 中文
+- 修正重启续接判定：如果 Codex app-server 把被重启打断的旧 turn 标成 completed，但没有任何可转发的 assistant/plan 输出或错误内容，FoxClaw 会把它当作中断任务自动续跑，而不是把 Telegram 状态卡误改成“已完成”。
+- 已经有明确输出或错误结果的 completed turn 仍按完成处理，避免对真实完成的任务重复续跑。
+
+### English
+- Fixed restart recovery detection: if the Codex app-server marks a restart-interrupted turn as completed but it has no relayable assistant/plan output or error, FoxClaw now treats it as interrupted and auto-resumes it instead of retiring the Telegram status card as completed.
+- Completed turns that do have output or an error are still treated as finished, avoiding duplicate resume runs for truly completed work.
+
+## 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
 
 ### 中文

package/dist/controller/controller.d.ts

@@ -419,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

@@ -7229,16 +7229,38 @@ 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') {
+            if (!turnHasRelayableOutcome(previousTurn)) {
+                return this.resumeInterruptedTurnAfterRestart(preview, target);
+            }
+            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,
@@ -7248,7 +7270,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,
@@ -7263,11 +7285,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);
@@ -8396,6 +8466,16 @@ function summarizeTurnItems(items) {
         .map(([type, count]) => `${type}=${count}`)
         .join(', ');
 }
+function turnHasRelayableOutcome(turn) {
+    if (turn.error?.trim()) {
+        return true;
+    }
+    return turn.items.some((item) => {
+        const type = item.type.toLowerCase();
+        return ((type === 'agentmessage' || type === 'assistantmessage' || type === 'plan')
+            && Boolean(item.text?.trim()));
+    });
+}
 function mapGoalNotification(raw) {
     if (!raw || typeof raw !== 'object') {
         return null;

package/dist/i18n.d.ts

@@ -418,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...";
@@ -1114,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

@@ -416,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...',
@@ -1112,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/package.json

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