@foxden-app/foxclaw 0.13.4 → 0.13.6

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 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.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
+
+### 中文
+
+- 修复 DSH `/threads` 只显示会话 ID：补充读取 DSH 原生持久化标题，旧会话无标题时使用首条用户消息；空会话显示未命名、工作目录和短编号。
+- 标题读取不恢复会话、不调用模型，单个历史会话读取失败不会影响列表；保留分页及原会话 ID 的打开行为。
+
+### English
+
+- Fixed DSH `/threads` displaying session IDs instead of readable names. Read native persisted titles, derive legacy names from the first human message, and show a workspace and short identifier for empty sessions.
+- Title reads do not resume sessions or invoke a model. Unreadable histories cannot break the list; pagination and opening by the original session ID are preserved.
+
 ## 0.13.4 - 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(`<blockquote expandable>${renderTelegramMarkdownRichHtml(text)}</blockquote>`, { 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

@@ -40,7 +40,23 @@ export declare class DshEngineAdapter implements IEngineAdapter {
     listEfforts(scopeId: string): Promise<SessionConfigSelectOption[]>;
     selectEffort(scopeId: string, effort: string | null): Promise<void>;
     setAccess(scopeId: string, access: AccessPresetValue): Promise<void>;
-    listSessions(scopeId: string, cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse>;
+    listSessions(scopeId: string, cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse | {
+        sessions: {
+            title: string | undefined;
+            sessionId: import("@agentclientprotocol/sdk").SessionId;
+            cwd: string;
+            additionalDirectories?: Array<string>;
+            updatedAt?: string | null;
+            _meta?: {
+                [key: string]: unknown;
+            } | null;
+        }[];
+        nextCursor?: string | null;
+        _meta?: {
+            [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

@@ -29,6 +29,7 @@ export declare class DshClient extends EventEmitter {
     private policyPath;
     private policyWrite;
     private stderr;
+    private titlesDirectory;
     permissionHandler?: (request: RequestPermissionRequest, signal: AbortSignal) => Promise<RequestPermissionResponse>;
     cancelPermissions?: () => void;
     constructor(options: DshClientOptions, scopeId: string, logger: Logger);
@@ -42,7 +43,25 @@ export declare class DshClient extends EventEmitter {
     session(cwd: string, sessionId?: string | null): Promise<string>;
     configOptions(sessionId: string): SessionConfigOption[];
     setConfig(sessionId: string, configId: string, value: string): Promise<void>;
-    listSessions(cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse>;
+    listSessions(cursor?: string): Promise<import("@agentclientprotocol/sdk").ListSessionsResponse | {
+        sessions: {
+            title: string | undefined;
+            sessionId: import("@agentclientprotocol/sdk").SessionId;
+            cwd: string;
+            additionalDirectories?: Array<string>;
+            updatedAt?: string | null;
+            _meta?: {
+                [key: string]: unknown;
+            } | null;
+        }[];
+        nextCursor?: string | null;
+        _meta?: {
+            [key: string]: unknown;
+        } | 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

@@ -4,7 +4,7 @@ import { EventEmitter } from 'node:events';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { ClientApp, ndJsonStream, PROTOCOL_VERSION } from '@agentclientprotocol/sdk';
 /** An owned ACP process; protocol stdout stays separate from diagnostics. */
@@ -21,6 +21,7 @@ export class DshClient extends EventEmitter {
     policyPath = '';
     policyWrite = Promise.resolve();
     stderr = '';
+    titlesDirectory = '';
     permissionHandler;
     cancelPermissions;
     constructor(options, scopeId, logger) {
@@ -65,6 +66,15 @@ export class DshClient extends EventEmitter {
             pluginPath = pluginPath.replace(/\.js$/, '.ts');
         }
         await fs.writeFile(patchPath, `- insert:\n    - id: foxclaw-permissions\n      name: ${JSON.stringify(pathToFileURL(pluginPath).href)}\n      config:\n        policyPath: ${JSON.stringify(this.policyPath)}\n`, { mode: 0o600 });
+        this.titlesDirectory = path.join(path.dirname(this.policyPath), `titles-${randomUUID()}`);
+        let titlesPlugin = fileURLToPath(new URL('./session_titles_plugin.js', import.meta.url));
+        try {
+            await fs.access(titlesPlugin);
+        }
+        catch {
+            titlesPlugin = titlesPlugin.replace(/\.js$/, '.ts');
+        }
+        await fs.appendFile(patchPath, `- insert:\n    - id: foxclaw-session-titles\n      name: ${JSON.stringify(pathToFileURL(titlesPlugin).href)}\n      config:\n        directory: ${JSON.stringify(this.titlesDirectory)}\n`);
         if (this.options.credentialControl) {
             let credentialsPlugin = fileURLToPath(new URL('./credentials_plugin.js', import.meta.url));
             try {
@@ -172,7 +182,65 @@ export class DshClient extends EventEmitter {
         await this.start();
         if (!this.capabilities.list)
             throw new Error('This DSH profile cannot list sessions');
-        return this.agent.request('session/list', cursor ? { cursor } : {});
+        const page = await this.agent.request('session/list', cursor ? { cursor } : {});
+        const unnamed = page.sessions.filter(session => !session.title?.trim());
+        if (unnamed.length === 0)
+            return page;
+        const titles = await this.readSessionTitles(unnamed.map(session => session.sessionId));
+        return { ...page, sessions: page.sessions.map(session => ({ ...session, title: session.title?.trim() ? session.title : titles[session.sessionId] })) };
+    }
+    async readSessionTitles(ids) {
+        try {
+            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(request), { mode: 0o600 });
+            await fs.rename(`${requestPath}.tmp`, requestPath);
+            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 result;
+                    throw new Error('Invalid DSH title response');
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+                await new Promise(resolve => setTimeout(resolve, 50));
+            }
+            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(() => { })));
+        }
     }
     async closeSession(sessionId) {
         await this.agent.request('session/close', { sessionId });
@@ -190,6 +258,8 @@ export class DshClient extends EventEmitter {
         this.optionsBySession.clear();
         if (!child || !child.pid) {
             connection?.close();
+            if (this.titlesDirectory)
+                await fs.rm(this.titlesDirectory, { recursive: true, force: true });
             return;
         }
         const exited = new Promise(resolve => child.once('exit', () => resolve()));
@@ -207,5 +277,7 @@ export class DshClient extends EventEmitter {
         connection?.close();
         if (this.process === child)
             this.process = null;
+        if (this.titlesDirectory)
+            await fs.rm(this.titlesDirectory, { recursive: true, force: true });
     }
 }

package/dist/dsh/session_titles_plugin.d.ts

@@ -0,0 +1,41 @@
+interface SessionQuery {
+    readTitle(id: string): Promise<{
+        title: string;
+    } | undefined>;
+    readSession(id: string): Promise<{
+        events: Array<{
+            type: string;
+            data: {
+                source?: {
+                    kind: string;
+                };
+                content?: Array<{
+                    type: string;
+                    text?: string;
+                }>;
+            };
+        }>;
+    }>;
+}
+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";
+export declare const inject: string[];
+/** Read native log-backed names without resuming sessions or invoking a model. */
+export declare function readSessionTitle(query: SessionQuery, id: string): Promise<string | undefined>;
+/** A private, per-process mailbox supplements ACP versions that omit titles. */
+export declare function apply(ctx: Context, config: {
+    directory: string;
+}): Promise<void>;
+export {};

package/dist/dsh/session_titles_plugin.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export const name = 'foxclaw-session-titles';
+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;
+    if (title?.trim())
+        return title;
+    const { events } = await query.readSession(id);
+    for (const event of events) {
+        if (event.type !== 'user/message' || event.data.source?.kind !== 'user')
+            continue;
+        const text = event.data.content?.filter(block => block.type === 'text').map(block => block.text ?? '').join(' ');
+        if (text?.trim())
+            return Array.from(text.replace(/\s+/gu, ' ').trim()).slice(0, 120).join('');
+    }
+    return undefined;
+}
+/** A private, per-process mailbox supplements ACP versions that omit titles. */
+export async function apply(ctx, config) {
+    await fs.mkdir(config.directory, { recursive: true, mode: 0o700 });
+    let active;
+    let stopped = false;
+    const poll = async () => {
+        for (const file of await fs.readdir(config.directory)) {
+            if (!/^[a-f0-9-]+\.request$/.test(file))
+                continue;
+            const requestPath = path.join(config.directory, file);
+            const responsePath = requestPath.replace(/\.request$/, '.response');
+            let response = {};
+            try {
+                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' };
+            }
+            if (!stopped) {
+                await fs.writeFile(`${responsePath}.tmp`, JSON.stringify(response), { mode: 0o600 });
+                await fs.rename(`${responsePath}.tmp`, responsePath);
+            }
+            await fs.rm(requestPath, { force: true });
+        }
+    };
+    const timer = setInterval(() => {
+        if (!active)
+            active = poll().catch(() => { }).finally(() => { active = undefined; });
+    }, 50);
+    ctx.effect(() => async () => {
+        stopped = true;
+        clearInterval(timer);
+        await active;
+        await fs.rm(path.join(config.directory, 'ready'), { force: true });
+    });
+    await fs.writeFile(path.join(config.directory, 'ready'), '', { mode: 0o600 });
+}

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;
@@ -141,7 +142,13 @@ export class DshUi {
     }
     async threads(scopeId, locale, orchestrator, messageId, cursor) {
         const page = await this.adapter.listSessions(scopeId, cursor);
-        const rows = page.sessions.map(session => [this.button(scopeId, 'open', session.sessionId, (session.title || session.sessionId).slice(0, 60), session.cwd)]);
+        const rows = page.sessions.map(session => {
+            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),
+                this.button(scopeId, 'rename', session.sessionId, '✏️', session.cwd)];
+        });
         if (page.nextCursor)
             rows.push([this.button(scopeId, 'page', page.nextCursor, this.copy(locale, '下一页', 'Next page'))]);
         rows.push([{ text: this.copy(locale, '返回设置', 'Back'), callback_data: 'engine:setup:main' }]);
@@ -189,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':
@@ -272,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:')) {
@@ -336,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;
@@ -378,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) {
@@ -391,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.4",
+  "version": "0.13.6",
   "description": "Foxden local execution claw for controlling Codex, OpenCode, Antigravity, and DeepSeek Harness from trusted chat interfaces.",
   "type": "module",
   "main": "dist/main.js",