minimal-agent 0.18.5 → 0.18.7

package/src/loop.ts

@@ -28,6 +28,9 @@
  */
 
 import crypto from 'node:crypto';
+import { answerPreparationNotice } from './runtime/answerPreparation.js';
+import { finalAnswerMessages } from './runtime/finalAnswer.js';
+import { createLifecycleTrace } from './runtime/lifecycleTrace.js';
 import { conciseToolPath } from './runtime/toolDisplay.js';
 import { dirname, resolve } from 'node:path';
 import { loadProjectPromptInstructions } from './prompts/projectInstructions.js';
@@ -100,6 +103,7 @@ import {
 } from './advisor/advisorCoordinator.js';
 import { toolEffectFor } from './tools/capabilities.js';
 import { isReadOnlyShellCommand, isVerificationShellCommand } from './tools/bash/semantics.js';
+import { collectReviewContext } from './advisor/reviewContext.js';
 import {
   createAgentRuntimeContext,
   type AgentRuntimeContext,
@@ -410,11 +414,13 @@ export async function* runQuery(
   if (!computerIntent.needed && sessionState) delete sessionState.computerAutomation;
   // DI fallback：测试可传 stub，生产走真实模块单例
   const chatFn = options.chat ?? defaultChat;
+  const trace = createLifecycleTrace('loop');
   const executeToolFn = options.executeTool ?? defaultExecuteTool;
   const explicitFileDeliveryRequested = expectsFormalDelivery(userInput);
   const currentUserMessageId = options.userMessageId ?? crypto.randomUUID();
 
   let currentTransientBundle = options.transientBundle;
+  let advisorContextBundle = currentTransientBundle;
   let modelEnvironmentCwd = runtimeContext.cwd;
   const observedRuleScopes = new Map<string, string>();
   const pendingRuleScopes = new Set<string>();
@@ -435,6 +441,7 @@ export async function* runQuery(
     const selected = availableForBundle >= bundle.diagnostics.usedTokens
       ? bundle
       : resizeContextBundle(bundle, availableForBundle);
+    advisorContextBundle = selected;
     return [selected.text, opaque].filter(Boolean).join('\n\n');
   };
   let resultPresented = false;
@@ -452,6 +459,16 @@ export async function* runQuery(
     executionServices: { ...options.executionServices, executeTool: executeToolFn, chat: chatFn, invocationPolicy: options.invocationPolicy },
     history,
     sessionState,
+    advisorReviewContext: () => ({
+      ...collectReviewContext(advisorContextBundle),
+      constraints: [...collectReviewContext(advisorContextBundle).constraints,
+        { id: 'execution.boundary', authority: 'host', content: JSON.stringify({ cwd: sessionState?.activeWorktree?.path ?? toolCallContext.cwd,
+          conversationMode: toolCallContext.conversationMode, profile: runtimeContext.profile,
+          availableTools: [...currentEffectiveToolSet.names], invocation: invocationInstructions(options.invocationPolicy) }) }],
+      omittedIds: [...new Set([...(currentTransientBundle?.diagnostics.omittedIds ?? []), ...(advisorContextBundle?.diagnostics.omittedIds ?? [])]),
+        ...(options.transientContext ? ['legacy.transient-context:not-forwarded'] : [])],
+      clippedIds: [...new Set([...(currentTransientBundle?.diagnostics.clippedIds ?? []), ...(advisorContextBundle?.diagnostics.clippedIds ?? [])])],
+    }),
     // Statistics only; consultations have no per-turn quota.
     advisorCalls: { used: 0 },
     advisorInvocation: 'agent',
@@ -910,7 +927,17 @@ export async function* runQuery(
     }
 
     // 3. 调 LLM 并组装 assistant 消息
+    trace('model_start');
     let assistantText = '';
+    // Candidate text is private until the delivery gates allow publication.
+    // Keep the compatibility event as a phase notice, never as a text retraction.
+    function* retireDraft(reason: Extract<LoopEvent, { type: 'assistant_draft_discarded' }>['reason'] | 'interrupted'): Generator<LoopEvent> {
+      const message: Message = { role: 'system', content: answerPreparationNotice(reason), id: crypto.randomUUID(),
+        timestamp: Date.now(), _ephemeral: true, _uiProgress: true };
+      history.push(message);
+      yield { type: 'injected_message', message };
+      if (reason !== 'interrupted') yield { type: 'assistant_draft_discarded', reason, textLength: 0 };
+    }
     /** 按 index 累积 tool_calls（OpenAI 协议下 tool_calls 是分片返回的） */
     const toolCallsByIndex: ToolCall[] = [];
     /**
@@ -921,9 +948,6 @@ export async function* runQuery(
     let reasoningString = '';
     const reasoningDetails: unknown[] = [];
 
-    /** 首个 text_delta 时切到 streaming，再来不重复 yield */
-    let stageStreamingYielded = false;
-
     /**
      * R2：本轮 LLM 流的终止原因（来自 client 的 done.stopReason）。
      * 'length' = 被 provider 因 max_tokens 截断 —— 收尾时据此给 warning，
@@ -956,12 +980,7 @@ export async function* runQuery(
           : {}),
       })) {
         if (ev.type === 'text_delta') {
-          if (!stageStreamingYielded) {
-            stageStreamingYielded = true;
-            yield { type: 'stage_change', stage: 'streaming' };
-          }
           assistantText += ev.delta;
-          yield { type: 'text', delta: ev.delta };
         } else if (ev.type === 'tool_call_delta') {
           mergeToolCallDelta(toolCallsByIndex, ev);
         } else if (ev.type === 'reasoning_delta') {
@@ -1002,7 +1021,9 @@ export async function* runQuery(
         }
       }
     } catch (e) {
+      trace('model_error');
       if ((e as Error).name === 'AbortError') {
+        yield* retireDraft('interrupted');
         yield interruption();
         return;
       }
@@ -1026,6 +1047,7 @@ export async function* runQuery(
             options.promptCache,
           );
         } catch (error) {
+          yield* retireDraft('interrupted');
           if (signal?.aborted || (error as Error).name === 'AbortError') {
             yield interruption();
             return;
@@ -1057,6 +1079,7 @@ export async function* runQuery(
       }
 
       // code='llm_error'：终结性错误，stop_reason='error'
+      yield* retireDraft('interrupted');
       yield {
         type: 'error',
         error: `LLM 调用失败：${(e as Error).message}`,
@@ -1065,7 +1088,9 @@ export async function* runQuery(
       return;
     }
 
+    trace('model_end');
     if (lastFinishReason === 'aborted' || signal?.aborted || options.hasQueuedInput?.()) {
+      yield* retireDraft('interrupted');
       if (options.hasQueuedInput?.() && !signal?.aborted) {
         pushQueuedInputMarker(history);
         yield { type: 'interrupted', reason: 'queued_input' };
@@ -1086,6 +1111,19 @@ export async function* runQuery(
       }
     }
 
+    // A pending review must run before another solving/publishing attempt.
+    // Read-only diagnosis and human questions remain available while stalled.
+    const pendingReview = options.advisorCheckpoints === false ? undefined : advisorCoordinator.pendingReview();
+    if (pendingReview && turn < maxTurns && toolCallsByIndex.length > 0
+      && !toolCallsByIndex.some(tc => ['Advisor', 'AskUserQuestion'].includes(tc.function.name))
+      && toolCallsByIndex.some(tc => tc.function.name === 'PresentResult'
+        || advisorSemanticsFor(tc, toolCallContext, currentEffectiveToolSet.tools.find(t => t.name === tc.function.name), { treatVerificationAsReadOnly: true }).mutatesWorkspace
+        || stallGuard.shouldReject(tc))) {
+      yield* retireDraft('advisor_checkpoint');
+      toolCallsByIndex.splice(0, toolCallsByIndex.length, { id: crypto.randomUUID(), type: 'function',
+        function: { name: 'Advisor', arguments: JSON.stringify(pendingReview) } });
+      assistantText = '';
+    }
     const assistantMsg: Message = {
       role: 'assistant',
       content: assistantText.length > 0 ? assistantText : null,
@@ -1098,12 +1136,12 @@ export async function* runQuery(
       ...(options.messageProvenance ? { provenance: options.messageProvenance } : {}),
     };
     // 4. 没有工具调用 → 整轮交互结束
-    if (toolCallsByIndex.length === 0) {
+    finalResponse: if (toolCallsByIndex.length === 0) {
       if (!askCorrectionAttempted && runtimeContext.interactiveAsk
         && currentEffectiveToolSet.names.has('AskUserQuestion')
         && needsInteractiveQuestion(stripThinkBlocks(assistantText)) && turn < maxTurns) {
         askCorrectionAttempted = true;
-        yield { type: 'assistant_draft_discarded', reason: 'interactive_question', textLength: assistantText.length };
+        yield* retireDraft('interactive_question');
         continue;
       }
       const emptyResponse = stripThinkBlocks(assistantText).length === 0;
@@ -1112,12 +1150,11 @@ export async function* runQuery(
       if (pendingDelegations.length && !delegationCorrectionAttempted && turn < maxTurns) {
         delegationCorrectionAttempted = true;
         coordinationText = coordination!.text;
-        yield { type: 'assistant_draft_discarded', reason: 'formal_delivery', textLength: assistantText.length };
+        yield* retireDraft('formal_delivery');
         continue;
       }
       const pendingMessages = [...(options.takePendingMessages?.() ?? []), ...await takeAgentNotifications(toolCallContext)];
       if (pendingMessages.length) {
-        if (!emptyResponse) history.push(assistantMsg);
         history.push(...pendingMessages);
         continue;
       }
@@ -1131,22 +1168,27 @@ export async function* runQuery(
         && turn < maxTurns
       ) {
         deliveryCorrectionAttempted = true;
-        yield {
-          type: 'assistant_draft_discarded',
-          reason: 'formal_delivery',
-          textLength: assistantText.length,
-        };
+        yield* retireDraft('formal_delivery');
         continue;
       }
-      const deliveryCheckpoint = emptyResponse
+      const deliveryCheckpoint = emptyResponse || options.advisorCheckpoints === false
         ? { allow: true as const }
         : advisorCoordinator.beforeDelivery(assistantText);
+      const fallbackReview = !emptyResponse && options.advisorCheckpoints !== false
+        ? advisorCoordinator.pendingReview(assistantText) : undefined;
+      if (fallbackReview && turn < maxTurns) {
+        yield* retireDraft('advisor_checkpoint');
+        // Reuse the effective tool boundary, permissions, cancellation, events and
+        // persistence. Never call a provider behind the host's tool pipeline.
+        toolCallsByIndex.push({ id: crypto.randomUUID(), type: 'function', function: {
+          name: 'Advisor', arguments: JSON.stringify(fallbackReview),
+        } });
+        assistantMsg.content = null;
+        assistantMsg.tool_calls = toolCallsByIndex;
+        break finalResponse;
+      }
       if (!deliveryCheckpoint.allow && turn < maxTurns) {
-        yield {
-          type: 'assistant_draft_discarded',
-          reason: 'advisor_checkpoint',
-          textLength: assistantText.length,
-        };
+        yield* retireDraft('advisor_checkpoint');
         continue;
       }
       if (!emptyResponse) {
@@ -1156,19 +1198,110 @@ export async function* runQuery(
       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.
-        yield {
-          type: 'assistant_draft_discarded',
-          reason: 'empty_response',
-          textLength: assistantText.length,
-        };
+        yield* retireDraft('empty_response');
       } else {
+        // Publication is a separate tool-free request. Nothing from preparation
+        // has been streamed, and no gate may retract text after this boundary.
+        let publicationError: unknown;
+        let publicationInterrupted = false;
+        let streamed = false;
+        if (!options.responseFormat && runtimeContext.profile === 'main'
+          && (runtimeContext.surface === 'desktop' || runtimeContext.surface === 'tui')) {
+          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 publicationPlan = buildContextBudgetPlan({ provider, history: publicationMessages, tools: [] });
+            if (publicationPlan.overBudget) throw new Error('最终表达上下文超过模型输入上限，未发送请求。');
+            if (signal?.aborted || options.hasQueuedInput?.()) {
+              publicationInterrupted = true;
+              throw new Error('最终发布已取消。');
+            }
+            turnUsage.totalCalls += 1;
+            for await (const event of chatFn({
+              provider,
+              messages: publicationMessages,
+              tools: [], signal,
+              conversationMode: runtimeContext.conversationMode ?? 'private',
+              promptCache: options.promptCache,
+            })) {
+              if (event.type === 'done' && !publicationDone) {
+                publicationDone = true;
+                if (typeof event.promptTokens === 'number' || typeof event.outputTokens === 'number') {
+                  turnUsage.reportedCalls += 1;
+                  turnUsage.inputTokens += event.promptTokens ?? 0;
+                  turnUsage.outputTokens += event.outputTokens ?? 0;
+                }
+              }
+              if (signal?.aborted || options.hasQueuedInput?.()) {
+                publicationInterrupted = true;
+                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('发布内容偏离定稿，使用原定稿。');
+                }
+                publishedText += event.delta;
+                streamed = true;
+                yield { type: 'text', delta: event.delta };
+              } else if (event.type === 'tool_call_delta') {
+                throw new Error('最终表达阶段返回了非预期工具调用，未执行该工具。');
+              } else if (event.type === 'done') {
+                publicationDone = true;
+                lastFinishReason = event.stopReason;
+                if (event.stopReason === 'aborted') publicationInterrupted = true;
+              }
+            }
+            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;
+            }
+            publishedText = candidate;
+            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 } };
+            else yield { type: 'error', code: 'llm_error', error: `最终答案生成失败：${String(publicationError)}`, usage: { ...turnUsage, trustworthy: turnUsage.totalCalls > 0 && turnUsage.reportedCalls === turnUsage.totalCalls } };
+            return;
+          }
+        }
+        assistantMsg.presentation = 'final';
+        trace('final_published');
         if (assistantMsg.role === 'assistant') assistantMsg.advisorTaskVersion = advisorCoordinator.versions.taskVersion;
         assistantMsg.advisorCheckpoints = advisorCoordinator.drainDegradations();
         history.push(assistantMsg);
+        // Non-interactive consumers retain atomic output. Interactive hosts
+        // already received real deltas; commit the identical text only once.
+        if (!streamed) yield { type: 'text', delta: assistantText };
         yield {
           type: 'assistant_message',
           message: assistantMsg as Extract<Message, { role: 'assistant' }>,
         };
+        if (publicationInterrupted || publicationError) {
+          yield { type: 'warning', message: '最终答案未完整生成，已保留已输出内容；未撤回或重新生成。' };
+          if (publicationInterrupted) yield { ...interruption(), usage: { ...turnUsage, trustworthy: turnUsage.totalCalls > 0 && turnUsage.reportedCalls === turnUsage.totalCalls } };
+          else yield { type: 'error', code: 'llm_error', error: `最终答案流中断：${String(publicationError)}`, usage: { ...turnUsage, trustworthy: turnUsage.totalCalls > 0 && turnUsage.reportedCalls === turnUsage.totalCalls } };
+          return;
+        }
       }
       // R2：最终回答被 provider 因 max_tokens 截断（finish_reason='length'）时，
       // 不能静默当正常 end_turn 收尾 —— 否则 -p 宿主会拿到半截答案却以为成功。
@@ -1220,7 +1353,11 @@ export async function* runQuery(
         ...turnUsage,
         trustworthy: turnUsage.totalCalls > 0 && turnUsage.reportedCalls === turnUsage.totalCalls,
       };
-      if (pendingDelegations.length) {
+      if (emptyResponse && !resultPresented) {
+        const warning = '本轮未生成最终答复，已有进展已保留。可以重试上一回合。';
+        yield { type: 'warning', message: warning };
+        yield { type: 'turn_done', completionStatus: 'no_answer', warning, usage };
+      } else if (pendingDelegations.length) {
         const warning = `必要子任务尚未收口：${pendingDelegations.map((r) => r.id).join(', ')}。本轮不能视为全部完成。`;
         yield { type: 'warning', message: warning };
         yield { type: 'turn_done', completionStatus: 'delivery_incomplete', warning, usage };
@@ -1240,11 +1377,14 @@ export async function* runQuery(
           usage,
         };
       } else {
-        yield { type: 'turn_done', completionStatus: 'completed', usage };
+        yield { type: 'turn_done', completionStatus: 'completed', usage,
+          ...(emptyResponse ? { warning: '成果已提交，未生成文字总结；请查看已提交的成果。' } : {}) };
       }
       return;
     }
 
+    assistantMsg.presentation = 'progress';
+    trace('progress_published');
     history.push(assistantMsg);
     yield {
       type: 'assistant_message',
@@ -1471,7 +1611,19 @@ export async function* runQuery(
     };
 
     const runOne: typeof runOneImpl = async (tc, reportProgress) => {
+      // Also settle denied/invalid/unavailable calls that never reached the
+      // provider adapter. This records a real attempt, not an ignored reminder.
+      let consultation;
+      if (tc.function.name === 'Advisor') {
+        let reason: import('./types.js').AdvisorReason | undefined;
+        try { reason = JSON.parse(tc.function.arguments).reason; } catch { /* validation handles malformed input */ }
+        consultation = advisorCoordinator.beginConsultation(reason);
+      }
       const outcome = await runOneImpl(tc, reportProgress);
+      if (consultation && outcome.result.metadata?.kind !== 'advisor_consultation'
+        && !( !outcome.result.ok && outcome.result.error === 'aborted')) {
+        outcome.result = { ...outcome.result, metadata: advisorCoordinator.finishConsultation(consultation, outcome.result.ok) };
+      }
       const metadata = outcome.result.metadata;
       if (metadata?.kind === 'advisor_decision' && outcome.result.ok
         || metadata?.kind === 'advisor_consultation') {
@@ -1788,6 +1940,7 @@ export function buildModelMessages(
   transientContext?: string,
   currentUserMessageId?: string,
 ): Message[] {
+  history = history.filter(message => !(message.role === 'system' && message._ephemeral));
   const transient = transientContext?.trim();
   if (!transient) return history;
   let index = currentUserMessageId

package/src/memory/experienceStore.js

@@ -673,6 +673,7 @@ export async function recallExperiences(workspaceId, query, limit = 5) {
                 item.conditions,
                 item.procedure,
             ])
+                .normalize('NFKC')
                 .toLowerCase()
                 .includes(term)
                 ? 1

package/src/memory/experienceStore.ts

@@ -848,6 +848,7 @@ export async function recallExperiences(
               item.conditions,
               item.procedure,
             ])
+              .normalize('NFKC')
               .toLowerCase()
               .includes(term)
               ? 1

package/src/memory/memoryService.js

@@ -747,7 +747,7 @@ export const memoryService = {
                     .toLowerCase()
                     .includes(term))))
             .slice(0, count(3));
