minimal-agent 0.18.13 → 0.18.14

package/src/loop/toolExecutor.ts

@@ -1,5 +1,5 @@
 import { dirname, resolve } from 'node:path';
-import type { AdvisorCoordinator } from '../advisor/advisorCoordinator.js';
+import type { AdvisorNudge } from '../advisor/advisorNudge.js';
 import { countTextTokens } from '../context/tokenCounter.js';
 import { StallGuard, type StallObservation } from '../harness/stallGuard.js';
 import { loadProjectPromptInstructions } from '../prompts/projectInstructions.js';
@@ -21,12 +21,12 @@ export type WorkerOutcome = {
 interface ToolExecutorInput {
   options: Pick<RunQueryOptions,
     'signal' | 'sessionState' | 'agentHandoff' | 'hasQueuedInput' |
-    'advisorCheckpoints' | 'toolBoundaryLabel' | 'toolGate' |
+    'toolBoundaryLabel' | 'toolGate' |
     'onToolStart' | 'onToolEnd' | 'commitFormalDelivery'>;
   runtimeContext: AgentRuntimeContext;
   toolCallContext: ToolCallContext;
   currentEffectiveToolSet: EffectiveToolSet;
-  advisorCoordinator: AdvisorCoordinator;
+  advisorNudge: AdvisorNudge;
   stallGuard: StallGuard;
   modelEnvironmentCwd: string;
   observedRuleScopes: Map<string, string>;
@@ -41,7 +41,7 @@ export function createToolExecutor(input: ToolExecutorInput) {
     runtimeContext,
     toolCallContext,
     currentEffectiveToolSet,
-    advisorCoordinator,
+    advisorNudge,
     stallGuard,
     modelEnvironmentCwd,
     observedRuleScopes,
@@ -56,7 +56,6 @@ export function createToolExecutor(input: ToolExecutorInput) {
   const runOneImpl = async (
     tc: ToolCall,
     reportProgress?: (message: string, detail?: import('../types.js').ToolProgressDetail) => void,
-    advisorConsultation?: import('../types.js').AdvisorConsultationMetadata,
   ): Promise<WorkerOutcome> => {
     let started = false;
     try {
@@ -76,8 +75,9 @@ export function createToolExecutor(input: ToolExecutorInput) {
           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: {
@@ -112,21 +112,6 @@ export function createToolExecutor(input: ToolExecutorInput) {
           },
         };
       }
-      const checkpoint =
-        options.advisorCheckpoints === false
-          ? { allow: true as const }
-          : 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
@@ -267,7 +252,6 @@ export function createToolExecutor(input: ToolExecutorInput) {
         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,
@@ -303,10 +287,9 @@ export function createToolExecutor(input: ToolExecutorInput) {
           };
         }
       }
-      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 };
@@ -324,37 +307,11 @@ export function createToolExecutor(input: ToolExecutorInput) {
   };
 
   const runOne = async (tc: ToolCall, reportProgress?: Parameters<typeof runOneImpl>[1]): Promise<WorkerOutcome> => {
-    // 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, 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;
   };

package/src/loop/toolPresentation.js

@@ -35,19 +35,8 @@ export function friendlyToolDescription(toolName, rawArgsJson, fileLabel) {
             return `技能 · ${truncate(args.name, 60)}`;
         case 'SearchSkills':
             return `查找技能 · ${truncate(args.query, 60)}`;
-        case 'Advisor': {
-            const reasons = {
-                plan_review: '执行前评审',
-                delivery_review: '交付前核验',
-                stalled: '分析重复失败',
-                uncertainty: '核查不确定问题',
-                user_dissatisfaction: '复核用户反馈',
-                evidence_conflict: '核查证据冲突',
-            };
-            return `咨询顾问 · ${reasons[String(args.reason)] ?? '独立第二意见'}`;
-        }
-        case 'AdvisorDecision':
-            return `顾问建议 · ${truncate(args.decision ?? args.action, 40) || '记录核验与采纳结论'}`;
+        case 'Advisor':
+            return `咨询顾问 · ${args.reviewMode === 'full' ? '完整代码审查' : '独立第二意见'}`;
         case 'AskUserQuestion':
             return '询问关键决策';
         case 'PresentResult':

package/src/loop/toolPresentation.ts

@@ -35,19 +35,8 @@ export function friendlyToolDescription(
       return `技能 · ${truncate(args.name, 60)}`;
     case 'SearchSkills':
       return `查找技能 · ${truncate(args.query, 60)}`;
-    case 'Advisor': {
-      const reasons: Record<string, string> = {
-        plan_review: '执行前评审',
-        delivery_review: '交付前核验',
-        stalled: '分析重复失败',
-        uncertainty: '核查不确定问题',
-        user_dissatisfaction: '复核用户反馈',
-        evidence_conflict: '核查证据冲突',
-      };
-      return `咨询顾问 · ${reasons[String(args.reason)] ?? '独立第二意见'}`;
-    }
-    case 'AdvisorDecision':
-      return `顾问建议 · ${truncate(args.decision ?? args.action, 40) || '记录核验与采纳结论'}`;
+    case 'Advisor':
+      return `咨询顾问 · ${args.reviewMode === 'full' ? '完整代码审查' : '独立第二意见'}`;
     case 'AskUserQuestion':
       return '询问关键决策';
     case 'PresentResult':

package/src/loop/toolSemantics.js

@@ -2,8 +2,7 @@ import { isReadOnlyShellCommand, isVerificationShellCommand, isAdvisorInspection
 import { toolEffectFor } from '../tools/capabilities.js';
 import { getToolByName, getToolGateDetails } from '../tools/index.js';
 export function advisorSemanticsFor(call, context, tool, 
-// 默认 false：只有 advisor 检查点/记账（beforeTool、observeToolResult、
-// 持久化的 advisorMutatesWorkspace 标注）才传 true。工作区租约判定
+// 默认 false：只有顾问提醒的记账（AdvisorNudge.observeToolResult）才传 true。工作区租约判定
 // （needsWorkspaceLease）必须保持严格定义不受影响——验证类命令仍可能写
 // 构建产物/缓存，并发场景下让它绕开租约会重新引入竞态。
 opts) {
@@ -26,8 +25,8 @@ opts) {
         try {
             const input = JSON.parse(call.function.arguments || '{}');
             if (typeof input.command === 'string') {
-                // 跑测试/构建/lint 只是核对现状，不该被当成"开始实施改动"而白白烧掉
-                // pre-execution 检查点——即使它们可能写构建产物/缓存，不满足
+                // 跑测试/构建/lint 只是核对现状，不该被当成"开始实施改动"而过早提醒
+                // "动手前先咨询"——即使它们可能写构建产物/缓存，不满足
                 // isReadOnlyShellCommand 的并发安全定义（见 opts 注释，那个场景仍要严格）。
                 isReadOnly =
                     isReadOnlyShellCommand(input.command) ||

package/src/loop/toolSemantics.ts

@@ -1,4 +1,3 @@
-import type { AdvisorToolSemantics } from '../advisor/advisorCoordinator.js';
 import { isReadOnlyShellCommand, isVerificationShellCommand, isAdvisorInspectionCommand } from '../tools/bash/semantics.js';
 import { toolEffectFor } from '../tools/capabilities.js';
 import { getToolByName, getToolGateDetails } from '../tools/index.js';
@@ -7,12 +6,11 @@ export function advisorSemanticsFor(
   call: ToolCall,
   context?: ToolCallContext,
   tool?: Tool,
-  // 默认 false：只有 advisor 检查点/记账（beforeTool、observeToolResult、
-  // 持久化的 advisorMutatesWorkspace 标注）才传 true。工作区租约判定
+  // 默认 false：只有顾问提醒的记账（AdvisorNudge.observeToolResult）才传 true。工作区租约判定
   // （needsWorkspaceLease）必须保持严格定义不受影响——验证类命令仍可能写
   // 构建产物/缓存，并发场景下让它绕开租约会重新引入竞态。
   opts?: { treatVerificationAsReadOnly?: boolean },
-): AdvisorToolSemantics {
+): { mutatesWorkspace: boolean } {
   const definition = tool ?? getToolByName(call.function.name);
   const gate = context ? getToolGateDetails(call.function.name, call.function.arguments, context) : undefined;
   // Reuse the tool's side-effect contract, including shell/scripts, Trash and
@@ -33,8 +31,8 @@ export function advisorSemanticsFor(
         command?: unknown;
       };
       if (typeof input.command === 'string') {
-        // 跑测试/构建/lint 只是核对现状，不该被当成"开始实施改动"而白白烧掉
-        // pre-execution 检查点——即使它们可能写构建产物/缓存，不满足
+        // 跑测试/构建/lint 只是核对现状，不该被当成"开始实施改动"而过早提醒
+        // "动手前先咨询"——即使它们可能写构建产物/缓存，不满足
         // isReadOnlyShellCommand 的并发安全定义（见 opts 注释，那个场景仍要严格）。
         isReadOnly =
           isReadOnlyShellCommand(input.command) ||