minimal-agent 0.18.7 → 0.18.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minimal-agent",
-  "version": "0.18.7",
+  "version": "0.18.9",
   "description": "Bun-first 的本地 Agent 内核，支持工具、插件、工作流、上下文压缩、长期记忆与 OpenAI 兼容接口；Tauri 桌面宿主和 Node.js npm 发布可复用同一内核",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Bill Wang <leiwang0359@gmail.com>",

package/src/context/persistContext.js

@@ -91,7 +91,7 @@ export function filterEphemeralMessages(messages) {
 }
 /**
  * 保存当前 messages 为"上下文文件"，覆盖之前内容。
- * 写失败不抛——丢一次落盘比把进程崩掉划算。
+ * 自动保存默认尽力写入；显式用户操作使用 strict，在写失败时抛错。
  *
  * v2.x 新增：写盘前过滤掉 _ephemeral=true 的 system 消息（UI 临时提示，
  * 不应进入持久化历史）。
@@ -116,6 +116,10 @@ export async function saveContext(messages, file, options) {
         await rename(temp, target);
     }
     catch (e) {
+        // Explicit user mutations must not report success when persistence failed.
+        // Ordinary turn autosave retains its existing best-effort behavior.
+        if (options?.strict)
+            throw e;
         // 不抛（持久化失败不该影响对话本身），但要出声——磁盘满/权限问题时
         // 用户整段会话会静默丢失；与 clearContext 的 archive 失败处理风格对齐。
         try {

package/src/context/persistContext.ts

@@ -101,12 +101,12 @@ export function filterEphemeralMessages(messages: Message[]): Message[] {
 
 /**
  * 保存当前 messages 为"上下文文件"，覆盖之前内容。
- * 写失败不抛——丢一次落盘比把进程崩掉划算。
+ * 自动保存默认尽力写入；显式用户操作使用 strict，在写失败时抛错。
  *
  * v2.x 新增：写盘前过滤掉 _ephemeral=true 的 system 消息（UI 临时提示，
  * 不应进入持久化历史）。
  */