-        const pushSection = (id, content, ids = []) => {
+        const pushSection = (id, content, ids = [], recordList) => {
             if (countTextTokens([...sections, content].join('\n\n')) > budget)
                 return false;
             sections.push(content);
@@ -757,6 +757,7 @@ export const memoryService = {
                 content,
                 includedIds: ids,
                 estimatedTokens: countTextTokens(content),
+                ...(recordList ? { recordList } : {}),
             });
             return true;
         };
@@ -778,7 +779,7 @@ export const memoryService = {
                     selected.push(entry);
             }
             if (selected.length)
-                pushSection(id, `${header}\n${selected.map((item) => item.text).join('\n')}`, selected.map((item) => item.id));
+                pushSection(id, `${header}\n${selected.map((item) => item.text).join('\n')}`, selected.map((item) => item.id), { header, entries: selected });
         };
         addRecords('preferences', '【响应偏好｜personal 全局，workspace 项目】当前要求优先；项目偏好仅在当前项目适用；待复核信息不作为确定约束。', preferences.map((record) => ({ id: record.id, text: describe(record) })), share(550));
         addRecords('relevant', '【相关本机记忆｜低优先级、可纠正】当前消息优先；来源见 RecallMemory。', relevant.map((record) => ({ id: record.id, text: describe(record) })), share(850));

