@foxden-app/foxclaw 0.13.5 → 0.13.7

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 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.13.7 - 2026-10-06
+
+### 中文
+
+- 修复短小结在任务结束后看起来未收纳：Telegram 富消息改用默认关闭的 details 展开块，只显示“过程小结”入口，展开后保留完整内容及格式。接口不支持富消息时仍回退到可折叠引用。
+
+### English
+
+- Fixed short progress summaries appearing unfolded after completion. Telegram rich messages now use a closed details block with a visible disclosure label, preserving the full formatted content when expanded. Fall back to expandable quotes when rich messages are unavailable.
+
+## 0.13.6 - 2026-10-06
+
+### 中文
+
+- DSH `/threads` 每行右侧增加重命名按钮，输入新名称后通过原生标题服务保存并刷新列表，重启后保留；支持取消、过期及会话隔离。
+- 恢复 Codex 的小结与最终回答分离展示：工作中独立推送小结，完成后将之前的小结收纳为 Telegram 可展开消息，最终结论独立发送。长小结使用富消息保留全文，消息编号与收纳状态持久化；DSH 有明确消息边界时采用同样流程，Antigravity 保持现有展示。
+- 修复 Codex 断线后任务可能一直停留在工作中：释放实时任务并保留待确认状态与队列，使用 `/recover` 处理，避免自动重复执行结果未知的工具操作。正确识别原生失败结果及 RPC 结果未知的超时。
+- Codex 本机 WebSocket 启动等待由 10 秒延长到 60 秒，阻止超时握手迟到后污染连接；systemd 保留重启间隔，取消连续启动失败后的永久熔断，避免暂时不可用导致必须手动重启。
+
+### English
+
+- Added a rename button beside each DSH `/threads` entry. Save through the native title service and refresh the list, retaining names after restart; support cancellation, expiry, and scope isolation.
+- Restored separate Codex progress summaries and final answers. Send summaries as normal messages while working, fold earlier summaries into expandable Telegram messages at completion, and send the final answer separately. Preserve long summaries through rich messages and persist message IDs and fold state. DSH follows the same flow when message boundaries are available; Antigravity keeps its existing presentation.
+- Settle disconnected Codex executions without leaving a live task stuck. Keep unconfirmed outcomes and queued work for `/recover` instead of replaying tool operations automatically. Recognize native failed turns and RPC timeouts with unknown outcomes.
+- Allow 60 seconds instead of 10 for local Codex WebSocket startup and reject late handshakes from expired attempts. Keep systemd's restart delay while removing the start-limit lockout that required manual recovery after transient startup failures.
+
 ## 0.13.5 - 2026-10-06
 
 ### 中文

package/dist/channels/telegram/telegram_messaging_port.d.ts