-export async function saveContext(messages: Message[], file?: string, options?: { replaceDisplayHistory?: boolean }): Promise<void> {
+export async function saveContext(messages: Message[], file?: string, options?: { replaceDisplayHistory?: boolean; strict?: boolean }): Promise<void> {
   const target = file ?? getContextPath();
   const temp = `${target}.${process.pid}.${randomUUID()}.tmp`;
   try {
@@ -122,6 +122,9 @@ export async function saveContext(messages: Message[], file?: string, options?:
     await writeFile(temp, JSON.stringify(data), { encoding: 'utf8', mode: 0o600 });
     await rename(temp, target);
   } catch (e) {
+    // Explicit user mutations must not report success when persistence failed.
+    // Ordinary turn autosave retains its existing best-effort behavior.
+    if (options?.strict) throw e;
     // 不抛（持久化失败不该影响对话本身），但要出声——磁盘满/权限问题时
     // 用户整段会话会静默丢失；与 clearContext 的 archive 失败处理风格对齐。
     try {

package/src/loop.js

@@ -29,6 +29,8 @@
 import crypto from 'node:crypto';
 import { answerPreparationNotice } from './runtime/answerPreparation.js';
 import { finalAnswerMessages } from './runtime/finalAnswer.js';
+import { resolveOutputContract, toolsForResponsePhase } from './runtime/outputContract.js';
+import { needsDiagramPreparation, visualPresentation } from './prompts/visualPresentation.js';
 import { createLifecycleTrace } from './runtime/lifecycleTrace.js';
 import { conciseToolPath } from './runtime/toolDisplay.js';
 import { dirname, resolve } from 'node:path';
@@ -67,6 +69,7 @@ import { createAgentRuntimeContext, } from './runtime/agentRuntimeContext.js';
 import { stripThinkBlocks } from './utils/stripThink.js';
 import { orderedPool } from './runtime/orderedPool.js';
 import { takeAgentNotifications, agentCoordinationContext } from './tools/agent/agentTaskService.js';
+import { delegationRuntimeGuidance } from './prompts/delegation.js';
 import { executionSegments } from './tools/executionSegments.js';
 import { acquireSubagentLease, normalizeWriteScopes } from './tools/agent/coordinator.js';
 const DELIVERY_ARTIFACT = '(?:文件|合同|协议|方案|文档|表格|报告|图片|图像|海报|幻灯片|PPT|PDF|代码|脚本|压缩包|网页|页面|HTML|DOCX|XLSX|CSV|ZIP)';
@@ -237,7 +240,11 @@ export async function* runQuery(userInput, options) {
     let resultPresented = false;
     let presentedResultUnverified = false;
     let deliveryCorrectionAttempted = false;
+    let emptyResponseRecoveryAttempted = false;
+    let emptyResponseRecoveryReason = '';
     let askCorrectionAttempted = false;
+    let diagramPreparationAttempted = false;
+    const output = resolveOutputContract(runtimeContext.surface, runtimeContext.output);
     const subagents = await configService.subagents();
     await hydrateSessionWorktree({
         sessionState,
@@ -246,6 +253,8 @@ export async function* runQuery(userInput, options) {
         cwd: runtimeContext.cwd,
     });
     const toolCallContext = {
+        output,
+        availableToolNames: () => currentEffectiveToolSet.names,
         executionServices: { ...options.executionServices, executeTool: executeToolFn, chat: chatFn, invocationPolicy: options.invocationPolicy },
         history,
         sessionState,
@@ -320,8 +329,13 @@ export async function* runQuery(userInput, options) {
         const parts = [
             transientFor(activeTools),
             coordinationText,
+            delegationRuntimeGuidance({ available: runtimeContext.profile === 'main' && currentEffectiveToolSet.names.has('Agent'),
+                maxConcurrent: subagents.maxConcurrent, callsUsed: toolCallContext.agentCalls?.used ?? 0,
+                maxCalls: toolCallContext.agentCalls?.max ?? 0 }),
+            diagramPreparationAttempted ? visualPresentation(output) : '',
             delegationCorrectionAttempted ? '本轮必要子任务尚未验收或接管完成。先读取结果、等待运行任务或完成接力，使用 AgentResolve 记录判断；若确实无法完成，明确报告缺口，不声称全部完成。' : '',
             askCorrectionAttempted ? '当前交互宿主支持 AskUserQuestion。若仍需用户选择或补充，请调用该工具一次只问一个问题，等待答案后继续；不要仅在正文列问后停止。若没有待决事项则正常回答，不必提问。' : '',
+            emptyResponseRecoveryAttempted ? `上一次模型响应没有可交付正文（${emptyResponseRecoveryReason}）。请基于已有历史和工具结果继续完成任务：信息充分则给出实质结论，不充分则继续必要操作或明确缺口。不要重复已经完成的调查或有副作用的操作；不要把未完成的任务说成完成。已有顾问意见继续有效，无需仅因恢复而再次咨询。` : '',
             deliveryCorrectionAttempted && !resultPresented ? DELIVERY_CORRECTION_REMINDER : '',
             advisorAvailable ? advisorCoordinator.transientReminder() : '',
             advisorAvailable
@@ -685,16 +699,24 @@ export async function* runQuery(userInput, options) {
                 requiredNames: [...effectiveToolSet.requiredNames],
             });
         advisorCoordinator.setAvailable(currentEffectiveToolSet.names.has('Advisor'));
+        // Tool availability may change during emergency fitting. Rebuild dynamic
+        // guidance against the actual request boundary, then account for its size.
+        requestTransientContext = buildRequestTransientContext();
+        lastRequestTransientContext = requestTransientContext;
+        const finalRequestBudget = buildContextBudgetPlan({
+            provider, history, tools: currentEffectiveToolSet.tools,
+            transientContext: requestTransientContext,
+        });
         if (emergencyFit.removedNames.length > 0) {
             yield {
                 type: 'warning',
                 message: `当前模型窗口压力过高，本次请求临时省略工具 Schema：${emergencyFit.removedNames.join(', ')}；下一轮会重新评估并恢复。`,
             };
         }
-        if (emergencyFit.plan.overBudget) {
+        if (finalRequestBudget.overBudget) {
             yield {
                 type: 'error',
-                error: `当前请求即使经过上下文降级仍需要约 ${emergencyFit.plan.totalInputTokens} tokens，超过模型输入上限 ${emergencyFit.plan.inputLimit}。已停止发送，避免 Provider 接收必然失败的超限请求。`,
+                error: `当前请求即使经过上下文降级仍需要约 ${finalRequestBudget.totalInputTokens} tokens，超过模型输入上限 ${finalRequestBudget.inputLimit}。已停止发送，避免 Provider 接收必然失败的超限请求。`,
                 code: 'context_overflow',
             };
             yield { type: 'harness_diagnostics', diagnostics: harnessDiagnostics('error') };
@@ -737,7 +759,7 @@ export async function* runQuery(userInput, options) {
             for await (const ev of chatFn({
                 provider,
                 messages: modelMessages,
-                tools: currentEffectiveToolSet.tools,
+                tools: toolsForResponsePhase(currentEffectiveToolSet.tools, 'preparation'),
                 signal,
                 conversationMode: runtimeContext.conversationMode ?? 'private',
                 promptCache: options.promptCache,
@@ -896,6 +918,16 @@ export async function* runQuery(userInput, options) {
                 function: { name: 'Advisor', arguments: JSON.stringify(pendingReview) } });
             assistantText = '';
         }
+        // Count the calls that survived review scheduling, including failed loads.
+        for (const call of toolCallsByIndex) {
+            if (call.function.name !== 'Skill')
+                continue;
+            try {
+                if (JSON.parse(call.function.arguments).name === 'dynamic-ui')
+                    diagramPreparationAttempted = true;
+            }
+            catch { /* Ordinary tool validation reports malformed arguments. */ }
+        }
         const assistantMsg = {
             role: 'assistant',
             content: assistantText.length > 0 ? assistantText : null,
@@ -909,6 +941,20 @@ export async function* runQuery(userInput, options) {
         };
         // 4. 没有工具调用 → 整轮交互结束
         finalResponse: if (toolCallsByIndex.length === 0) {
+            // Repair only private preparation, through the ordinary tool pipeline.
+            // One attempt per turn, including missing/failed skills; never rewind a reply.
+            if (!diagramPreparationAttempted && !options.responseFormat
+                && runtimeContext.profile === 'main' && output.diagrams.length > 0
+                && currentEffectiveToolSet.names.has('Skill') && turn < maxTurns
+                && needsDiagramPreparation(assistantText, userInput)) {
+                diagramPreparationAttempted = true;
+                toolCallsByIndex.push({ id: crypto.randomUUID(), type: 'function', function: {
+                        name: 'Skill', arguments: JSON.stringify({ name: 'dynamic-ui' }),
+                    } });
+                assistantMsg.content = null;
+                assistantMsg.tool_calls = toolCallsByIndex;
+                break finalResponse;
+            }
             if (!askCorrectionAttempted && runtimeContext.interactiveAsk
                 && currentEffectiveToolSet.names.has('AskUserQuestion')
                 && needsInteractiveQuestion(stripThinkBlocks(assistantText)) && turn < maxTurns) {
@@ -968,8 +1014,19 @@ export async function* runQuery(userInput, options) {
                     yield { type: 'warning', message: '已达到本轮执行上限，顾问交付检查尚未完成；不能把此次输出视为已复核。' };
             }
             if (emptyResponse) {
-                // A no-tool response is already the model's terminal signal. Do not turn it
-                // into another model round, and do not persist/broadcast an empty bubble.
+                // Recover once within the existing turn budget, retaining tool receipts and
+                // advisor state. Never replay tools or expose an empty candidate as an answer.
+                if (!resultPresented && !emptyResponseRecoveryAttempted && turn < maxTurns) {
+                    emptyResponseRecoveryAttempted = true;
+                    emptyResponseRecoveryReason = lastFinishReason === 'length'
+                        ? '输出额度耗尽' : lastFinishReason === 'unknown'
+                        ? '响应流缺少正常结束状态' : '响应为空或仅含思考内容';
+                    const message = { role: 'system', content: '正在恢复回答，已保留调查结果与工作进展。',
+                        id: crypto.randomUUID(), timestamp: Date.now(), _ephemeral: true, _uiProgress: true };
+                    history.push(message);
+                    yield { type: 'injected_message', message };
+                    continue;
+                }
                 yield* retireDraft('empty_response');
             }
             else {
@@ -979,14 +1036,14 @@ export async function* runQuery(userInput, options) {
                 let publicationInterrupted = false;
                 let streamed = false;
                 if (!options.responseFormat && runtimeContext.profile === 'main'
-                    && (runtimeContext.surface === 'desktop' || runtimeContext.surface === 'tui')) {
+                    && output.finalDelivery === 'stream') {
                     const candidate = assistantText;
                     const candidateFinishReason = lastFinishReason;
                     let publishedText = '';
                     let publicationDone = false;
                     yield { type: 'stage_change', stage: 'streaming' };
                     try {
-                        const publicationMessages = finalAnswerMessages(buildModelMessages(history, requestTransientContext, userMessage.id), assistantText);
+                        const publicationMessages = finalAnswerMessages(buildModelMessages(history, requestTransientContext, userMessage.id), assistantText, output);
                         const publicationPlan = buildContextBudgetPlan({ provider, history: publicationMessages, tools: [] });
                         if (publicationPlan.overBudget)
                             throw new Error('最终表达上下文超过模型输入上限，未发送请求。');
@@ -998,7 +1055,7 @@ export async function* runQuery(userInput, options) {
                         for await (const event of chatFn({
                             provider,
                             messages: publicationMessages,
-                            tools: [], signal,
+                            tools: toolsForResponsePhase(currentEffectiveToolSet.tools, 'publication'), signal,
                             conversationMode: runtimeContext.conversationMode ?? 'private',
                             promptCache: options.promptCache,
                         })) {
@@ -1015,11 +1072,8 @@ export async function* runQuery(userInput, options) {
                                 break;
                             }
                             if (event.type === 'text_delta') {
-                                // Never expose a rewrite of the reviewed candidate. Previously
-                                // published chunks are necessarily an exact prefix of it.
-                                if (!candidate.startsWith(publishedText + event.delta)) {
-                                    throw new Error('发布内容偏离定稿，使用原定稿。');
-                                }
+                                // Final expression is live generation, not an exact-copy replay.
+                                // Once visible, text is never replaced or joined with a different draft.
                                 publishedText += event.delta;
                                 streamed = true;
                                 yield { type: 'text', delta: event.delta };
@@ -1040,26 +1094,20 @@ export async function* runQuery(userInput, options) {
                             throw new Error('最终答案流缺少有效的结束状态。');
                         if (!publishedText.trim() && !publicationInterrupted)
                             throw new Error('最终表达未返回正文。');
-                        if (!publicationInterrupted && publishedText !== candidate)
-                            throw new Error('最终表达未完整传递定稿。');
                     }
                     catch (error) {
                         publicationInterrupted ||= signal?.aborted === true || options.hasQueuedInput?.() === true || error?.name === 'AbortError';
                         publicationError = error;
                     }
-                    if (publicationError && !publicationInterrupted) {
-                        yield { type: 'warning', message: '流式发布未完成，已使用原定稿补齐；未重新生成或改写答案。' };
-                        const remaining = candidate.slice(publishedText.length);
-                        if (remaining) {
-                            yield { type: 'text', delta: remaining };
-                            streamed = true;
-                        }
+                    if (publicationError && !publicationInterrupted && !publishedText) {
+                        yield { type: 'warning', message: '最终回答流未能开始，已一次性显示内部准备的答案；未进行新的事实核验。' };
+                        yield { type: 'text', delta: candidate };
+                        streamed = true;
                         publishedText = candidate;
+                        lastFinishReason = candidateFinishReason;
                         publicationError = undefined;
                     }
                     assistantText = publishedText;
-                    if (!publicationInterrupted)
-                        lastFinishReason = candidateFinishReason;
                     assistantMsg.content = publishedText || null;
                     if (!publishedText) {
                         if (publicationInterrupted)
@@ -1140,7 +1188,9 @@ export async function* runQuery(userInput, options) {
                 trustworthy: turnUsage.totalCalls > 0 && turnUsage.reportedCalls === turnUsage.totalCalls,
             };
             if (emptyResponse && !resultPresented) {
-                const warning = '本轮未生成最终答复，已有进展已保留。可以重试上一回合。';
+                const warning = emptyResponseRecoveryAttempted
+                    ? '自动恢复后仍未生成最终答复，已有进展已保留。可以继续本轮或检查模型服务。'
+                    : '本轮未生成最终答复，已有进展已保留。可以重试上一回合。';
                 yield { type: 'warning', message: warning };
                 yield { type: 'turn_done', completionStatus: 'no_answer', warning, usage };
             }

package/src/loop.ts

@@ -30,6 +30,8 @@
 import crypto from 'node:crypto';
 import { answerPreparationNotice } from './runtime/answerPreparation.js';
 import { finalAnswerMessages } from './runtime/finalAnswer.js';
+import { resolveOutputContract, toolsForResponsePhase } from './runtime/outputContract.js';
+import { needsDiagramPreparation, visualPresentation } from './prompts/visualPresentation.js';
 import { createLifecycleTrace } from './runtime/lifecycleTrace.js';
 import { conciseToolPath } from './runtime/toolDisplay.js';
 import { dirname, resolve } from 'node:path';
@@ -111,6 +113,7 @@ import {
 import { stripThinkBlocks } from './utils/stripThink.js';
 import { orderedPool } from './runtime/orderedPool.js';
 import { takeAgentNotifications, agentCoordinationContext } from './tools/agent/agentTaskService.js';
+import { delegationRuntimeGuidance } from './prompts/delegation.js';
 import { executionSegments } from './tools/executionSegments.js';
 import { acquireSubagentLease, normalizeWriteScopes } from './tools/agent/coordinator.js';
 
@@ -447,7 +450,11 @@ export async function* runQuery(
   let resultPresented = false;
   let presentedResultUnverified = false;
   let deliveryCorrectionAttempted = false;
+  let emptyResponseRecoveryAttempted = false;
+  let emptyResponseRecoveryReason = '';
   let askCorrectionAttempted = false;
+  let diagramPreparationAttempted = false;
+  const output = resolveOutputContract(runtimeContext.surface, runtimeContext.output);
   const subagents = await configService.subagents();
   await hydrateSessionWorktree({
     sessionState,
@@ -456,6 +463,8 @@ export async function* runQuery(
     cwd: runtimeContext.cwd,
   });
   const toolCallContext: ToolCallContext = {
+    output,
+    availableToolNames: () => currentEffectiveToolSet.names,
     executionServices: { ...options.executionServices, executeTool: executeToolFn, chat: chatFn, invocationPolicy: options.invocationPolicy },
     history,
     sessionState,
@@ -533,8 +542,13 @@ export async function* runQuery(
     const parts = [
       transientFor(activeTools),
       coordinationText,
+      delegationRuntimeGuidance({ available: runtimeContext.profile === 'main' && currentEffectiveToolSet.names.has('Agent'),
+        maxConcurrent: subagents.maxConcurrent, callsUsed: toolCallContext.agentCalls?.used ?? 0,
+        maxCalls: toolCallContext.agentCalls?.max ?? 0 }),
+      diagramPreparationAttempted ? visualPresentation(output) : '',
       delegationCorrectionAttempted ? '本轮必要子任务尚未验收或接管完成。先读取结果、等待运行任务或完成接力，使用 AgentResolve 记录判断；若确实无法完成，明确报告缺口，不声称全部完成。' : '',
       askCorrectionAttempted ? '当前交互宿主支持 AskUserQuestion。若仍需用户选择或补充，请调用该工具一次只问一个问题，等待答案后继续；不要仅在正文列问后停止。若没有待决事项则正常回答，不必提问。' : '',
+      emptyResponseRecoveryAttempted ? `上一次模型响应没有可交付正文（${emptyResponseRecoveryReason}）。请基于已有历史和工具结果继续完成任务：信息充分则给出实质结论，不充分则继续必要操作或明确缺口。不要重复已经完成的调查或有副作用的操作；不要把未完成的任务说成完成。已有顾问意见继续有效，无需仅因恢复而再次咨询。` : '',
       deliveryCorrectionAttempted && !resultPresented ? DELIVERY_CORRECTION_REMINDER : '',
       advisorAvailable ? advisorCoordinator.transientReminder() : '',
       advisorAvailable
@@ -910,16 +924,24 @@ export async function* runQuery(
     advisorCoordinator.setAvailable(
       currentEffectiveToolSet.names.has('Advisor'),
     );
+    // Tool availability may change during emergency fitting. Rebuild dynamic
+    // guidance against the actual request boundary, then account for its size.
+    requestTransientContext = buildRequestTransientContext();
+    lastRequestTransientContext = requestTransientContext;
+    const finalRequestBudget = buildContextBudgetPlan({
+      provider, history, tools: currentEffectiveToolSet.tools,
+      transientContext: requestTransientContext,
+    });
     if (emergencyFit.removedNames.length > 0) {
       yield {
         type: 'warning',
         message: `当前模型窗口压力过高，本次请求临时省略工具 Schema：${emergencyFit.removedNames.join(', ')}；下一轮会重新评估并恢复。`,
       };
     }
-    if (emergencyFit.plan.overBudget) {
+    if (finalRequestBudget.overBudget) {
       yield {
         type: 'error',
-        error: `当前请求即使经过上下文降级仍需要约 ${emergencyFit.plan.totalInputTokens} tokens，超过模型输入上限 ${emergencyFit.plan.inputLimit}。已停止发送，避免 Provider 接收必然失败的超限请求。`,
+        error: `当前请求即使经过上下文降级仍需要约 ${finalRequestBudget.totalInputTokens} tokens，超过模型输入上限 ${finalRequestBudget.inputLimit}。已停止发送，避免 Provider 接收必然失败的超限请求。`,
         code: 'context_overflow',
       };
       yield { type: 'harness_diagnostics', diagnostics: harnessDiagnostics('error') };
@@ -966,7 +988,7 @@ export async function* runQuery(
       for await (const ev of chatFn({
         provider,
         messages: modelMessages,
-        tools: currentEffectiveToolSet.tools,
+        tools: toolsForResponsePhase(currentEffectiveToolSet.tools, 'preparation'),
         signal,
         conversationMode: runtimeContext.conversationMode ?? 'private',
         promptCache: options.promptCache,
@@ -1124,6 +1146,13 @@ export async function* runQuery(
         function: { name: 'Advisor', arguments: JSON.stringify(pendingReview) } });
       assistantText = '';
     }
+    // Count the calls that survived review scheduling, including failed loads.
+    for (const call of toolCallsByIndex) {
+      if (call.function.name !== 'Skill') continue;
+      try {
+        if (JSON.parse(call.function.arguments).name === 'dynamic-ui') diagramPreparationAttempted = true;
+      } catch { /* Ordinary tool validation reports malformed arguments. */ }
+    }
     const assistantMsg: Message = {
       role: 'assistant',
       content: assistantText.length > 0 ? assistantText : null,
@@ -1137,6 +1166,20 @@ export async function* runQuery(
     };
     // 4. 没有工具调用 → 整轮交互结束
     finalResponse: if (toolCallsByIndex.length === 0) {
+      // Repair only private preparation, through the ordinary tool pipeline.
+      // One attempt per turn, including missing/failed skills; never rewind a reply.
+      if (!diagramPreparationAttempted && !options.responseFormat
+        && runtimeContext.profile === 'main' && output.diagrams.length > 0
+        && currentEffectiveToolSet.names.has('Skill') && turn < maxTurns
+        && needsDiagramPreparation(assistantText, userInput)) {
+        diagramPreparationAttempted = true;
+        toolCallsByIndex.push({ id: crypto.randomUUID(), type: 'function', function: {
+          name: 'Skill', arguments: JSON.stringify({ name: 'dynamic-ui' }),
+        } });
+        assistantMsg.content = null;
+        assistantMsg.tool_calls = toolCallsByIndex;
+        break finalResponse;
+      }
       if (!askCorrectionAttempted && runtimeContext.interactiveAsk
         && currentEffectiveToolSet.names.has('AskUserQuestion')
         && needsInteractiveQuestion(stripThinkBlocks(assistantText)) && turn < maxTurns) {
@@ -1196,8 +1239,19 @@ export async function* runQuery(
         if (!deliveryCheckpoint.allow) yield { type: 'warning', message: '已达到本轮执行上限，顾问交付检查尚未完成；不能把此次输出视为已复核。' };
       }
       if (emptyResponse) {
-        // A no-tool response is already the model's terminal signal. Do not turn it
-        // into another model round, and do not persist/broadcast an empty bubble.
+        // Recover once within the existing turn budget, retaining tool receipts and
+        // advisor state. Never replay tools or expose an empty candidate as an answer.
+        if (!resultPresented && !emptyResponseRecoveryAttempted && turn < maxTurns) {
+          emptyResponseRecoveryAttempted = true;
+          emptyResponseRecoveryReason = lastFinishReason === 'length'
+            ? '输出额度耗尽' : lastFinishReason === 'unknown'
+              ? '响应流缺少正常结束状态' : '响应为空或仅含思考内容';
+          const message: Message = { role: 'system', content: '正在恢复回答，已保留调查结果与工作进展。',
+            id: crypto.randomUUID(), timestamp: Date.now(), _ephemeral: true, _uiProgress: true };
+          history.push(message);
+          yield { type: 'injected_message', message };
+          continue;
+        }
         yield* retireDraft('empty_response');
       } else {
         // Publication is a separate tool-free request. Nothing from preparation
@@ -1206,14 +1260,14 @@ export async function* runQuery(
         let publicationInterrupted = false;
         let streamed = false;
         if (!options.responseFormat && runtimeContext.profile === 'main'
-          && (runtimeContext.surface === 'desktop' || runtimeContext.surface === 'tui')) {
+          && output.finalDelivery === 'stream') {
           const candidate = assistantText;
           const candidateFinishReason = lastFinishReason;
           let publishedText = '';
           let publicationDone = false;
           yield { type: 'stage_change', stage: 'streaming' };
           try {
-            const publicationMessages = finalAnswerMessages(buildModelMessages(history, requestTransientContext, userMessage.id), assistantText);
+            const publicationMessages = finalAnswerMessages(buildModelMessages(history, requestTransientContext, userMessage.id), assistantText, output);
             const publicationPlan = buildContextBudgetPlan({ provider, history: publicationMessages, tools: [] });
             if (publicationPlan.overBudget) throw new Error('最终表达上下文超过模型输入上限，未发送请求。');
             if (signal?.aborted || options.hasQueuedInput?.()) {
@@ -1224,7 +1278,7 @@ export async function* runQuery(
             for await (const event of chatFn({
               provider,
               messages: publicationMessages,
-              tools: [], signal,
+              tools: toolsForResponsePhase(currentEffectiveToolSet.tools, 'publication'), signal,
               conversationMode: runtimeContext.conversationMode ?? 'private',
               promptCache: options.promptCache,
             })) {
@@ -1241,11 +1295,8 @@ export async function* runQuery(
                 break;
               }
               if (event.type === 'text_delta') {
-                // Never expose a rewrite of the reviewed candidate. Previously
-                // published chunks are necessarily an exact prefix of it.
-                if (!candidate.startsWith(publishedText + event.delta)) {
-                  throw new Error('发布内容偏离定稿，使用原定稿。');
-                }
+                // Final expression is live generation, not an exact-copy replay.
+                // Once visible, text is never replaced or joined with a different draft.
                 publishedText += event.delta;
                 streamed = true;
                 yield { type: 'text', delta: event.delta };
@@ -1260,23 +1311,19 @@ export async function* runQuery(
             if (!publicationDone && !publicationInterrupted) throw new Error('最终答案流未正常结束。');
             if (!publicationInterrupted && lastFinishReason !== 'stop' && lastFinishReason !== 'length') throw new Error('最终答案流缺少有效的结束状态。');
             if (!publishedText.trim() && !publicationInterrupted) throw new Error('最终表达未返回正文。');
-            if (!publicationInterrupted && publishedText !== candidate) throw new Error('最终表达未完整传递定稿。');
           } catch (error) {
             publicationInterrupted ||= signal?.aborted === true || options.hasQueuedInput?.() === true || (error as Error)?.name === 'AbortError';
             publicationError = error;
           }
-          if (publicationError && !publicationInterrupted) {
-            yield { type: 'warning', message: '流式发布未完成，已使用原定稿补齐；未重新生成或改写答案。' };
-            const remaining = candidate.slice(publishedText.length);
-            if (remaining) {
-              yield { type: 'text', delta: remaining };
-              streamed = true;
-            }
+          if (publicationError && !publicationInterrupted && !publishedText) {
+            yield { type: 'warning', message: '最终回答流未能开始，已一次性显示内部准备的答案；未进行新的事实核验。' };
+            yield { type: 'text', delta: candidate };
+            streamed = true;
             publishedText = candidate;
+            lastFinishReason = candidateFinishReason;
             publicationError = undefined;
           }
           assistantText = publishedText;
-          if (!publicationInterrupted) lastFinishReason = candidateFinishReason;
           assistantMsg.content = publishedText || null;
           if (!publishedText) {
             if (publicationInterrupted) yield { ...interruption(), usage: { ...turnUsage, trustworthy: turnUsage.totalCalls > 0 && turnUsage.reportedCalls === turnUsage.totalCalls } };
@@ -1354,7 +1401,9 @@ export async function* runQuery(
         trustworthy: turnUsage.totalCalls > 0 && turnUsage.reportedCalls === turnUsage.totalCalls,
       };
       if (emptyResponse && !resultPresented) {
-        const warning = '本轮未生成最终答复，已有进展已保留。可以重试上一回合。';
+        const warning = emptyResponseRecoveryAttempted
+          ? '自动恢复后仍未生成最终答复，已有进展已保留。可以继续本轮或检查模型服务。'
+          : '本轮未生成最终答复，已有进展已保留。可以重试上一回合。';
         yield { type: 'warning', message: warning };
         yield { type: 'turn_done', completionStatus: 'no_answer', warning, usage };
       } else if (pendingDelegations.length) {

package/src/memory/factLearning.js

@@ -2,7 +2,7 @@
  * its source material. A durable receipt makes retries idempotent. */
 import { readFile } from 'node:fs/promises';
 import { parseMemoryProposal } from './proposal.js';
-import { failureSchema, jobEligible, recordJobFailure, reportLearningFailure } from './jobPolicy.js';
+import { failureSchema, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
 import { join } from 'node:path';
 import lockfile from 'proper-lockfile';
 import { z } from 'zod';
@@ -437,7 +437,7 @@ export function scheduleFactLearning(options) {
     void runFactLearning(options)
         .catch((error) => {
         if (!options.signal?.aborted)
-            reportLearningFailure(directory(options.workspaceId));
+            recordBackgroundLearningFailure(options.workspaceId, 'facts', 'learning');
     })
         .finally(async () => {
         const settings = await memoryService.settings();
@@ -453,7 +453,7 @@ export function scheduleFactLearning(options) {
         if (pending.length)
             wakeAt(directory(options.workspaceId), Math.max(Date.now() + 1000, Math.min(...pending.map((turn) => turn.nextAttemptAt ?? Date.now()))), () => scheduleFactLearning({ ...options, force: false }), options.signal);
     })
-        .catch((error) => process.stderr.write(`[minimal-agent memory] 恢复调度失败：${error.message}\n`));
+        .catch(() => recordBackgroundLearningFailure(options.workspaceId, 'facts', 'scheduling'));
 }
 export async function drainFactLearning() {
     await Promise.allSettled([...running.values()].map((task) => task.promise));

package/src/memory/factLearning.ts

@@ -2,7 +2,7 @@
  * its source material. A durable receipt makes retries idempotent. */
 import { readFile } from 'node:fs/promises';
 import { parseMemoryProposal } from './proposal.js';
-import { failureSchema, jobEligible, recordJobFailure, reportLearningFailure } from './jobPolicy.js';
+import { failureSchema, jobEligible, recordJobFailure, recordBackgroundLearningFailure } from './jobPolicy.js';
 import { join } from 'node:path';
 import lockfile from 'proper-lockfile';
 import { z } from 'zod';
@@ -574,7 +574,7 @@ export function scheduleFactLearning(
   void runFactLearning(options)
     .catch((error) => {
       if (!options.signal?.aborted)
-        reportLearningFailure(directory(options.workspaceId));
+        recordBackgroundLearningFailure(options.workspaceId, 'facts', 'learning');
     })
     .finally(async () => {
       const settings = await memoryService.settings();
@@ -604,11 +604,7 @@ export function scheduleFactLearning(
           options.signal,
         );
     })
-    .catch((error) =>
-      process.stderr.write(
-        `[minimal-agent memory] 恢复调度失败：${error.message}\n`,
-      ),
-    );
+    .catch(() => recordBackgroundLearningFailure(options.workspaceId, 'facts', 'scheduling'));
 }
 export async function drainFactLearning() {
   await Promise.allSettled([...running.values()].map((task) => task.promise));

package/src/memory/fileStore.js

@@ -1,12 +1,9 @@
 import { randomUUID } from 'node:crypto';
-import lockfile from 'proper-lockfile';
 import { chmod, mkdir, open, readFile, rename, rm, stat, } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
+import { acquireStateFileLock } from '../runtime/fileLock.js';
 import { agentStateDir } from '../context/agentHome.js';
 import { CATEGORY_DIR, MEMORY_ID_PATTERN } from './constants.js';
-const LOCK_STALE_MS = 120_000;
-const LOCK_WAIT_MS = 15_000;
 let mutationQueue = Promise.resolve();
 export function memoryRootDir() {
     return join(agentStateDir(), 'memory');
@@ -54,36 +51,7 @@ export async function pathExists(path) {
 export async function acquireFileLock(path, signal) {
     signal?.throwIfAborted();
     await ensurePrivateDir(dirname(path));
-    const deadline = Date.now() + LOCK_WAIT_MS;
-    while (true) {
-        signal?.throwIfAborted();
-        try {
-            // Do not steal old-version file locks. Restart old hosts before upgrading;
-            // their locks must be reviewed rather than aged out under a live writer.
-            const legacy = await stat(`${path}.lock`).catch(error => {
-                if (error.code === 'ENOENT')
-                    return null;
-                throw error;
-            });
-            if (legacy?.isFile())
-                throw new Error('MEMORY_LEGACY_LOCK：请停止旧版本宿主并检查遗留记忆锁');
-            const release = await lockfile.lock(path, {
-                realpath: false, retries: 0, stale: LOCK_STALE_MS, update: 10_000,
-            });
-            if (signal?.aborted) {
-                await release();
-                signal.throwIfAborted();
-            }
-            return release;
-        }
-        catch (error) {
-            if (error.code !== 'ELOCKED')
-                throw error;
-            if (Date.now() >= deadline)
-                throw new Error('等待记忆文件锁超时');
-            await delay(40, undefined, { signal });
-        }
-    }
+    return acquireStateFileLock(path, { signal, label: 'MEMORY' });
 }
 export async function atomicWriteFile(path, content) {
     await ensurePrivateDir(dirname(path));