package/src/memory/memoryService.ts

@@ -1110,6 +1110,7 @@ export const memoryService = {
       id: MemoryContextBundle['sections'][number]['id'],
       content: string,
       ids: string[] = [],
+      recordList?: MemoryContextBundle['sections'][number]['recordList'],
     ) => {
       if (countTextTokens([...sections, content].join('\n\n')) > budget)
         return false;
@@ -1120,6 +1121,7 @@ export const memoryService = {
         content,
         includedIds: ids,
         estimatedTokens: countTextTokens(content),
+        ...(recordList ? { recordList } : {}),
       });
       return true;
     };
@@ -1155,6 +1157,7 @@ export const memoryService = {
           id,
           `${header}\n${selected.map((item) => item.text).join('\n')}`,
           selected.map((item) => item.id),
+          { header, entries: selected },
         );
     };
     addRecords(

package/src/memory/projectKnowledge.js

@@ -304,6 +304,7 @@ export async function recallProjectKnowledge(workspaceId, query, limit = 5) {
                 item.applicability,
                 item.aliases,
             ])
+                .normalize('NFKC')
                 .toLowerCase()
                 .includes(term)
                 ? 1

package/src/memory/projectKnowledge.ts

@@ -434,6 +434,7 @@ export async function recallProjectKnowledge(
               item.applicability,
               item.aliases,
             ])
