minimal-agent 0.18.13 → 0.18.14

package/src/llm/providers/responsesFormat.ts

@@ -0,0 +1,306 @@
+/**
+ * ============================================================
+ *  src/llm/providers/responsesFormat.ts —— OpenAI Responses API 协议
+ * ------------------------------------------------------------
+ *  ⚠️ 未经真实端点验证：本机没有可用于付费调用的 OpenAI key，请求体与 SSE 事件字段
+ *  照官方文档（POST /v1/responses，stream:true）实现，配了手写的 SSE 录像单测，
+ *  没有做过真实 round-trip。拿到 key 后先跑一次真实对话冒烟（含一次工具调用）。
+ *
+ *  与 openaiFormat.ts / anthropicFormat.ts 同一分工：这里只做「内部 Message[]/Tool[]
+ *  ⇄ Responses 协议形状」的翻译 + SSE 逐帧解析；重试/退避/空闲看门狗/就地退化
+ *  留在 client.ts。
+ *
+ *  设计取舍（都是为了让它在不依赖服务端会话状态的前提下正确）：
+ *   - 无状态：`store:false`，每次请求重发完整历史，不用 previous_response_id。
+ *     与本项目「history 是唯一事实源、压缩/快照在本地」的前提一致。
+ *   - 工具 `strict:false`：Responses 的函数工具默认 strict:true，要求
+ *     additionalProperties:false 且全字段 required；本项目的工具 schema 不满足，
+ *     不显式关掉就会整批 400。
+ *   - 回传的 function_call 只带 call_id/name/arguments，**不带 id**：带上 fc_ id
+ *     而缺少配对的 reasoning 项，服务端会报错；无状态重发不保存 reasoning 项，
+ *     所以只能不带。代价是推理模型在多轮工具调用间丢失上一轮的推理上下文
+ *     （质量略降，不影响正确性）。
+ *   - 不请求 reasoning.summary：部分组织需要先做身份验证才能拿推理摘要，
+ *     请求了反而 400。服务端若主动发摘要增量，照常显示为思维链。
+ * ============================================================
+ */
+
+import type {
+  ChatContentPart,
+  LlmStreamEvent,
+  LocalProvider,
+  Message,
+  PromptCacheContext,
+  PromptCacheUsage,
+  Tool,
+} from '../../types.js';
+
+type ResponsesItem = Record<string, unknown>;
+
+function userContent(content: string | ChatContentPart[]): unknown {
+  if (typeof content === 'string') return content;
+  return content.map((part): Record<string, unknown> => {
+    if (part.type === 'text') return { type: 'input_text', text: part.text };
+    if (part.type === 'image_url') {
+      const detail = part.image_url.detail;
+      return {
+        type: 'input_image',
+        image_url: part.image_url.url,
+        // 'default' 是本项目内部取值，Responses 只认 auto/low/high。
+        detail: detail === 'low' || detail === 'high' ? detail : 'auto',
+      };
+    }
+    return { type: 'input_text', text: '[视频内容未发送：Responses 格式的 provider 暂不支持视频输入]' };
+  });
+}
+
+/** 内部 Message[]（OpenAI Chat 形状）→ Responses 的 input 数组。 */
+export function toResponsesInput(messages: readonly Message[]): ResponsesItem[] {
+  const input: ResponsesItem[] = [];
+  for (const message of messages) {
+    if (message.role === 'system') {
+      input.push({ role: 'system', content: message.content });
+    } else if (message.role === 'user') {
+      input.push({ role: 'user', content: userContent(message.content) });
+    } else if (message.role === 'assistant') {
+      if (message.content) {
+        input.push({ role: 'assistant', content: [{ type: 'output_text', text: message.content }] });
+      }
+      for (const call of message.tool_calls ?? []) {
+        input.push({
+          type: 'function_call',
+          call_id: call.id,
+          name: call.function.name,
+          arguments: call.function.arguments || '{}',
+        });
+      }
+    } else {
+      input.push({ type: 'function_call_output', call_id: message.tool_call_id, output: message.content });
+    }
+  }
+  return input;
+}
+
+function looksLikeVersionedBase(url: string): boolean {
+  try {
+    const path = new URL(url).pathname.replace(/\/+$/, '');
+    if (path === '' || path === '/') return true;
+    return /^v\d+/.test(path.split('/').at(-1)!);
+  } catch {
+    return false;
+  }
+}
+
+/** baseURL 是完整端点（以 /responses 结尾）；只有「版本化基础路径」才自动补后缀。 */
+export function buildResponsesUrl(provider: LocalProvider): string {
+  const url = provider.baseURL.trim().replace(/\/+$/, '');
+  if (!url || url.endsWith('/responses')) return url;
+  return looksLikeVersionedBase(url) ? `${url}/responses` : url;
+}
+
+export interface ResponsesRequestArgs {
+  provider: LocalProvider;
+  cleanedMessages: readonly Message[];
+  tools: Tool[];
+  withMaxTokens: boolean;
+  withReasoningEffort: boolean;
+  withPromptCacheKey?: boolean;
+  promptCache?: PromptCacheContext;
+  /** 与 Chat Completions 同形状的结构化输出要求，这里翻成 text.format。 */
+  responseFormat?: {
+    type: 'json_schema';
+    json_schema: { name: string; schema: Record<string, unknown>; strict?: boolean };
+  };
+  withResponseFormat: boolean;
+}
+
+export function buildResponsesRequest(args: ResponsesRequestArgs): {
+  url: string;
+  headers: Record<string, string>;
+  body: string;
+} {
+  const { provider, cleanedMessages, tools } = args;
+  const functionTools = tools.map((tool) => ({
+    type: 'function',
+    name: tool.name,
+    description: typeof tool.description === 'function' ? tool.description() : tool.description,
+    parameters: tool.parameters,
+    strict: false,
+  }));
+  const body: Record<string, unknown> = {
+    model: provider.model,
+    input: toResponsesInput(cleanedMessages),
+    stream: true,
+    store: false,
+  };
+  if (functionTools.length > 0) {
+    body.tools = functionTools;
+    body.tool_choice = 'auto';
+  }
+  if (args.withMaxTokens && typeof provider.maxTokens === 'number' && provider.maxTokens > 0) {
+    body.max_output_tokens = provider.maxTokens;
+  }
+  if (args.withReasoningEffort && provider.reasoningEffort) {
+    body.reasoning = { effort: provider.reasoningEffort };
+  }
+  if (args.withResponseFormat && args.responseFormat) {
+    const schema = args.responseFormat.json_schema;
+    body.text = {
+      format: {
+        type: 'json_schema',
+        name: schema.name,
+        schema: schema.schema,
+        ...(schema.strict !== undefined ? { strict: schema.strict } : {}),
+      },
+    };
+  }
+  if (args.withPromptCacheKey && args.promptCache?.scopeKey) {
+    body.prompt_cache_key = args.promptCache.scopeKey;
+  }
+  return {
+    url: buildResponsesUrl(provider),
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${provider.apiKey}`,
+    },
+    body: JSON.stringify(body),
+  };
+}
+
+/** 400 是否在抱怨 reasoning / effort 取值（模型不支持该档位，或根本不是推理模型）。 */
+export function isReasoningEffortRejected(status: number, errText: string): boolean {
+  if (status !== 400 && status !== 422) return false;
+  const text = errText.toLowerCase();
+  if (!text.includes('reasoning')) return false;
+  return (
+    text.includes('not support') ||
+    text.includes('unsupported') ||
+    text.includes('invalid') ||
+    text.includes('not valid') ||
+    text.includes('unknown') ||
+    text.includes('unrecognized') ||
+    text.includes('unexpected') ||
+    text.includes('not allowed') ||
+    text.includes('supported values')
+  );
+}
+
+function finiteNonNegative(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+/** 每个请求一个新实例；把 Responses 的 SSE `data:` 载荷翻成 LlmStreamEvent。 */
+export function createResponsesSSEParser(): {
+  handleData(dataStr: string): LlmStreamEvent[];
+  buildFallbackDone(): LlmStreamEvent;
+} {
+  /** output_index → 本轮第几个工具调用（loop 按 index 合并分片）。 */
+  const toolIndex = new Map<number, number>();
+  const streamedArguments = new Set<number>();
+  let stopReason: 'stop' | 'tool_calls' | 'length' | 'unknown' = 'unknown';
+  let sawToolCall = false;
+  let promptTokens: number | undefined;
+  let outputTokens: number | undefined;
+  let cachedTokens: number | undefined;
+  let promptCacheUsage: PromptCacheUsage = { reported: false };
+
+  const readUsage = (usage: unknown) => {
+    if (!usage || typeof usage !== 'object') return;
+    const u = usage as Record<string, unknown>;
+    // input_tokens 已含命中缓存的部分（与 Chat Completions 的 prompt_tokens 同语义）。
+    promptTokens = finiteNonNegative(u.input_tokens) ?? promptTokens;
+    outputTokens = finiteNonNegative(u.output_tokens) ?? outputTokens;
+    const details = u.input_tokens_details;
+    if (details && typeof details === 'object') {
+      cachedTokens = finiteNonNegative((details as Record<string, unknown>).cached_tokens) ?? cachedTokens;
+    }
+    promptCacheUsage = {
+      reported: cachedTokens !== undefined,
+      ...(promptTokens !== undefined ? { promptTokens } : {}),
+      ...(cachedTokens !== undefined ? { cacheReadTokens: cachedTokens } : {}),
+    };
+  };
+  const done = (): LlmStreamEvent => ({
+    type: 'done',
+    stopReason,
+    promptTokens,
+    outputTokens,
+    cachedPromptTokens: cachedTokens,
+    promptCacheUsage,
+  });
+  const indexFor = (outputIndex: number) => {
+    let index = toolIndex.get(outputIndex);
+    if (index === undefined) {
+      index = toolIndex.size;
+      toolIndex.set(outputIndex, index);
+    }
+    return index;
+  };
+
+  return {
+    buildFallbackDone: done,
+    handleData(dataStr: string): LlmStreamEvent[] {
+      if (dataStr === '[DONE]') return [done()];
+      let data: any;
+      try {
+        data = JSON.parse(dataStr);
+      } catch {
+        return [];
+      }
+      switch (data.type) {
+        case 'response.output_text.delta':
+          return typeof data.delta === 'string' && data.delta
+            ? [{ type: 'text_delta', delta: data.delta }]
+            : [];
+        case 'response.reasoning_summary_text.delta':
+        case 'response.reasoning_text.delta':
+          return typeof data.delta === 'string' && data.delta
+            ? [{ type: 'reasoning_delta', field: 'reasoning', delta: data.delta }]
+            : [];
+        case 'response.output_item.added': {
+          const item = data.item;
+          if (item?.type !== 'function_call') return [];
+          sawToolCall = true;
+          // id 用 call_id（回传 function_call_output 时必须对得上），不是 fc_ 的 item id。
+          return [{ type: 'tool_call_delta', index: indexFor(data.output_index ?? 0), id: item.call_id, name: item.name }];
+        }
+        case 'response.function_call_arguments.delta': {
+          const outputIndex = data.output_index ?? 0;
+          if (typeof data.delta !== 'string' || !data.delta) return [];
+          streamedArguments.add(outputIndex);
+          return [{ type: 'tool_call_delta', index: indexFor(outputIndex), argumentsDelta: data.delta }];
+        }
+        case 'response.output_item.done': {
+          // 兜底：有的网关不发 arguments.delta，只在条目完成时给完整 arguments。
+          const item = data.item;
+          const outputIndex = data.output_index ?? 0;
+          if (item?.type !== 'function_call' || streamedArguments.has(outputIndex)) return [];
+          sawToolCall = true;
+          const arguments_ = typeof item.arguments === 'string' ? item.arguments : '';
+          return arguments_
+            ? [{ type: 'tool_call_delta', index: indexFor(outputIndex), id: item.call_id, name: item.name, argumentsDelta: arguments_ }]
+            : [];
+        }
+        case 'response.completed':
+          readUsage(data.response?.usage);
+          stopReason = sawToolCall ? 'tool_calls' : 'stop';
+          return [done()];
+        case 'response.incomplete': {
+          readUsage(data.response?.usage);
+          const reason = data.response?.incomplete_details?.reason;
+          stopReason = reason === 'max_output_tokens' ? 'length' : sawToolCall ? 'tool_calls' : 'unknown';
+          return [done()];
+        }
+        case 'response.failed': {
+          const error = data.response?.error;
+          throw new Error(`OpenAI Responses 流式响应失败：${JSON.stringify(error ?? data.response ?? data)}`);
+        }
+        case 'error':
+          throw new Error(`OpenAI Responses 流式响应报错：${JSON.stringify(data.error ?? data)}`);
+        default:
+          // response.created / in_progress / content_part.* / output_text.done 等：已知安全的 no-op。
+          return [];
+      }
+    },
+  };
+}

package/src/loop/README.md

@@ -11,11 +11,11 @@ decisions stay visible in one place: retry, consult, execute, publish or interru
 | `toolExecutor.ts` | Single-call authorization, rules, leases, execution and delivery receipt |
 | `toolBatch.ts` | Safe concurrency segments, question/advisor barriers and ordered commits |
 | `progressStream.ts` | Callback-to-generator progress bridge and worker settlement |
-| `publication.ts` | Final expression stream and fallback before first visible text |
 | `messages.ts` | Model message projection, interrupts, screenshot lifecycle, tool deltas |
 | `toolPresentation.ts` | Human-readable tool descriptions; no execution policy |
 | `toolSemantics.ts` | Advisor side-effect classification |
 | `deliveryIntent.ts` | Existing formal-delivery intent policy |
+| `liveDiagramGate.ts` | Holds back a possible text-drawn diagram in a live answer until its fence closes |
 
 ## Ownership and invariants
 
@@ -29,8 +29,23 @@ decisions stay visible in one place: retry, consult, execute, publish or interru
   Writes and interactive/advisor barriers do not become parallel work.
 - Host execution hooks start only after preflight checks. UI `tool_start` is a
   separate event: even a denied/deferred request receives a visible result.
-- Final candidate text remains private until delivery checks finish. Publication
-  does not execute tools or replace a prefix already shown to the user.
+- Before each request the orchestrator decides whether the answer can stream
+  live (`liveFinal`): only when no delivery check could still hold it back
+  (no owed formal delivery or unresolved delegation). The advisor is not such
+  a check: it only reminds (`advisor/advisorNudge.ts`) and never holds an answer
+  or defers a tool. Live text is never retracted — on
+  interruption or error only the text actually shown is committed, and pending
+  messages commit it as progress first. The ask correction applies only to
+  private drafts; the diagram correction also works live: `liveDiagramGate`
+  holds a possible text drawing until its fence closes, and a box stops the
+  visible answer right before it — the shown part becomes a progress message and
+  the model continues from there. Otherwise the candidate stays private until
+  every check passes and is published verbatim; no second tool-free request
+  rewrites it. Corrections retire the draft and add a transient reminder (the
+  diagram one carries the draft as internal material until the revised answer
+  itself arrives, across any skill-loading round); the kernel never
+  writes a tool call the model did not make, except the documented host-forced
+  Advisor checkpoint.
 - Cancellation belongs to the host AbortSignal. Progress stream disposal waits for
   active workers to settle; it does not grant permission to leave tools orphaned.
 - Existing exports from `loop.ts` remain compatible for TUI, Desktop, subagents and

package/src/loop/liveDiagramGate.js

@@ -0,0 +1,63 @@
+import { DIAGRAM_FENCE_INFO, FENCE_CLOSE, FENCE_OPEN, isBoxDiagram } from '../prompts/visualPresentation.js';
+/**
+ * Lets a live answer be corrected for text-drawn diagrams without ever
+ * retracting shown text. Text streams as it arrives, except a fenced block
+ * that could be a prose drawing (no info string, `text`, `plaintext`): that is
+ * held from its opening line until it closes. Not a box → released at once.
+ * A box → the visible answer stops right before it; the loop keeps the shown
+ * part and asks the model to continue from there with a real diagram. Fences
+ * with a language are code and stream straight through.
+ */
+export class LiveDiagramGate {
+    #scanned = 0;
+    #fence;
+    #hit;
+    #released = false;
+    /** Start of the held box, once one was found (and not released). */
+    get hit() {
+        return this.#released ? undefined : this.#hit;
+    }
+    /** Give up on correcting (tool round, no turns left): show everything. */
+    release() {
+        this.#released = true;
+    }
+    /** How much of `text` may be shown now; `final` once the model has finished. */
+    releasable(text, final = false) {
+        if (this.#released)
+            return text.length;
+        if (this.#hit !== undefined)
+            return this.#hit;
+        for (let newline = text.indexOf('\n', this.#scanned); newline >= 0; newline = text.indexOf('\n', this.#scanned)) {
+            const start = this.#scanned;
+            const line = text.slice(start, newline).replace(/\r$/, '');
+            this.#scanned = newline + 1;
+            if (!this.#fence) {
+                const open = FENCE_OPEN.exec(line);
+                if (open)
+                    this.#fence = { start, body: this.#scanned, marker: open[1], candidate: DIAGRAM_FENCE_INFO.test(open[2]) };
+                continue;
+            }
+            const close = FENCE_CLOSE.exec(line);
+            if (!close || close[1][0] !== this.#fence.marker[0] || close[1].length < this.#fence.marker.length)
+                continue;
+            if (this.#fence.candidate && isBoxDiagram(text.slice(this.#fence.body, start))) {
+                this.#hit = this.#fence.start;
+                return this.#hit;
+            }
+            this.#fence = undefined;
+        }
+        if (final) {
+            // The model ended inside a fence: judge what it wrote, then show the rest.
+            if (this.#fence?.candidate && isBoxDiagram(text.slice(this.#fence.body)))
+                this.#hit = this.#fence.start;
+            return this.#hit ?? text.length;
+        }
+        if (this.#fence?.candidate)
+            return this.#fence.start;
+        // A partial line outside any fence may still turn into a fence opener
+        // (list items indent fences by up to 3 spaces).
+        if (!this.#fence && /^ {0,3}[`~]/.test(text.slice(this.#scanned)))
+            return this.#scanned;
+        return text.length;
+    }
+}

package/src/loop/liveDiagramGate.ts

@@ -0,0 +1,61 @@
+import { DIAGRAM_FENCE_INFO, FENCE_CLOSE, FENCE_OPEN, isBoxDiagram } from '../prompts/visualPresentation.js';
+
+/**
+ * Lets a live answer be corrected for text-drawn diagrams without ever
+ * retracting shown text. Text streams as it arrives, except a fenced block
+ * that could be a prose drawing (no info string, `text`, `plaintext`): that is
+ * held from its opening line until it closes. Not a box → released at once.
+ * A box → the visible answer stops right before it; the loop keeps the shown
+ * part and asks the model to continue from there with a real diagram. Fences
+ * with a language are code and stream straight through.
+ */
+export class LiveDiagramGate {
+  #scanned = 0;
+  #fence?: { start: number; body: number; marker: string; candidate: boolean };
+  #hit?: number;
+  #released = false;
+
+  /** Start of the held box, once one was found (and not released). */
+  get hit(): number | undefined {
+    return this.#released ? undefined : this.#hit;
+  }
+
+  /** Give up on correcting (tool round, no turns left): show everything. */
+  release(): void {
+    this.#released = true;
+  }
+
+  /** How much of `text` may be shown now; `final` once the model has finished. */
+  releasable(text: string, final = false): number {
+    if (this.#released) return text.length;
+    if (this.#hit !== undefined) return this.#hit;
+    for (let newline = text.indexOf('\n', this.#scanned); newline >= 0; newline = text.indexOf('\n', this.#scanned)) {
+      const start = this.#scanned;
+      const line = text.slice(start, newline).replace(/\r$/, '');
+      this.#scanned = newline + 1;
+      if (!this.#fence) {
+        const open = FENCE_OPEN.exec(line);
+        if (open)
+          this.#fence = { start, body: this.#scanned, marker: open[1]!, candidate: DIAGRAM_FENCE_INFO.test(open[2]!) };
+        continue;
+      }
+      const close = FENCE_CLOSE.exec(line);
+      if (!close || close[1]![0] !== this.#fence.marker[0] || close[1]!.length < this.#fence.marker.length) continue;
+      if (this.#fence.candidate && isBoxDiagram(text.slice(this.#fence.body, start))) {
+        this.#hit = this.#fence.start;
+        return this.#hit;
+      }
+      this.#fence = undefined;
+    }
+    if (final) {
+      // The model ended inside a fence: judge what it wrote, then show the rest.
+      if (this.#fence?.candidate && isBoxDiagram(text.slice(this.#fence.body))) this.#hit = this.#fence.start;
+      return this.#hit ?? text.length;
+    }
+    if (this.#fence?.candidate) return this.#fence.start;
+    // A partial line outside any fence may still turn into a fence opener
+    // (list items indent fences by up to 3 spaces).
+    if (!this.#fence && /^ {0,3}[`~]/.test(text.slice(this.#scanned))) return this.#scanned;
+    return text.length;
+  }
+}

package/src/loop/messages.js

@@ -108,6 +108,18 @@ export function pushManualInterruptMarker(history) {
         id: crypto.randomUUID(),
     });
 }
+/**
+ * 回答已发布但实质成果没经顾问复核（advisor.enforcement='followup'）：补一条系统提示，
+ * 让模型自己去调 Advisor。回答不撤回，Advisor 调用由模型发出，宿主不替它伪造。
+ */
+export function pushAdvisorFollowUpMarker(history) {
+    history.push({
+        role: 'user',
+        content: '(系统提示：你刚才给出的回答包含实质结论或成果，但还没有经过顾问复核。现在调用 Advisor 复核：意见指出问题就更正并说明；没有异议则用一句话说明已复核，不要重复整篇回答。)',
+        timestamp: Date.now(),
+        id: crypto.randomUUID(),
+    });
+}
 /**
  * 有新的用户输入在队列中，当前安全停靠
  */

package/src/loop/messages.ts

@@ -122,6 +122,19 @@ export function pushManualInterruptMarker(history: Message[]): void {
   });
 }
 
+/**
+ * 回答已发布但实质成果没经顾问复核（advisor.enforcement='followup'）：补一条系统提示，
+ * 让模型自己去调 Advisor。回答不撤回，Advisor 调用由模型发出，宿主不替它伪造。
+ */
+export function pushAdvisorFollowUpMarker(history: Message[]): void {
+  history.push({
+    role: 'user',
+    content: '(系统提示：你刚才给出的回答包含实质结论或成果，但还没有经过顾问复核。现在调用 Advisor 复核：意见指出问题就更正并说明；没有异议则用一句话说明已复核，不要重复整篇回答。)',
+    timestamp: Date.now(),
+    id: crypto.randomUUID(),
+  });
+}
+
 /**
  * 有新的用户输入在队列中，当前安全停靠
  */

package/src/loop/options.ts

@@ -35,8 +35,13 @@ export interface RunQueryOptions {
   allowedTools?: string[];
   /** 调用方工具边界名称，仅用于准确解释越界调用；缺省表示宿主能力边界。 */
   toolBoundaryLabel?: string;
-  /** Disable Advisor checkpoints for an explicitly read-only embedded node. */
-  advisorCheckpoints?: boolean;
+  /** False turns off the Advisor reminders for an explicitly read-only embedded node. */
+  advisorReminders?: boolean;
+  /**
+   * 实质回答发布后仍未经顾问复核时，再发一次请求让模型自己补问（回答不撤回）。
+   * 缺省读配置 `advisor.enforcement === 'followup'`；测试和内嵌节点可显式指定。
+   */
+  advisorFollowUp?: boolean;
   /** Tools the host/workflow explicitly requires; emergency schema reduction preserves them. */
   requiredTools?: string[];
   /**

package/src/loop/toolBatch.js

@@ -28,7 +28,6 @@ export async function* executeToolBatch(input) {
         return (![
             'AskUserQuestion',
             'Advisor',
-            'AdvisorDecision',
             'OptimizeConversation',
             'AgentReport',
             'AgentResolve',

package/src/loop/toolBatch.ts

@@ -41,7 +41,6 @@ export async function* executeToolBatch(input: {
       ![
         'AskUserQuestion',
         'Advisor',
-        'AdvisorDecision',
         'OptimizeConversation',
         'AgentReport',
         'AgentResolve',

package/src/loop/toolExecutor.js

@@ -9,12 +9,12 @@ import { resolveToolPath } from '../tools/shared/fileUtils.js';
 import { advisorSemanticsFor } from './toolSemantics.js';
 /** One batch's execution boundary. Scheduling and history writes belong to callers. */
 export function createToolExecutor(input) {
-    const { options, runtimeContext, toolCallContext, currentEffectiveToolSet, advisorCoordinator, stallGuard, modelEnvironmentCwd, observedRuleScopes, pendingRuleScopes, currentUserMessageId, executeToolFn, } = input;
+    const { options, runtimeContext, toolCallContext, currentEffectiveToolSet, advisorNudge, stallGuard, modelEnvironmentCwd, observedRuleScopes, pendingRuleScopes, currentUserMessageId, executeToolFn, } = input;
     const { signal, sessionState } = options;
     // Convert tool execution failures/aborts into results; host hook failures are
     // not a successful tool outcome and may propagate to the batch boundary.
     const failureReviews = [];
-    const runOneImpl = async (tc, reportProgress, advisorConsultation) => {
+    const runOneImpl = async (tc, reportProgress) => {
         let started = false;
         try {
             const handoff = options.agentHandoff?.current();
@@ -33,8 +33,9 @@ export function createToolExecutor(input) {
                     result: { ok: false, disposition: 'deferred', error: 'aborted' },
                 };
             }
-            const advisorAvailable = currentEffectiveToolSet.names.has('Advisor');
-            if (!advisorAvailable && stallGuard.shouldReject(tc)) {
+            // Rejecting a third identical failing call is the guard's own job, advisor or
+            // not: the advisor is only a reminder now, so nothing else stops the loop.
+            if (stallGuard.shouldReject(tc)) {
                 return {
                     tc,
                     result: {
@@ -68,15 +69,6 @@ export function createToolExecutor(input) {
                     },
                 };
             }
-            const checkpoint = options.advisorCheckpoints === false
-                ? { allow: true }
-                : advisorCoordinator.beforeTool(tc, {
-                    ...advisorSemanticsFor(tc, toolCallContext, currentEffectiveToolSet.tools.find((tool) => tool.name === tc.function.name), { treatVerificationAsReadOnly: true }),
-                    retriesFailure: stallGuard.shouldReject(tc),
-                });
-            if (!checkpoint.allow) {
-                return { tc, result: checkpoint.deferred };
-            }
             // 工具执行闸门：宿主注入后覆盖所有工具，包括只读工具。deny → 把 reason 当
             // tool_result 回填，模型据此改道/如实报告，不抛异常不中断整轮。宿主异常一律 deny。
             // Keep the host gate's side-effect classification identical to the
@@ -210,7 +202,6 @@ export function createToolExecutor(input) {
                 options.onToolStart?.(tc.function.name, tc.id);
                 result = await executeToolFn(tc.function.name, tc.function.arguments, signal, {
                     ...toolCallContext,
-                    advisorConsultation,
                     delegationTools: currentEffectiveToolSet.tools,
                     cwd: sessionState?.activeWorktree?.path ?? toolCallContext.cwd,
                     toolCallId: tc.id,
@@ -244,10 +235,10 @@ export function createToolExecutor(input) {
                     };
                 }
             }
-            if (tc.function.name === 'Advisor' || tc.function.name === 'AdvisorDecision') {
-                // 串行批次内下一项可能就是 AdvisorDecision/受保护写入，必须立即推进协调器状态。
-                advisorCoordinator.observeToolResult(tc, result);
-            }
+            // A successful consultation lets the model try the failing path again: the
+            // guard stops counting those failures against it.
+            if (tc.function.name === 'Advisor' && result.ok)
+                stallGuard.noteConsultation();
             started = false;
             options.onToolEnd?.(tc.id, false);
             return { tc, result };
@@ -266,37 +257,11 @@ export function createToolExecutor(input) {
         }
     };
     const runOne = 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;
-            try {
-                reason = JSON.parse(tc.function.arguments).reason;
-            }
-            catch {
-                /* validation handles malformed input */
-            }
-            consultation = advisorCoordinator.beginConsultation(reason);
-        }
-        const outcome = await runOneImpl(tc, reportProgress, consultation);
-        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') {
-            if (metadata.checkpoint === 'stalled')
-                stallGuard.completeReview(metadata.checkpointKey.split(':').at(-1));
-        }
+        const outcome = await runOneImpl(tc, reportProgress);
         const failure = stallGuard.observeAttempt(tc, outcome.result);
         if (failure.stalled && failure.signature) {
             failureReviews.push(failure);
-            advisorCoordinator.requireFailureReview(failure.signature, failure.attempts ?? []);
+            advisorNudge.notifyStalled(failure.signature);
         }
         return outcome;
     };