neoagent 3.2.1-beta.0 → 3.2.1-beta.10

package/server/services/ai/loop/blank_recovery.js

@@ -33,9 +33,9 @@ function shouldContinueAfterRecoverableToolFailure({
   if (Number(remainingIterations || 0) <= 0) return false;
   const failedExecution = latestFailedToolExecution(toolExecutions);
   if (!isRecoverableInternalToolFailure(failedExecution)) return false;
-  const visible = normalizeOutgoingMessage(lastContent || '');
-  if (!visible) return false;
-  return /\b(blocked|could not|cannot|can't|do not have a confirmed finished result|not found|missing|internal tool issue)\b/i.test(visible);
+  // Structural only: recoverable internal tool failure + remaining budget.
+  // Do not phrase-match the draft reply.
+  return Boolean(normalizeOutgoingMessage(lastContent || '') || failedExecution);
 }
 
 function buildBlankAfterToolFailureGuidance(toolExecutions = []) {
@@ -46,7 +46,8 @@ function buildBlankAfterToolFailureGuidance(toolExecutions = []) {
   return [
     `The previous tool "${toolName}" failed with: ${summarizeForLog(failure, 240)}.`,
     'The latest assistant turn returned no user-facing answer and no tool call, so the task is not terminal.',
-    'Continue with the next safe recovery action: retry with corrected arguments, use another available tool, verify from existing evidence, or report a real blocker only if no autonomous path remains.',
+    'Continue with the next safe recovery action now in this same turn: retry with corrected arguments, use another available tool, verify from existing evidence, or report a real blocker only if no autonomous path remains.',
+    'Do not invent a finished result. Prefer a concrete recovery step or a truthful partial answer over silence.',
   ].join(' ');
 }
 

package/server/services/ai/loop/callbacks.js

@@ -65,6 +65,7 @@ async function publishInterimUpdate(engine, {
       persistConversation: true,
       metadata,
       deliveryKind: 'interim',
+      signal: runMeta.abortController?.signal || null,
     });
     requireSuccessfulMessagingDelivery(deliveryResult, 'Interim messaging delivery');
   } else if (triggerSource === 'voice_live') {

package/server/services/ai/loop/completion_judge.js

@@ -3,6 +3,8 @@
 const { normalizeCompletionConfidence } = require('../completion');
 const { normalizeOutgoingMessage } = require('../messagingFallback');
 const {
+  assessResearchAdequacy,
+  formatResearchAdequacyGuidance,
   summarizeAvailableTools,
   summarizeToolExecutions,
 } = require('../toolEvidence');
@@ -194,8 +196,15 @@ function buildCompletionDecisionPrompt({
   lastReply,
   iteration,
   maxIterations,
+  analysis = null,
+  researchAdequacy = null,
 }) {
   const draftReply = normalizeOutgoingMessage(lastReply) || '';
+  const adequacy = researchAdequacy || assessResearchAdequacy({
+    analysis,
+    goalContext,
+    toolExecutions,
+  });
   const lines = [
     'Return JSON only.',
     'Decide whether this run should continue autonomously or stop now.',
@@ -210,13 +219,33 @@ function buildCompletionDecisionPrompt({
     '- A tool-specific API error, timeout, rate limit, or missing result inside this run is usually "continue", not "blocked", if any other available tool could still make progress.',
     '- Repeated read-only inspection that has already established the relevant object is absent or unchanged is not progress. Accept a concise complete/blocker reply instead of requiring more searching.',
     `- If completion_confidence_required is ${goalContext.effectiveCompletionConfidence} and the latest draft depends on unverified assumptions, use "continue" so the run can gather evidence, inspect state, or narrow the reply.`,
-    triggerSource === 'messaging' && messagingSent
-      ? '- A final reply was already delivered via send_message. Use "complete" unless concrete task work remains.'
-      : triggerSource === 'messaging'
-        ? '- For messaging, do not stop on a partial status message. Continue unless the task is actually complete or externally blocked.'
-        : '- Do not stop just because you wrote a status update. Continue unless the task is actually complete or externally blocked.',
+    '- When research intensity is light or deep, use "continue" until the required primary/source coverage and target coverage are met, or the draft is an explicit blocker naming exactly what could not be verified.',
+    '- Search snippets, memory, and model priors are leads, not completion evidence. Prefer opened/fetched primary sources before "complete".',
+    '- If the latest draft invents entities, products, people, files, results, or actions that are not supported by tool evidence, use "continue" so the run can gather evidence or rewrite into a truthful partial/blocker answer.',
+    '- A polished-sounding answer is not complete if key requested targets still lack direct evidence.',
+    '- If the latest draft only announces unfinished work, promises a future update, or asks the user to wait without a concrete result or blocker, use "continue" so the run keeps acting.',
+    '- If the latest draft asks for missing required user input, confirmation, or a choice needed to proceed, use "blocked" so the run waits instead of repeating the same ask.',
   ];
 
+  if (adequacy.intensity !== 'none') {
+    lines.push(
+      `- Research intensity for this run is ${adequacy.intensity}. Current coverage: primary=${adequacy.primarySourceCount}/${adequacy.requiredPrimarySources}, secondary=${adequacy.secondarySourceCount}, targets_covered=${adequacy.coveredTargets.length}/${Math.max(adequacy.requiredTargetCoverage, adequacy.targets.length)}.`,
+    );
+  }
+  if (adequacy.adequate === false) {
+    lines.push(
+      `- Research is still incomplete (${adequacy.reason}). Use "continue" unless the latest draft is an explicit blocker naming the exact missing evidence.`,
+    );
+  }
+
+  if (triggerSource === 'messaging' && messagingSent) {
+    lines.push('- A final reply was already delivered via send_message. Use "complete" unless concrete task work remains.');
+  } else if (triggerSource === 'messaging') {
+    lines.push('- For messaging, do not stop on a partial status message. Continue unless the task is actually complete or externally blocked.');
+  } else {
+    lines.push('- Do not stop just because you wrote a status update. Continue unless the task is actually complete or externally blocked.');
+  }
+
   lines.push(
     goalContext.effectiveGoal ? `Goal: ${goalContext.effectiveGoal}` : '',
     goalContext.persistedGoalPrompt,
@@ -227,6 +256,16 @@ function buildCompletionDecisionPrompt({
     `Current iteration: ${iteration} of ${maxIterations}.`,
     `Available tools in this run: ${summarizeAvailableTools(tools) || 'none'}`,
     `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 8) || 'none'}`,
+    adequacy.intensity !== 'none'
+      ? `Research adequacy: intensity=${adequacy.intensity}; adequate=${adequacy.adequate}; reason=${adequacy.reason}`
+      : '',
+    adequacy.targets.length
+      ? `Research targets: ${adequacy.targets.join('; ')}`
+      : '',
+    adequacy.uncoveredTargets.length
+      ? `Uncovered research targets: ${adequacy.uncoveredTargets.join('; ')}`
+      : '',
+    formatResearchAdequacyGuidance(adequacy),
     `Latest draft reply:\n${draftReply || '(empty)'}`,
   );
   return lines.filter(Boolean).join('\n');
@@ -241,6 +280,39 @@ function normalizeCompletionDecision(raw, fallbackStatus = 'continue') {
   };
 }
 
+function enforceTerminalReplyDecision(decision, lastReply, options = {}) {
+  // Natural-language terminality is judged by the model completion decision.
+  // Runtime only enforces structural evidence contracts (research adequacy).
+  const researchAdequacy = options.researchAdequacy
+    || assessResearchAdequacy({
+      analysis: options.analysis || null,
+      goalContext: options.goalContext || null,
+      toolExecutions: options.toolExecutions || [],
+    });
+  if (
+    researchAdequacy
+    && researchAdequacy.adequate === false
+    && (decision?.status === 'complete' || decision?.status === 'blocked')
+  ) {
+    // Allow true blocked outcomes only when the model already chose blocked AND
+    // research cannot progress further (no remaining targets/primary gap that
+    // tools could still cover). Otherwise force continue for evidence gathering.
+    if (
+      decision?.status === 'blocked'
+      && researchAdequacy.uncoveredTargets.length === 0
+      && researchAdequacy.primarySourceCount >= researchAdequacy.requiredPrimarySources
+    ) {
+      return decision;
+    }
+    return {
+      status: 'continue',
+      reason: researchAdequacy.reason
+        || 'Research evidence is still incomplete for the requested targets; continue gathering sources before finishing.',
+    };
+  }
+  return decision;
+}
+
 // Intentionally lightweight (200-token cap, self-contained) so the model can
 // answer cold without re-reading full conversation history.
 function buildChurnAssessmentPrompt({
@@ -249,7 +321,14 @@ function buildChurnAssessmentPrompt({
   goalContext,
   toolExecutions,
   iteration,
+  analysis = null,
+  researchAdequacy = null,
 }) {
+  const adequacy = researchAdequacy || assessResearchAdequacy({
+    analysis,
+    goalContext,
+    toolExecutions,
+  });
   const lines = [
     'Return JSON only.',
     'Self-assess your current loop state — are you making genuine progress or spinning?',
@@ -263,15 +342,50 @@ function buildChurnAssessmentPrompt({
       : '',
     `Iteration: ${iteration}`,
     `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 6) || 'none'}`,
+    adequacy.intensity !== 'none'
+      ? `Research adequacy: intensity=${adequacy.intensity}; adequate=${adequacy.adequate}; covered=${adequacy.coveredTargets.length}/${Math.max(adequacy.requiredTargetCoverage, adequacy.targets.length)}; primary=${adequacy.primarySourceCount}/${adequacy.requiredPrimarySources}.`
+      : '',
+    adequacy.uncoveredTargets.length
+      ? `Still uncovered research targets: ${adequacy.uncoveredTargets.join('; ')}.`
+      : '',
     '',
     'Assessment rules:',
     '- "progressing": You are systematically gathering necessary context and the next concrete action is already determined — you know exactly what to do next.',
     '- "churn": You are re-reading/re-searching information already in context, or exploring without a clear next concrete step. Accept the nudge and act.',
     '- "blocked": No concrete action is available in this run. You have all the evidence needed to deliver a truthful final answer or a specific external blocker.',
+    '- For multi-target research, keep "progressing" while uncovered targets remain and a fresh primary source can still be opened. Do not mark "blocked" just because you have partial notes.',
+    '- Re-querying the same snippet source for an already covered target is "churn". Opening a different primary source for an uncovered target is "progressing".',
+    adequacy.adequate === false
+      ? '- Research adequacy is currently incomplete. Prefer "progressing" if a new primary source for an uncovered target is still available; use "churn" only for repeated identical reads; do not use "blocked" unless tools cannot reach remaining targets.'
+      : '',
   ];
   return lines.filter(Boolean).join('\n');
 }
 
+function enforceChurnAssessment(assessment, options = {}) {
+  const normalized = normalizeChurnAssessment(assessment);
+  const researchAdequacy = options.researchAdequacy
+    || assessResearchAdequacy({
+      analysis: options.analysis || null,
+      goalContext: options.goalContext || null,
+      toolExecutions: options.toolExecutions || [],
+    });
+  if (
+    researchAdequacy
+    && researchAdequacy.adequate === false
+    && researchAdequacy.intensity !== 'none'
+    && normalized.assessment === 'blocked'
+    && (researchAdequacy.uncoveredTargets?.length > 0 || researchAdequacy.primarySourceCount < researchAdequacy.requiredPrimarySources)
+  ) {
+    return {
+      assessment: 'progressing',
+      reason: researchAdequacy.reason
+        || 'Research targets remain uncovered; keep gathering primary sources instead of force-finishing.',
+    };
+  }
+  return normalized;
+}
+
 function normalizeChurnAssessment(raw) {
   const allowed = new Set(['progressing', 'churn', 'blocked']);
   const assessment = String(raw?.assessment || '').trim().toLowerCase();
@@ -285,9 +399,11 @@ module.exports = {
   buildChurnAssessmentPrompt,
   buildCompletionDecisionPrompt,
   buildGoalContractPrompt,
+  enforceTerminalReplyDecision,
   goalContractFromAnalysis,
   goalContractFromPlan,
   mergeGoalContracts,
+  enforceChurnAssessment,
   normalizeChurnAssessment,
   normalizeCompletionDecision,
   normalizeGoalContract,