+              .normalize('NFKC')
               .toLowerCase()
               .includes(term)
               ? 1

package/src/memory/retrieval.js

@@ -13,10 +13,10 @@ export function isReviewDue(record, settings, now = Date.now()) {
 export function scoreMemory(record, query, settings) {
     if (record.status === 'superseded' || (record.validUntil !== undefined && record.validUntil <= Date.now()))
         return Number.NEGATIVE_INFINITY;
-    const haystack = `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.toLocaleLowerCase();
+    const haystack = `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.normalize('NFKC').toLocaleLowerCase();
     const terms = memoryTerms(query);
     const lexical = terms.reduce((sum, term) => sum + (haystack.includes(term) ? 10 : 0), 0);
-    const phrase = query.trim() && haystack.includes(query.trim().toLocaleLowerCase())
+    const phrase = query.trim() && haystack.includes(query.trim().normalize('NFKC').toLocaleLowerCase())
         ? 25
         : 0;
     const stalePenalty = isReviewDue(record, settings) || record.status === 'needs_review' ? 8 : 0;
@@ -53,10 +53,10 @@ export function recallFromSnapshot(snapshot, query, settings, limit) {
         }
         recordSearchStrategy('bm25', eligible.length);
         const bm25 = index.search(query);
-        const normalized = query.trim().toLocaleLowerCase();
+        const normalized = query.trim().normalize('NFKC').toLocaleLowerCase();
         return eligible
             .map((record) => {
-            const haystack = `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.toLocaleLowerCase();
+            const haystack = `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.normalize('NFKC').toLocaleLowerCase();
             const phrase = normalized && haystack.includes(normalized) ? 25 : 0;
             const stalePenalty = isReviewDue(record, settings) || record.status === 'needs_review' ? 8 : 0;
             return {

package/src/memory/retrieval.ts

@@ -39,14 +39,14 @@ export function scoreMemory(
 ): number {
   if (record.status === 'superseded' || (record.validUntil !== undefined && record.validUntil <= Date.now())) return Number.NEGATIVE_INFINITY;
   const haystack =
-    `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.toLocaleLowerCase();
+    `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.normalize('NFKC').toLocaleLowerCase();
   const terms = memoryTerms(query);
   const lexical = terms.reduce(
     (sum, term) => sum + (haystack.includes(term) ? 10 : 0),
     0,
   );
   const phrase =
-    query.trim() && haystack.includes(query.trim().toLocaleLowerCase())
+    query.trim() && haystack.includes(query.trim().normalize('NFKC').toLocaleLowerCase())
       ? 25
       : 0;
   const stalePenalty =
@@ -93,10 +93,10 @@ export function recallFromSnapshot(
     }
     recordSearchStrategy('bm25', eligible.length);
     const bm25 = index.search(query);
-    const normalized = query.trim().toLocaleLowerCase();
+    const normalized = query.trim().normalize('NFKC').toLocaleLowerCase();
     return eligible
       .map((record) => {
-        const haystack = `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.toLocaleLowerCase();
+        const haystack = `${record.category} ${record.subject} ${record.topicKey} ${record.aliases.join(' ')} ${record.statement}`.normalize('NFKC').toLocaleLowerCase();
         const phrase = normalized && haystack.includes(normalized) ? 25 : 0;
         const stalePenalty = isReviewDue(record, settings) || record.status === 'needs_review' ? 8 : 0;
         return {

package/src/memory/types.ts

@@ -176,6 +176,7 @@ export interface MemoryContextBundle {
     content: string;
     includedIds: string[];
     estimatedTokens: number;
+    recordList?: { header: string; entries: Array<{ id: string; text: string }> };
   }>;
 }
 

package/src/prompts/policyRegistry.js

@@ -38,8 +38,8 @@ ${toolNames.has('TaskCreate') && toolNames.has('TaskUpdate') ? '- 用户已要
         id: 'execution.communication', layer: 'execution', profiles: ['main'], source: 'native',
         render: () => `# 结果与沟通
 - 按用途选择对话答案、可编辑文件或可运行成果，不按篇幅自动建文件；要求生成成品时实际产出。
-- 每个有意义的工作步骤开始前，用一句简短正文说明当前要做什么；步骤结束或方向变化时，说明新增发现、阶段结果或阻塞，并明确下一步具体工作。工具简介由界面展示，不逐条复述工具日志，不输出私有推理。连续相关的小工具操作合并成一个步骤；不要为汇报暂停执行或向用户索要无必要确认。
-- Skill、顾问、浏览器和子 Agent 的工作也遵循同一规则：说明目的，返回后核验结果，说明采纳结论与下一步。
+- 开始执行时简述目标与近期动作；出现实质发现、阶段成果、方向变化或阻塞时更新，并说明下一步。连续相关操作合并汇报，不机械套用“工作进展/下一步”标题，不逐条复述界面已有的工具日志，不输出私有推理；没有新增信息就继续工作，不为汇报暂停执行。
+- 使用 Skill、顾问、浏览器或子 Agent 时说明其目的；返回后核验结果，只汇报影响后续行动的结论，不复述全部过程。
 - 最终答案先给明确结果；复杂任务按“完成内容 / 验证结果 / 未完成与下一步”使用 Markdown 小标题和简短列表，附相关文件或成果入口。简单问题直接回答，不强套空标题。区分已验证、失败与尚未验证，不捏造成功或百分比。代码使用带语言的代码块，比较项用表格，正文不重复粘贴全部工具输出。
 - 可视化须有助理解关系；已有成品不在正文重复。`,
     },
@@ -60,6 +60,14 @@ ${toolNames.has('TaskCreate') && toolNames.has('TaskUpdate') ? '- 用户已要
 - 不经明确授权不得 amend 提交、丢弃工作区修改或强推。Git 使用非交互命令。发现无关他人改动保留并绕开；重叠且无法确定归属时暂停相关修改并询问，不回退他人成果。
 - 测试按风险选择：修改后主动运行能证明行为的最小验证；共享协议、跨模块和用户流程改动应扩大到类型检查、相关测试或构建。不能运行时明确说明。
 - 收尾前审阅本轮 diff，清除自己产生的半成品，确认实现、测试和用户目标一致。`,
+    },
+    {
+        id: 'execution.follow-through', layer: 'execution', profiles: ['main'], source: 'native',
+        render: () => `# 推进与完成
+- 多阶段任务明确完成条件和关键路径，不把计划本身当成交付；小任务直接执行。
+- 在任务范围内持续完成实现、检查和必要返工，不因首次失败提前收尾；受阻时先推进独立工作。
+- 失败后依据回执改变方法，不原样循环或臆测环境故障；真正受外部条件阻塞时说明尝试与所需输入。
+- 完成以成果和验证证据为准，不以操作次数或投入时长为准。`,
     },
     {
         id: 'execution.interruption', layer: 'execution', profiles: ['main'], source: 'native',
@@ -185,10 +193,18 @@ const CAPABILITY_POLICIES = [
         render: ({ toolNames }) => `- 需求匹配已安装 Skill 或用户点名时，${skillInvokeInstruction(toolNames.has('Skill'))}；前端开发与交互修复也要主动匹配设计技能，不等用户说“设计”。引用资源按需读取，多阶段按需组合，不预读整个目录或加载无关技能。`,
     },
     {
-        id: 'execution.desktop-diagrams', layer: 'execution', profiles: MAIN_PROFILE, source: 'native',
-        render: ({ surface, toolNames }) => surface === 'desktop'
-            ? `- Desktop 需要架构、流程或关系图时，${toolNames.has('Skill') || toolNames.has('Read') ? '优先加载可用的 dynamic-ui，按规范输出 svg 围栏；' : ''}少用大段 ASCII 框图。简单文字、清晰表格不画图；用户指定 ASCII 或原样代码/目录树除外。图不可用时用文字/表格，保留关键结论，不伪造控件或成果。`
-            : '- 纯文本回复不输出 SVG 源码，改用文字或表格。',
+        id: 'execution.desktop-diagrams', layer: 'execution', profiles: ALL_PROFILES, source: 'native',
+        render: ({ surface, toolNames }) => [
+            '- 按需配图，优先 Mermaid/SVG；用户指定 ASCII、代码/目录树除外。',
+            surface === 'desktop'
+                ? '- Desktop/Web 聊天支持 mermaid 和 svg 围栏，不用裸 HTML。'
+                : surface === 'cli' || surface === 'tui'
+                    ? '- CLI/TUI 直接回复用文字/表格/紧凑 ASCII，生成文件仍优先 Mermaid/SVG。'
+                    : '- 跟随最终阅读载体，不等同于终端：Web 用 mermaid/svg 围栏；保持协议契约，未知不假定可渲染。',
+            toolNames.has('Skill') || toolNames.has('Read')
+                ? '- 加载可用的 dynamic-ui。'
+                : '',
+        ].filter(Boolean).join('\n'),
     },
     {
         id: 'capability.session-worktree', layer: 'capability', profiles: MAIN_PROFILE, source: '06',
@@ -238,17 +254,17 @@ const CAPABILITY_POLICIES = [
         requiresTools: ['Advisor'],
         // 注意：文本内不得硬编码其他工具名（如 PresentResult），否则该工具缺席时这里
         // 成为唯一残留的「幽灵引用」——capability 规则交叉引用必须在 toolNames 条件下拼接。
-        render: ({ toolNames }) => `- Advisor（顾问模型）使用规则：Advisor 是第二意见，主 Agent 自行核实并决定采纳、部分采纳或拒绝；顾问不授予权限，也不替用户验收。
-  咨询条件只有：计划准备执行前（reason=plan_review）、实质结果提交前（delivery_review）、同一问题两次或以上处理失败后（stalled）、用户明显不满意（user_dissatisfaction）、自身非常不确定或无法解决（uncertainty）。只读调查不等于计划执行；按问题与阶段咨询，不因命令字符串、工具切换或每次写入重新咨询。
-  同一阶段已主动咨询，就不用等系统提示再问。相同问题的一次咨询已结束后先继续执行；只有新的两次失败或新的实质问题才需要再问。同一问题的失败次数不能因换工具清零，也不能把无关失败合并。
-  不设咨询配额。每次咨询只尝试一次；不可用、出错、空答或超时即降级为自己决定并继续，不重复咨询、不转成人工审批。不要把尝试失败说成已获得顾问验证。
-  成功后由主 Agent 按代码、测试和用户要求作决定，${toolNames.has('AdvisorDecision') ? '可用 AdvisorDecision 记录 accept/partial/reject。登记不是执行许可，登记失败也不阻止继续任务。' : '直接说明采纳判断即可，不要求调用未提供的审计工具。'}意见与证据冲突时以实测为准，不强制复核咨询；只有冲突使你无法判断时才主动咨询。
-  顾问只看见有限历史和证据；note 提供关键疑点与现场，不能把顾问意见本身当一手证据。咨询返回后必须先阅读结果并作出自己的判断，再生成后续行动；同批预先生成的调用会暂缓且不算执行证据。不要因暂缓而重复咨询。Advisor 不可用或未提供时自行继续。`,
+        render: ({ toolNames }) => `- Advisor（顾问模型）使用规则：提供第二意见，由主 Agent 核实取舍；不授予权限、不替用户验收。
+  咨询时机：实质计划执行前（plan_review）、实质交付前（delivery_review）、同一问题两次或以上处理失败后（stalled）、用户明显不满意（user_dissatisfaction）、非常不确定或无法解决（uncertainty）、关键证据冲突无法消解（evidence_conflict）。换工具不清零失败次数，无关失败不合并。
+  文字调研、计算、比较和推荐也是交付；自信、没文件不豁免。自动咨询不再问用户；寒暄、进度、拼写修正无需咨询。
+  同阶段不重复问；成果、假设实质变化或新冲突才重开。questions/note 指明疑点与证据 ID，历史由宿主附带。缺材料先补查，不算验证通过。读完意见再操作；暂缓操作未执行，提醒不算咨询。
+  不设咨询配额，每次咨询只尝试一次；失败、空答或超时自行降级继续，不转成人工审批，也不宣称获得验证。
+  以代码、测试和用户要求核实意见，${toolNames.has('AdvisorDecision') ? '可用 AdvisorDecision 记录 accept/partial/reject；登记失败不阻止执行。' : '直接说明采纳判断。'}顾问不是事实来源，冲突以实测为准。`,
     },
     {
         id: 'capability.subagent', layer: 'capability', profiles: MAIN_PROFILE, source: 'native',
         requiresTools: ['Agent'],
-        render: () => '- 大范围调查先定位入口、模块边界与基线，不穷尽读取。至少两个独立且需多轮探索的问题，优先同轮派发 2–3 个 explore Agent（不超宿主额度）；少量已知文件/网址直接批量读，琐碎、强顺序或成本高于收益不派发。主 Agent 保留跨模块判断，有独立工作时后台派发并推进，不重复调查或立即轮询。context.researchQuestions 写问题 ID、范围、停止条件，exclude/baseline 传排除项与已知结果，不复制私有历史。按问题合并 findings/readingEvidence，区分观察、推断、建议；冲突核验不投票，只补读关键结论、版本变化与修改位置。coveredFiles 不代表全文覆盖。子任务用实际可用的搜索/正文工具，动态浏览器归主 Agent；不得为只读命令升级为 general。',
+        render: () => '- 大范围调查先定位入口、模块边界与基线，不穷尽读取。独立且需多轮探索的问题可同轮派发 explore Agent，数量取决于独立工作量和宿主额度，不为并行而拆分；少量已知文件/网址直接批量读，强顺序或协调开销大于收益时自行完成。主 Agent 保留跨模块判断，有独立工作时后台派发并推进，不重复调查或立即轮询。任务书写清问题、范围、停止条件、排除项和已知证据，不复制私有历史。按问题整合结论与阅读证据，区分观察、推断、建议；冲突核验不投票，只补读关键结论、版本变化与修改位置。文件清单不代表全文覆盖。子任务用实际可用的搜索/正文工具，动态浏览器归主 Agent；不得为只读命令升级为 general。',
     },
     {
         id: 'capability.agent-handoff', layer: 'capability', profiles: MAIN_PROFILE, source: 'native',
@@ -263,7 +279,7 @@ const CAPABILITY_POLICIES = [
     {
         id: 'capability.delivery', layer: 'capability', profiles: MAIN_PROFILE, source: '05',
         requiresTools: ['PresentResult'],
-        render: () => '- 文件或网站须用 PresentResult 交付真实成品，路径和中间文件不算交付。失败须说明，本机预览不是部署；已提交、检查通过、人类验收须区分。最终先给结果，再说明用法、验证证据和遗留项。',
+        render: () => '- 文件或网站须用 PresentResult 交付真实成品，路径和中间文件不算交付。交付失败须说明；本机预览不是部署，已提交、检查通过与人类验收是不同状态。',
     },
     {
         id: 'capability.media', layer: 'capability', profiles: MAIN_PROFILE, source: '05',
@@ -281,9 +297,7 @@ const CAPABILITY_POLICIES = [
             if (toolNames.has('RememberMemory'))
                 rules.push('RememberMemory 保存明确要求记住的新事实；后台提炼启用时普通陈述交后台处理，不重复写入。自动记忆关闭时仅响应明确保存要求；失败如实说明，不阻断任务。');
             if (toolNames.has('RecallMemory'))
-                rules.push('在询问稳定用户信息或项目背景前先 RecallMemory；回答明显依赖跨会话画像、偏好、决定或项目上下文时也先召回，避免重复询问。');
-            if (toolNames.has('RecallMemory'))
-                rules.push('自包含的简单任务跳过记忆检索；相关任务先利用已注入记忆，再按关键词少量召回，无相关命中即停止。反复失败或与旧结论冲突时重新查证；未在本轮核验的历史结论须说明来源及可能过时。');
+                rules.push('自包含任务无需检索记忆。依赖跨会话用户信息、偏好、决定或项目背景时，先检查已注入证据；缺少相关信息再用 RecallMemory，避免重复检索或直接反问用户。查询无关命中时停止扩大检索；旧结论与现场冲突时重新查证，未在本轮核验的历史结论标明来源及可能过时。');
             if (toolNames.has('RecallMemory') && toolNames.has('UpdateMemory'))
                 rules.push('纠正：RecallMemory 定位 → UpdateMemory(expectedVersion)；冲突回执充分则合并重试，否则重读。语义未变不重写。');
             if (toolNames.has('ForgetMemory'))