@@ -17,6 +17,8 @@ export declare class TelegramMessagingPort implements ChannelPort {
     beginTaskPreview(scopeId: string, taskId: string, text: string, reuseMessageId?: number): Promise<number>;
     updateTaskPreview(scopeId: string, taskId: string, messageId: number, html: string): Promise<number>;
     endTaskPreview(scopeId: string, taskId: string): Promise<void>;
+    sendTaskCommentary(scopeId: string, text: string): Promise<number>;
+    foldTaskCommentary(scopeId: string, messageId: number, text: string): Promise<void>;
     readonly capabilities: {
         editableMessages: boolean;
         inlineActions: boolean;

package/dist/channels/telegram/telegram_messaging_port.js

@@ -3,6 +3,8 @@ import { telegramTaskResult } from '../../telegram/task_result.js';
 import { parseCommand } from '../../controller/commands.js';
 import { isDefaultTelegramScope, resolveTelegramAddressing } from '../../telegram/addressing.js';
 import { parseTelegramTargetFromBridgeScope } from '../../core/bridge_scope.js';
+import { renderTelegramMarkdownRichHtml } from '../../telegram/rich_markdown.js';
+import { escapeTelegramHtml } from '../../telegram/html.js';
 import { telegramRichHtml, telegramRichMarkdown } from '../../telegram/rich.js';
 /**
  * Telegram outbound operations addressed by bridge scope id (`telegram:…`).
@@ -17,6 +19,21 @@ export class TelegramMessagingPort {
     beginTaskPreview(scopeId, taskId, text, reuseMessageId = 0) { return this.taskPreviews.begin(scopeId, taskId, text, reuseMessageId); }
     updateTaskPreview(scopeId, taskId, messageId, html) { return this.taskPreviews.update(scopeId, taskId, messageId, html); }
     endTaskPreview(scopeId, taskId) { return this.taskPreviews.end(scopeId, taskId); }
+    async sendTaskCommentary(scopeId, text) {
+        return this.sendRichMarkdown(scopeId, text);
+    }
+    async foldTaskCommentary(scopeId, messageId, text) {
+        const target = parseTelegramTargetFromBridgeScope(scopeId);
+        try {
+            await this.gateway.editRichMessage(target.chatId, messageId, telegramRichHtml(`<details><summary>过程小结</summary>${renderTelegramMarkdownRichHtml(text)}</details>`, { skipEntityDetection: true }), []);
+        }
+        catch {
+            // The plain HTML endpoint has a smaller envelope than rich messages.
+            if (text.length > 3000)
+                throw new Error('Long commentary requires Telegram rich messages');
+            await this.gateway.editHtmlMessage(target.chatId, messageId, `<blockquote expandable>${escapeTelegramHtml(text)}</blockquote>`, []);
+        }
+    }
     capabilities = { editableMessages: true, inlineActions: true, maxMessageLength: 4000 };
     resolveIncoming(event, config, username) {
         return resolveTelegramAddressing({ text: event.text, attachmentsCount: event.attachments.length,

package/dist/codex_app/adapter.d.ts

@@ -3,6 +3,7 @@ import type { CodexAppClient } from './client.js';
 import type { SandboxModeValue, ApprovalPolicyValue } from '../types.js';
 export declare class CodexEngineAdapter implements IEngineAdapter {
     private readonly client;
+    readonly supportsCommentary = true;
     readonly id: string;
     readonly name: string;
     private readonly defaultModel;

package/dist/codex_app/adapter.js

@@ -4,6 +4,7 @@ import { buildAttachmentPrompt } from '../core/attachment_files.js';
 import { resolveAccessMode } from '../core/access.js';
 export class CodexEngineAdapter {
     client;
+    supportsCommentary = true;
     id;
     name;
     defaultModel;
@@ -45,6 +46,8 @@ export class CodexEngineAdapter {
             promptText = buildAttachmentPrompt(request.prompt, request.stagedAttachments);
         }
         let accumulatedResponse = '';
+        const messages = new Map();
+        const responseText = () => [...messages.values()].filter(message => message.kind !== 'commentary' && message.kind !== 'tool_summary').map(message => message.text).join('\n\n');
         let finalResult = null;
         let turnError = null;
         const resultWaiters = [];
@@ -70,9 +73,31 @@ export class CodexEngineAdapter {
                     return;
                 if (ev.turnId && turnId && ev.turnId !== turnId)
                     return;
-                if (ev.kind === 'agent_message_delta') {
-                    accumulatedResponse += ev.delta;
-                    emitter.emit('delta', ev.delta);
+                if (ev.kind === 'agent_message_started' || ev.kind === 'agent_message_delta' || ev.kind === 'agent_message_completed') {
+                    const phase = ev.kind === 'agent_message_delta' ? msg.params?.phase ?? msg.params?.item?.phase : ev.phase;
+                    const knownKind = Boolean(phase) || ev.isPlan;
+                    let message = messages.get(ev.itemId);
+                    if (!message) {
+                        message = { text: '', kind: knownKind || ev.kind === 'agent_message_completed' ? ev.outputKind : 'unknown', sent: false };
+                        messages.set(ev.itemId, message);
+                    }
+                    // Deltas often omit phase; started/completed items carry the authoritative phase.
+                    if (knownKind || (ev.kind === 'agent_message_completed' && message.kind === 'unknown'))
+                        message.kind = ev.outputKind;
+                    if (ev.kind === 'agent_message_delta') {
+                        message.text += ev.delta;
+                        if (message.kind !== 'commentary' && message.kind !== 'tool_summary')
+                            emitter.emit('delta', ev.delta);
+                    }
+                    else if (ev.kind === 'agent_message_completed') {
+                        if (ev.text !== null)
+                            message.text = ev.text;
+                        if ((message.kind === 'commentary' || message.kind === 'tool_summary') && !message.sent && message.text.trim()) {
+                            message.sent = true;
+                            emitter.emit('commentary', { messageId: ev.itemId, text: message.text });
+                        }
+                    }
+                    accumulatedResponse = responseText();
                 }
                 else if (ev.kind === 'tool_started') {
                     const cmdName = Array.isArray(ev.exec?.command) ? ev.exec.command.join(' ') : 'command';
@@ -90,9 +115,12 @@ export class CodexEngineAdapter {
                 }
                 else if (ev.kind === 'turn_completed') {
                     cleanup();
+                    const nativeTurn = msg.params?.turn;
+                    const failure = nativeTurn?.error?.message ?? (nativeTurn?.status === 'failed' ? 'Codex turn failed' : undefined);
                     finalResult = {
                         kind: 'result',
-                        status: ev.state === 'interrupted' ? 'INTERRUPTED' : 'SUCCESS',
+                        status: failure ? 'ERROR' : nativeTurn?.status === 'interrupted' || ev.state === 'interrupted' ? 'INTERRUPTED' : 'SUCCESS',
+                        ...(failure ? { error: String(failure) } : {}),
                         response: accumulatedResponse,
                         conversationId: threadId,
                     };
@@ -106,9 +134,20 @@ export class CodexEngineAdapter {
         };
         const cleanup = () => {
             this.client.off('notification', onNotification);
+            this.client.off('disconnected', onDisconnected);
             earlyNotifications.length = 0;
         };
+        const onDisconnected = () => {
+            if (finalResult || turnError)
+                return;
+            cleanup();
+            finalResult = { kind: 'result', status: 'ERROR', response: responseText(),
+                error: 'Codex connection closed before the task outcome was confirmed.', outcomeUnknown: true, conversationId: threadId };
+            emitter.emit('result', finalResult);
+            resolveWaiters(finalResult);
+        };
         this.client.on('notification', onNotification);
+        this.client.on('disconnected', onDisconnected);
         const effectiveModel = request.model && request.model !== 'default'
             ? request.model
             : (this.defaultModel && this.defaultModel !== 'default' ? this.defaultModel : null);
@@ -136,7 +175,7 @@ export class CodexEngineAdapter {
                         // thread might already be active on server
                     }
                 }
-                if (cancelled) {
+                if (cancelled || finalResult) {
                     cleanup();
                     return;
                 }
@@ -164,7 +203,7 @@ export class CodexEngineAdapter {
                         errMsg.includes('No thread') ||
                         errMsg.includes('stale') ||
                         errMsg.includes('invalid thread')) {
-                        if (cancelled)
+                        if (cancelled || finalResult)
                             throw turnErr;
                         const session = await this.client.startThread({
                             cwd: request.cwd,
@@ -173,7 +212,7 @@ export class CodexEngineAdapter {
                             sandboxMode: access.sandboxMode,
                         });
                         threadId = session.thread.threadId;
-                        if (cancelled) {
+                        if (cancelled || finalResult) {
                             cleanup();
                             return;
                         }
@@ -194,13 +233,25 @@ export class CodexEngineAdapter {
                         throw turnErr;
                     }
                 }
+                if (finalResult)
+                    return;
                 turnId = turn.id;
                 for (const notification of earlyNotifications.splice(0))
                     onNotification(notification);
             }
             catch (err) {
                 cleanup();
-                turnError = err instanceof Error ? err : new Error(String(err));
+                if (finalResult)
+                    return;
+                const failure = err instanceof Error ? err : new Error(String(err));
+                if (failure.message.includes('result is unknown')) {
+                    finalResult = { kind: 'result', status: 'ERROR', response: responseText(), error: failure.message,
+                        outcomeUnknown: true, conversationId: threadId };
+                    emitter.emit('result', finalResult);
+                    resolveWaiters(finalResult);
+                    return;
+                }
+                turnError = failure;
                 emitter.emit('error', turnError);
                 resolveWaiters(null);
             }

package/dist/codex_app/client.d.ts

@@ -79,6 +79,8 @@ export declare class CodexAppClient extends EventEmitter {
     private connected;
     private userAgent;
     private readonly requestTimeoutMs;
+    private readonly startupTimeoutMs;
+    private readonly handshakeTimeoutMs;
     constructor(codexCliBin: string, launchCommand: string, autolaunch: boolean, serverStatePath: string, serverLogPath: string, logger: Logger, childEnv?: NodeJS.ProcessEnv | null, appServerConfigOverrides?: readonly string[]);
     isConnected(): boolean;
     getUserAgent(): string | null;

package/dist/codex_app/client.js

@@ -34,6 +34,8 @@ export class CodexAppClient extends EventEmitter {
     connected = false;
     userAgent = null;
     requestTimeoutMs = 30_000;
+    startupTimeoutMs = 60_000;
+    handshakeTimeoutMs = 2000;
     constructor(codexCliBin, launchCommand, autolaunch, serverStatePath, serverLogPath, logger, childEnv = null, appServerConfigOverrides = []) {
         super();
         this.codexCliBin = codexCliBin;
@@ -588,20 +590,30 @@ export class CodexAppClient extends EventEmitter {
     async connectWebSocket() {
         const url = `ws://127.0.0.1:${this.port}`;
         const started = Date.now();
-        while (Date.now() - started < 10_000) {
+        while (Date.now() - started < this.startupTimeoutMs) {
             try {
                 await new Promise((resolve, reject) => {
                     const ws = new WebSocket(url);
+                    let settled = false;
                     const timer = setTimeout(() => {
+                        settled = true;
                         ws.close();
                         reject(new Error('WebSocket handshake timed out'));
-                    }, 2000);
+                    }, this.handshakeTimeoutMs);
                     const onError = (event) => {
+                        if (settled)
+                            return;
+                        settled = true;
                         clearTimeout(timer);
                         ws.close();
                         reject(new Error(`WebSocket connect failed: ${String(event.type)}`));
                     };
                     ws.addEventListener('open', () => {
+                        if (settled) {
+                            ws.close();
+                            return;
+                        }
+                        settled = true;
                         clearTimeout(timer);
                         ws.removeEventListener('error', onError);
                         this.socket = ws;

package/dist/core/channel_port.d.ts

@@ -32,6 +32,8 @@ export interface ChannelPort extends AttachmentDownloader {
     }>): Promise<void>;
     beginTaskPreview?(scopeId: string, taskId: string, text: string, reuseMessageId?: number): Promise<number>;
     updateTaskPreview?(scopeId: string, taskId: string, messageId: number, html: string): Promise<number>;
+    sendTaskCommentary?(scopeId: string, text: string): Promise<number>;
+    foldTaskCommentary?(scopeId: string, messageId: number, text: string): Promise<void>;
     endTaskPreview?(scopeId: string, taskId: string): Promise<void>;
     resolveAction?(event: ChannelTextEvent): ChannelCallbackEvent | null;
     editPlain(scopeId: string, messageId: ChannelMessageRef, text: string, keyboard?: ChannelInlineKeyboard): Promise<void>;

package/dist/core/engine_spi.d.ts

@@ -28,11 +28,17 @@ export interface EngineToolEvent {
     stepIndex?: number | undefined;
     summary?: string | undefined;
 }
+export interface EngineCommentaryEvent {
+    messageId: string;
+    text: string;
+}
 export interface EngineTurnResult {
     kind: 'result';
     status: 'SUCCESS' | 'ERROR' | 'INTERRUPTED';
     response: string;
     error?: string | undefined;
+    /** The connection ended before a native outcome was confirmed. */
+    outcomeUnknown?: boolean;
     conversationId: string | null;
     usage?: {
         inputTokens?: number | undefined;
@@ -47,6 +53,7 @@ export interface EngineTurnExecution {
     cancel(): void | Promise<void>;
     waitForResult(): Promise<EngineTurnResult | null>;
     on(event: 'delta', listener: (text: string) => void): void;
+    on(event: 'commentary', listener: (message: EngineCommentaryEvent) => void): void;
     on(event: 'tool', listener: (tool: EngineToolEvent) => void): void;
     on(event: 'result', listener: (result: EngineTurnResult) => void): void;
     on(event: 'error', listener: (error: Error) => void): void;
@@ -64,6 +71,7 @@ export interface EngineTurnErrorContext {
 export interface IEngineAdapter {
     readonly id: string;
     readonly name: string;
+    readonly supportsCommentary?: boolean;
     listModels(scopeId?: string): Promise<EngineModel[]>;
     executeTurn(request: EngineTurnRequest): EngineTurnExecution;
     preflightTurn?(request: EngineTurnRequest): Promise<void>;

package/dist/core/orchestrator.d.ts

@@ -28,6 +28,8 @@ export interface UnifiedActiveTurn {
     queueId?: string | undefined;
     taskId: string;
     settling?: boolean;
+    separateFinal?: boolean;
+    commentaryIds?: Set<string>;
 }
 export declare class UnifiedChannelOrchestrator {
     readonly config: AppConfig;

package/dist/core/orchestrator.js

@@ -357,8 +357,8 @@ export class UnifiedChannelOrchestrator {
                 { text: zh ? '放弃' : 'Cancel', callback_data: `engine:recover:cancel:${task.id}` },
             ]];
         await this.sendMessage(task.event.scopeId, zh
-            ? `⚠️ **任务执行结果待确认**\n任务: \`${task.id}\`\n${task.error ? `恢复失败: ${task.error}。` : '服务重启前可能已执行工具。'}原始输入与附件已保留，队列暂停。\n> ${task.sourcePrompt}\n\n/recover continue · /recover retry · /recover cancel`
-            : `⚠️ **Task outcome requires confirmation**\nTask: \`${task.id}\`\n${task.error ? `Recovery failed: ${task.error}.` : 'Tools may already have run before the restart.'} Input and attachments are preserved; the queue is paused.\n> ${task.sourcePrompt}\n\n/recover continue · /recover retry · /recover cancel`, actions);
+            ? `⚠️ **任务执行结果待确认**\n任务: \`${task.id}\`\n${task.error ? `提示: ${task.error}。` : '服务重启前可能已执行工具。'}原始输入与附件已保留，队列暂停。\n> ${task.sourcePrompt}\n\n/recover continue · /recover retry · /recover cancel`
+            : `⚠️ **Task outcome requires confirmation**\nTask: \`${task.id}\`\n${task.error ? `Details: ${task.error}.` : 'Tools may already have run before the restart.'} Input and attachments are preserved; the queue is paused.\n> ${task.sourcePrompt}\n\n/recover continue · /recover retry · /recover cancel`, actions);
     }
     async restoreDurableTasks() {
         const tasks = this.store.taskJournal.listUnfinished().filter(task => this.ownsScope(task.event.scopeId));
@@ -369,8 +369,8 @@ export class UnifiedChannelOrchestrator {
             }
         // Claim uncertainty synchronously before recovering messages or starting any queued work.
         for (const task of tasks)
-            if (task.state === 'running' && !task.result) {
-                this.store.taskJournal.update(task.id, 'awaiting_confirmation');
+            if (task.state === 'running' && (!task.result || task.result.outcomeUnknown)) {
+                this.store.taskJournal.update(task.id, 'awaiting_confirmation', { result: null });
             }
         // Import pre-journal previews and processing queues conservatively; their outcome is unknown.
         const journalScopes = new Set(tasks.filter(task => task.state !== 'queued').map(task => task.event.scopeId));
@@ -503,7 +503,7 @@ export class UnifiedChannelOrchestrator {
                 }
                 if (task.request.threadId)
                     this.store.setBinding(scopeId, task.request.threadId, task.request.cwd);
-                this.store.taskJournal.update(task.id, 'accepted', { request: { ...task.request, prompt, stagedAttachments }, result: null, delivery: [], deliveredChunks: 0, error: null });
+                this.store.taskJournal.update(task.id, 'accepted', { request: { ...task.request, prompt, stagedAttachments }, result: null, delivery: [], deliveredChunks: 0, previewSettled: false, separateFinal: this.getAdapterForBackend(task.backendId).supportsCommentary === true, error: null });
                 await this.executeTurn(task.event, prompt, locale, 0, stagedAttachments, { taskId: task.id, queueId: task.queueId ?? undefined, reuseMessageId: task.previewMessageId || undefined, forcedThreadId: task.request.threadId ?? undefined });
             }
         });
@@ -539,7 +539,7 @@ export class UnifiedChannelOrchestrator {
             const task = this.store.taskJournal.get(turn.taskId);
             const folded = buildFoldedToolsSummary({ toolLines: turn.toolLines, toolCount: turn.toolCount, stepIndex: turn.stepIndex, startTime: turn.startTime, locale: task.request.locale });
             const response = `${task.request.locale === 'zh' ? '🛑 已停止任务；排队任务保留。' : '🛑 Task stopped; queued tasks kept.'}${turn.accumulatedText.trim() ? `\n\n${turn.accumulatedText.trim()}` : ''}`;
-            this.store.taskJournal.update(turn.taskId, 'delivery_pending', { result: { kind: 'result', status: 'INTERRUPTED', response, conversationId: turn.threadId }, delivery: combineSummaryAndResponse(folded, response), deliveredChunks: 0, previewMessageId: turn.messageId });
+            this.store.taskJournal.update(turn.taskId, 'delivery_pending', { result: { kind: 'result', status: 'INTERRUPTED', response, conversationId: turn.threadId }, delivery: combineSummaryAndResponse(folded, response), deliveredChunks: 0, previewMessageId: turn.messageId, separateFinal: turn.separateFinal === true });
             try {
                 await this.deliverTaskChunks(turn.taskId);
                 this.resolveDeliveredTask(turn.taskId);
@@ -622,7 +622,7 @@ export class UnifiedChannelOrchestrator {
                 throw new Error('Delivery interrupted by shutdown');
             const index = task.deliveredChunks;
             const chunk = task.delivery[index];
-            if (index === 0 && task.previewMessageId > 0 && this.messaging.capabilities?.editableMessages !== false) {
+            if (!task.separateFinal && index === 0 && task.previewMessageId > 0 && this.messaging.capabilities?.editableMessages !== false) {
                 try {
                     await this.editMessage(task.event.scopeId, task.previewMessageId, chunk, []);
                 }
@@ -634,6 +634,34 @@ export class UnifiedChannelOrchestrator {
                 await this.sendMessage(task.event.scopeId, chunk);
             task = this.store.taskJournal.update(task.id, 'delivery_pending', { deliveredChunks: index + 1 });
         }
+        if (task.separateFinal) {
+            for (let index = 0; index < (task.commentary?.length ?? 0); index++) {
+                const item = task.commentary[index];
+                if (item.folded || this.messaging.capabilities?.editableMessages === false)
+                    continue;
+                try {
+                    if (this.messaging.foldTaskCommentary)
+                        await this.messaging.foldTaskCommentary(task.event.scopeId, item.messageId, item.text);
+                    else
+                        await this.editMessage(task.event.scopeId, item.messageId, `<blockquote expandable>${escapeHtml(item.text)}</blockquote>`, []);
+                    const commentary = [...task.commentary];
+                    commentary[index] = { ...item, folded: true };
+                    task = this.store.taskJournal.update(task.id, 'delivery_pending', { commentary });
+                }
+                catch (error) {
+                    this.logger.warn('orchestrator.commentary_fold_failed', { taskId, messageId: item.messageId, error: String(error) });
+                }
+            }
+            if (!task.previewSettled) {
+                if (task.previewMessageId > 0 && this.messaging.capabilities?.editableMessages !== false) {
+                    if (task.finalPreviewText)
+                        await this.editMessage(task.event.scopeId, task.previewMessageId, task.finalPreviewText, []);
+                    else
+                        await this.messaging.deleteMessage(task.event.scopeId, task.previewMessageId).catch(() => { });
+                }
+                task = this.store.taskJournal.update(task.id, 'delivery_pending', { previewSettled: true });
+            }
+        }
     }
     async safeDeliverChunks(scopeId, messageId, chunks) {
         const active = this.activeTurns.get(scopeId);
@@ -642,7 +670,7 @@ export class UnifiedChannelOrchestrator {
         await this.messageOperations.run(`${scopeId}:preview:${active.taskId}`, () => this.messaging.endTaskPreview?.(scopeId, active.taskId) ?? Promise.resolve());
         const task = this.store.taskJournal.get(active.taskId);
         messageId = active.messageId;
-        this.store.taskJournal.update(task.id, 'delivery_pending', { delivery: chunks, deliveredChunks: 0, previewMessageId: messageId });
+        this.store.taskJournal.update(task.id, 'delivery_pending', { delivery: chunks, deliveredChunks: 0, previewMessageId: messageId, separateFinal: active.separateFinal === true });
         await this.deliverTaskChunks(task.id);
     }
     async safeDeliverMessage(scopeId, messageId, text) {
@@ -927,7 +955,7 @@ export class UnifiedChannelOrchestrator {
                 stagedAttachments, threadId: binding?.threadId || null, cwd: binding?.cwd || this.config.defaultCwd,
                 model: settings?.model || 'default', effort: boost ? 'high' : settings?.reasoningEffort ?? backend.defaults?.reasoningEffort ?? null,
                 serviceTier: boost ? 'boost' : settings?.serviceTier ?? null, locale, accessPreset: settings?.accessPreset ?? 'default' },
-            queueId, previewMessageId: 0, result: null, delivery: [], deliveredChunks: 0, error: null,
+            queueId, previewMessageId: 0, result: null, delivery: [], deliveredChunks: 0, previewSettled: false, separateFinal: this.getBackendDescriptorForScope(event.scopeId).adapter.supportsCommentary === true, error: null,
             createdAt: Date.now(), updatedAt: Date.now(),
         };
         this.store.taskJournal.insert(task);
@@ -1123,7 +1151,7 @@ export class UnifiedChannelOrchestrator {
             throw new Error('Orchestrator is stopped');
         }
         let execution;
-        task = this.store.taskJournal.update(task.id, 'running', { result: null, delivery: [], deliveredChunks: 0 });
+        task = this.store.taskJournal.update(task.id, 'running', { result: null, delivery: [], deliveredChunks: 0, previewSettled: false, separateFinal: adapter.supportsCommentary === true });
         try {
             execution = adapter.executeTurn(req);
         }
@@ -1150,6 +1178,8 @@ export class UnifiedChannelOrchestrator {
             previewKey: turnKey,
             queueId: options?.queueId,
             taskId: task.id,
+            separateFinal: adapter.supportsCommentary === true,
+            commentaryIds: new Set(),
         };
         this.activeTurns.set(scopeId, activeTurn);
         this.messaging.sendTypingInScope(scopeId).catch(() => { });
@@ -1174,7 +1204,7 @@ export class UnifiedChannelOrchestrator {
                 const elapsedSeconds = Math.max(1, Math.floor((Date.now() - activeTurn.startTime) / 1000));
                 const content = renderStreamPreviewContent({
                     toolLines: activeTurn.toolLines,
-                    accumulatedText: activeTurn.accumulatedText,
+                    accumulatedText: activeTurn.separateFinal ? '' : activeTurn.accumulatedText,
                     isBoost,
                     engineName: adapter.name,
                     stepIndex: activeTurn.stepIndex,
@@ -1206,6 +1236,28 @@ export class UnifiedChannelOrchestrator {
             activeTurn.accumulatedText += delta;
             scheduleFlush();
         });
+        execution.on('commentary', (message) => {
+            if (!ownsTurn() || activeTurn.settling || !message.text.trim() || activeTurn.commentaryIds?.has(message.messageId))
+                return;
+            activeTurn.commentaryIds?.add(message.messageId);
+            activeTurn.separateFinal = true;
+            activeTurn.accumulatedText = '';
+            void this.messageOperations.run(`${scopeId}:preview:${activeTurn.taskId}`, async () => {
+                if (!ownsTurn())
+                    return;
+                const limit = this.messaging.sendTaskCommentary ? 30000 : Math.min(3000, this.messaging.capabilities?.maxMessageLength ?? 3000);
+                for (const text of chunkMessage(message.text, limit)) {
+                    const messageId = this.messaging.sendTaskCommentary
+                        ? await this.messaging.sendTaskCommentary(scopeId, text)
+                        : await this.messaging.sendRichMarkdown(scopeId, text);
+                    const current = this.store.taskJournal.get(activeTurn.taskId);
+                    this.store.taskJournal.update(current.id, current.state, {
+                        commentary: [...(current.commentary ?? []), { messageId, text, folded: false }], separateFinal: true,
+                    });
+                }
+            }).catch(error => this.logger.warn('orchestrator.commentary_send_failed', { taskId: activeTurn.taskId, error: String(error) }));
+            scheduleFlush();
+        });
         execution.on('tool', (tool) => {
             if (!ownsTurn() || activeTurn.settling)
                 return;
@@ -1271,6 +1323,8 @@ export class UnifiedChannelOrchestrator {
             this.activeTurns.delete(scopeId);
             this.store.removeActiveTurnPreview(turnKey);
             const task = this.store.taskJournal.get(activeTurn.taskId);
+            if (task.state === 'awaiting_confirmation')
+                return;
             if (task.state === 'delivery_pending' && task.deliveredChunks < task.delivery.length) {
                 this.logger.warn('orchestrator.delivery_pending', { taskId: task.id, scopeId });
                 return;
@@ -1304,6 +1358,14 @@ export class UnifiedChannelOrchestrator {
                             totalTokens: res.usage.totalTokens,
                         }, adapter.id);
                     }
+                    if (res.outcomeUnknown) {
+                        await this.messageOperations.run(`${scopeId}:preview:${activeTurn.taskId}`, () => this.messaging.endTaskPreview?.(scopeId, activeTurn.taskId) ?? Promise.resolve());
+                        const waiting = this.store.taskJournal.update(activeTurn.taskId, 'awaiting_confirmation', { result: null, error: res.error ?? null });
+                        if (activeTurn.messageId > 0)
+                            await this.editMessage(scopeId, activeTurn.messageId, locale === 'zh' ? '⚠️ 后端连接中断，任务结果尚未确认。使用 /recover 处理；排队任务已保留。' : '⚠️ Backend disconnected; task outcome unconfirmed. Use /recover; queued tasks are kept.', []).catch(() => { });
+                        await this.showRecovery(waiting);
+                        return;
+                    }
                     if (res.status === 'SUCCESS') {
                         let finalText = (res.response || '').trim();
                         if (!finalText && activeTurn.accumulatedText) {
@@ -1317,7 +1379,11 @@ export class UnifiedChannelOrchestrator {
                             usage: res.usage,
                             locale,
                         });
-                        const chunks = combineSummaryAndResponse(foldedTools, finalText || '(无输出 / No output)');
+                        if (activeTurn.separateFinal)
+                            this.store.taskJournal.update(activeTurn.taskId, 'running', { finalPreviewText: foldedTools });
+                        const chunks = activeTurn.separateFinal
+                            ? chunkMessage(finalText || '(无输出 / No output)', this.messaging.capabilities?.maxMessageLength)
+                            : combineSummaryAndResponse(foldedTools, finalText || '(无输出 / No output)');
                         await this.safeDeliverChunks(scopeId, activeTurn.messageId, chunks);
                         return;
                     }

package/dist/dsh/adapter.d.ts

@@ -56,6 +56,7 @@ export declare class DshEngineAdapter implements IEngineAdapter {
             [key: string]: unknown;
         } | null;
     }>;
+    renameSession(scopeId: string, sessionId: string, cwd: string, title: string): Promise<string>;
     isBusy(scopeId: string): boolean;
     executeTurn(request: EngineTurnRequest): EngineTurnExecution;
     stop(): Promise<void>;

package/dist/dsh/adapter.js

@@ -92,6 +92,12 @@ export class DshEngineAdapter {
         await state.client.setAccess(access);
     }
     async listSessions(scopeId, cursor) { return (await this.sessionForScope(scopeId)).client.listSessions(cursor); }
+    async renameSession(scopeId, sessionId, cwd, title) {
+        const state = await this.sessionForScope(scopeId);
+        if (this.busy.has(scopeId))
+            throw new Error('DSH session is busy');
+        return state.client.renameSession(sessionId, cwd, title);
+    }
     isBusy(scopeId) { return this.busy.has(scopeId); }
     executeTurn(request) {
         const emitter = new EventEmitter();
@@ -112,6 +118,8 @@ export class DshEngineAdapter {
             const update = notification.update;
             if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
                 if (update.messageId && update.messageId !== finalMessageId) {
+                    if (finalMessageId && finalMessage.trim())
+                        emitter.emit('commentary', { messageId: finalMessageId, text: finalMessage });
                     finalMessageId = update.messageId;
                     finalMessage = '';
                 }

package/dist/dsh/client.d.ts

@@ -60,6 +60,8 @@ export declare class DshClient extends EventEmitter {
         } | null;
     }>;
     private readSessionTitles;
+    renameSession(sessionId: string, cwd: string, title: string): Promise<string>;
+    private titleRequest;
     closeSession(sessionId: string): Promise<void>;
     stop(): Promise<void>;
     private dispose;

package/dist/dsh/client.js

@@ -190,26 +190,45 @@ export class DshClient extends EventEmitter {
         return { ...page, sessions: page.sessions.map(session => ({ ...session, title: session.title?.trim() ? session.title : titles[session.sessionId] })) };
     }
     async readSessionTitles(ids) {
-        const directory = this.titlesDirectory;
         try {
-            await fs.access(path.join(directory, 'ready'));
+            const result = await this.titleRequest(ids);
+            return Object.fromEntries(Object.entries(result).filter((entry) => ids.includes(entry[0]) && typeof entry[1] === 'string'));
         }
         catch {
+            this.logger.warn('dsh.session_titles.unavailable', { scopeId: this.scopeId });
             return {};
         }
+    }
+    async renameSession(sessionId, cwd, title) {
+        await this.start();
+        const alreadyOpen = this.optionsBySession.has(sessionId);
+        await this.session(cwd, sessionId);
+        try {
+            const result = await this.titleRequest({ operation: 'rename', sessionId, title });
+            if (result.ok !== true || typeof result.title !== 'string')
+                throw new Error(typeof result.error === 'string' ? result.error : 'DSH rename failed');
+            return result.title;
+        }
+        finally {
+            if (!alreadyOpen && this.connected)
+                await this.closeSession(sessionId);
+        }
+    }
+    async titleRequest(request) {
+        const directory = this.titlesDirectory;
+        await fs.access(path.join(directory, 'ready'));
         const requestPath = path.join(directory, `${randomUUID()}.request`);
         const responsePath = requestPath.replace(/\.request$/, '.response');
         try {
-            await fs.writeFile(`${requestPath}.tmp`, JSON.stringify(ids), { mode: 0o600 });
+            await fs.writeFile(`${requestPath}.tmp`, JSON.stringify(request), { mode: 0o600 });
             await fs.rename(`${requestPath}.tmp`, requestPath);
-            const deadline = Date.now() + 5000;
+            const deadline = Date.now() + 10000;
             while (this.connected && Date.now() < deadline) {
                 try {
                     const result = JSON.parse(await fs.readFile(responsePath, 'utf8'));
-                    if (result && typeof result === 'object' && !Array.isArray(result)) {
-                        return Object.fromEntries(Object.entries(result).filter(([id, title]) => ids.includes(id) && typeof title === 'string'));
-                    }
-                    return {};
+                    if (result && typeof result === 'object' && !Array.isArray(result))
+                        return result;
+                    throw new Error('Invalid DSH title response');
                 }
                 catch (error) {
                     if (error.code !== 'ENOENT')
@@ -217,15 +236,11 @@ export class DshClient extends EventEmitter {
                 }
                 await new Promise(resolve => setTimeout(resolve, 50));
             }
-            this.logger.warn('dsh.session_titles.timeout', { scopeId: this.scopeId });
-        }
-        catch {
-            this.logger.warn('dsh.session_titles.unavailable', { scopeId: this.scopeId });
+            throw new Error('DSH title operation timed out or disconnected');
         }
         finally {
             await Promise.all([requestPath, responsePath, `${requestPath}.tmp`].map(file => fs.rm(file, { force: true }).catch(() => { })));
         }
-        return {};
     }
     async closeSession(sessionId) {
         await this.agent.request('session/close', { sessionId });

package/dist/dsh/session_titles_plugin.d.ts

@@ -19,6 +19,15 @@ interface SessionQuery {
 }
 interface Context {
     sessionQuery: SessionQuery;
+    sessions?: {
+        get(id: string): unknown;
+        flush(session: unknown): Promise<unknown>;
+    };
+    sessionTitle?: {
+        rename(session: unknown, title: string): {
+            title: string;
+        };
+    };
     effect(callback: () => () => Promise<void>): void;
 }
 export declare const name = "foxclaw-session-titles";

package/dist/dsh/session_titles_plugin.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 export const name = 'foxclaw-session-titles';
-export const inject = ['sessionQuery'];
+export const inject = ['sessionQuery', 'sessions', 'sessionTitle'];
 /** Read native log-backed names without resuming sessions or invoking a model. */
 export async function readSessionTitle(query, id) {
     const title = (await query.readTitle(id))?.title;
@@ -28,21 +28,37 @@ export async function apply(ctx, config) {
                 continue;
             const requestPath = path.join(config.directory, file);
             const responsePath = requestPath.replace(/\.request$/, '.response');
-            let titles = Object.create(null);
+            let response = {};
             try {
-                const ids = JSON.parse(await fs.readFile(requestPath, 'utf8'));
-                if (!Array.isArray(ids) || ids.length > 1000 || !ids.every(id => typeof id === 'string'))
-                    throw new Error('Invalid session title request');
-                const results = await Promise.allSettled(ids.map(async (id) => ({ id, title: await readSessionTitle(ctx.sessionQuery, id) })));
-                titles = Object.create(null);
-                for (const result of results) {
-                    if (result.status === 'fulfilled' && result.value.title)
-                        titles[result.value.id] = result.value.title;
+                const request = JSON.parse(await fs.readFile(requestPath, 'utf8'));
+                if (Array.isArray(request)) {
+                    if (request.length > 1000 || !request.every(id => typeof id === 'string'))
+                        throw new Error('Invalid session title request');
+                    const results = await Promise.allSettled(request.map(async (id) => ({ id, title: await readSessionTitle(ctx.sessionQuery, id) })));
+                    const titles = Object.create(null);
+                    for (const result of results) {
+                        if (result.status === 'fulfilled' && result.value.title)
+                            titles[result.value.id] = result.value.title;
+                    }
+                    response = titles;
                 }
+                else {
+                    const rename = request;
+                    if (rename?.operation !== 'rename' || typeof rename.sessionId !== 'string' || typeof rename.title !== 'string')
+                        throw new Error('Invalid rename request');
+                    const session = ctx.sessions?.get(rename.sessionId);
+                    if (!session || !ctx.sessionTitle)
+                        throw new Error('DSH session is unavailable for rename');
+                    const accepted = ctx.sessionTitle.rename(session, rename.title);
+                    await ctx.sessions.flush(session);
+                    response = { ok: true, title: accepted.title };
+                }
+            }
+            catch (error) {
+                response = { ok: false, error: error instanceof Error ? error.message : 'DSH title operation failed' };
             }
-            catch { /* Metadata failure must not break native session listing. */ }
             if (!stopped) {
-                await fs.writeFile(`${responsePath}.tmp`, JSON.stringify(titles), { mode: 0o600 });
+                await fs.writeFile(`${responsePath}.tmp`, JSON.stringify(response), { mode: 0o600 });
                 await fs.rename(`${responsePath}.tmp`, responsePath);
             }
             await fs.rm(requestPath, { force: true });

package/dist/dsh/ui.d.ts

@@ -17,6 +17,7 @@ export declare class DshUi {
     private readonly approvals;
     readonly adapter: DshEngineAdapter;
     private readonly credentials;
+    private readonly renames;
     get pendingApprovals(): number;
     get pendingOperations(): number;
     stopPendingOperations(): Promise<void>;
@@ -41,6 +42,7 @@ export declare class DshUi {
     stop(): Promise<void>;
     isSensitiveInbound(event: ChannelTextEvent): boolean;
     inbound(event: ChannelTextEvent, locale: AppLocale, host: BackendUiHost): boolean | Promise<boolean>;
+    private saveRename;
     private saveKey;
     private clearKeyInput;
     private keyInput;

package/dist/dsh/ui.js

@@ -16,9 +16,10 @@ export class DshUi {
     approvals = new Map();
     adapter;
     credentials;
+    renames = new Set();
     get pendingApprovals() { return this.approvals.size; }
-    get pendingOperations() { return this.credentials.pendingOperations; }
-    stopPendingOperations() { return this.credentials.stop(); }
+    get pendingOperations() { return this.credentials.pendingOperations + this.renames.size; }
+    async stopPendingOperations() { await Promise.allSettled([...this.renames]); await this.credentials.stop(); }
     constructor(config, store, logger, messaging) {
         this.config = config;
         this.store = store;
@@ -145,7 +146,8 @@ export class DshUi {
             const workspace = session.cwd.split(/[\\/]/).filter(Boolean).at(-1) || session.cwd;
             const fallback = `${this.copy(locale, '未命名会话', 'Untitled session')} · ${workspace} · ${session.sessionId.slice(-8)}`;
             const title = session.title?.replace(/\s+/gu, ' ').trim() || fallback;
-            return [this.button(scopeId, 'open', session.sessionId, Array.from(title).slice(0, 60).join(''), session.cwd)];
+            return [this.button(scopeId, 'open', session.sessionId, Array.from(title).slice(0, 60).join(''), session.cwd),
+                this.button(scopeId, 'rename', session.sessionId, '✏️', session.cwd)];
         });
         if (page.nextCursor)
             rows.push([this.button(scopeId, 'page', page.nextCursor, this.copy(locale, '下一页', 'Next page'))]);
@@ -194,6 +196,8 @@ export class DshUi {
         await orchestrator.sendMessage(scopeId, `🧩 **DSH ${this.copy(locale, '插件配置', 'plugin configuration')}**\n\nProfile: \`${dsh.profile}\`\n${Object.entries(dependencies).map(([name, version]) => `• ${name}: ${String(version)}`).join('\n') || this.copy(locale, 'Profile 尚未初始化或没有显式依赖。', 'Profile is not initialized or has no explicit dependencies.')}\n• foxclaw-permissions\n\n${this.copy(locale, '已配置补丁', 'Configured patches')}:\n${dsh.patches.map(patch => `• ${patch}`).join('\n') || '—'}\n\n${this.copy(locale, '安装/移除插件请在终端执行，随后重启 foxclaw', 'Install/remove plugins in a terminal, then restart foxclaw')}:\n\`dsh plugin --profile ${dsh.profile} add <package>\`\n\`dsh plugin --profile ${dsh.profile} remove <package>\``);
     }
     async command(scopeId, command, args, locale, orchestrator) {
+        this.clearKeyInput(scopeId);
+        this.store.setServiceInteraction(scopeId, 'dsh:rename', null);
         try {
             switch (command) {
                 case 'cancel':
@@ -277,6 +281,7 @@ export class DshUi {
     }
     async callback(scopeId, data, locale, orchestrator, event) {
         this.clearKeyInput(scopeId);
+        this.store.setServiceInteraction(scopeId, 'dsh:rename', null);
         const answer = (text = '') => this.messaging.answerCallback(event?.callbackQueryId ?? '', text);
         if (!data.startsWith('dsh:')) {
             if (orchestrator.getBackendDescriptorForScope(scopeId).engineType === 'dsh' && data.startsWith('engine:') && !['engine:setup:main', 'engine:setup:models', 'engine:setup:active_mode', 'engine:setup:new', 'engine:setup:backend'].includes(data) && !data.startsWith('engine:backend:')) {
@@ -341,6 +346,13 @@ export class DshUi {
                     await this.selectAccess(scopeId, action.value, orchestrator);
                 else if (action.kind === 'open')
                     await this.open(scopeId, action.value, action.cwd, orchestrator);
+                else if (action.kind === 'rename') {
+                    if (orchestrator.hasActiveTurn(scopeId))
+                        throw new Error(this.copy(locale, '请先结束当前任务再重命名。', 'Finish the active task before renaming.'));
+                    this.store.setServiceInteraction(scopeId, 'dsh:rename', JSON.stringify({ sessionId: action.value, cwd: action.cwd, expires: Date.now() + 300000 }));
+                    await orchestrator.sendMessage(scopeId, this.copy(locale, '✏️ 发送新的会话名称，或发送 /cancel 取消。', '✏️ Send the new session name, or /cancel to cancel.'));
+                    return true;
+                }
                 else if (action.kind === 'page') {
                     await this.threads(scopeId, locale, orchestrator, event?.messageId, action.value);
                     return true;
@@ -383,7 +395,7 @@ export class DshUi {
         for (const pending of this.approvals.values())
             pending.resolve({ outcome: { outcome: 'cancelled' } });
         this.actions.clear();
-        await this.credentials.stop();
+        await this.stopPendingOperations();
         await this.adapter.stop();
     }
     isSensitiveInbound(event) {
@@ -396,10 +408,45 @@ export class DshUi {
         return true;
     }
     inbound(event, locale, host) {
+        const rename = this.store.getServiceInteraction(event.scopeId, 'dsh:rename');
+        if (rename) {
+            if (event.text.trim().startsWith('/')) {
+                this.store.setServiceInteraction(event.scopeId, 'dsh:rename', null);
+                return false;
+            }
+            return this.saveRename(event, locale, host, rename);
+        }
         if (!this.isSensitiveInbound(event))
             return false;
         return this.saveKey(event, locale, host);
     }
+    async saveRename(event, locale, host, state) {
+        this.store.setServiceInteraction(event.scopeId, 'dsh:rename', null);
+        try {
+            const pending = JSON.parse(state);
+            if (pending.expires < Date.now())
+                throw new Error(this.copy(locale, '重命名已过期，请重新点击按钮。', 'Rename expired; select the button again.'));
+            if (event.attachments.length || !event.text.trim() || Array.from(event.text.trim()).length > 120)
+                throw new Error(this.copy(locale, '名称须为 1–120 个字符的文本。', 'Enter a text name of 1–120 characters.'));
+            if (host.hasActiveTurn(event.scopeId))
+                throw new Error(this.copy(locale, '请先结束当前任务。', 'Finish the active task first.'));
+            const operation = this.adapter.renameSession(event.scopeId, pending.sessionId, pending.cwd, event.text.trim());
+            this.renames.add(operation);
+            let title;
+            try {
+                title = await operation;
+            }
+            finally {
+                this.renames.delete(operation);
+            }
+            await host.sendMessage(event.scopeId, this.copy(locale, `✅ 已重命名：${title}`, `✅ Renamed: ${title}`));
+            await this.threads(event.scopeId, locale, host);
+        }
+        catch (error) {
+            await host.sendMessage(event.scopeId, `⚠️ ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return true;
+    }
     async saveKey(event, locale, host) {
         const saved = this.keyInput(event.scopeId);
         this.clearKeyInput(event.scopeId);

package/dist/store/task_journal.d.ts

@@ -12,6 +12,14 @@ export interface JournalTask {
     queueId: string | null;
     previewMessageId: number;
     result: EngineTurnResult | null;
+    commentary?: Array<{
+        messageId: number;
+        text: string;
+        folded: boolean;
+    }>;
+    separateFinal?: boolean;
+    finalPreviewText?: string;
+    previewSettled?: boolean;
     delivery: string[];
     deliveredChunks: number;
     error: string | null;

package/dist/systemd.js

@@ -7,8 +7,7 @@ Description=FoxClaw local Codex execution bridge
 Documentation=https://github.com/foxden-app/foxclaw
 After=network-online.target
 Wants=network-online.target
-StartLimitIntervalSec=300
-StartLimitBurst=5
+StartLimitIntervalSec=0
 
 [Service]
 Type=simple

package/docs/dsh.md

@@ -57,7 +57,7 @@ Use `/models` → **Configure API Key** to add or update a DeepSeek key in a pri
 | `/models`, `/model <provider/model>` | Native model selection; `/model default` restores the session's initial model |
 | `/effort`, `/effort <level>` | Reasoning choices advertised by the current model; changing models resets reasoning to the new model's default |
 | `/permissions read-only\|default\|full-access` | Read-only, workspace-write, or full-access, also available as buttons |
-| `/threads`, `/open <session ID>` | List and resume persisted DSH sessions |
+| `/threads`, `/open <session ID>` | List and resume persisted DSH sessions; use ✏️ beside a session to rename it, or `/cancel` to cancel name entry |
 | `/new [directory]` | New session with an optional working directory |
 | `/active queue\|steer`, `/queue`, `/steer <message>`, `/interrupt` | Queueing, interruption, and takeover |
 | `/plugins` | Profile dependencies and configured patch paths |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foxden-app/foxclaw",
-  "version": "0.13.5",
+  "version": "0.13.7",
   "description": "Foxden local execution claw for controlling Codex, OpenCode, Antigravity, and DeepSeek Harness from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",