neoagent 3.2.1-beta.1 → 3.2.1-beta.11

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,7 +3,10 @@
 const { normalizeCompletionConfidence } = require('../completion');
 const { normalizeOutgoingMessage } = require('../messagingFallback');
 const {
+  assessResearchAdequacy,
+  formatResearchAdequacyGuidance,
   summarizeAvailableTools,
+  summarizeResearchEvidenceCatalog,
   summarizeToolExecutions,
 } = require('../toolEvidence');
 
@@ -194,12 +197,19 @@ 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.',
-    'Schema: {"status":"continue|complete|blocked","reason":"short concrete reason"}',
+    'Schema: {"status":"continue|complete|blocked","reason":"short concrete reason","blocker_review":{"kind":"user_input|permission|external_dependency|unavailable_capability|none","resolvable_in_run":true,"required_value":"specific missing dependency"},"research_review":{"required":true,"adequate":false,"overall_support":"primary|secondary|context|none","evidence_indexes":[1],"target_coverage":[{"target":"exact requested target","support":"primary|secondary|context|none","evidence_indexes":[1]}],"missing_targets":["exact missing target"]}}',
     'Rules:',
     '- Use "continue" whenever any safe next step remains in this same run.',
     '- Use "complete" when the requested outcome is achieved, already done, or a no-op because there is nothing matching the request to change, and the latest draft is the finished user-facing answer.',
@@ -210,13 +220,37 @@ 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, fill research_review from the numbered evidence entries. Do not mark complete unless every requested target has concrete support.',
+    '- Search snippets, memory, and model priors are leads, not completion evidence. Prefer opened/fetched primary sources before "complete".',
+    '- Judge source quality semantically from the actual evidence summary. Tool names, call counts, local notes, and target words in tool arguments do not by themselves make evidence primary or prove a claim.',
+    '- evidence_indexes are the numeric parts of E identifiers from the Research evidence catalog. Never cite an entry that does not support the target.',
+    '- A real external blocker or genuinely required user input may be "blocked" even when research is incomplete. Name the missing dependency precisely; do not pretend more autonomous research can resolve user-only information.',
+    '- For "blocked", blocker_review.kind must identify the external dependency, resolvable_in_run must be false, and required_value must state what is missing. Otherwise choose "continue".',
+    '- 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}. Successful evidence candidates=${adequacy.evidenceCandidateCount}; unique calls=${adequacy.uniqueEvidenceCandidateCount}. Semantic target coverage has not been precomputed.`,
+    );
+  }
+  if (adequacy.structurallyReady === false) {
+    lines.push(
+      `- No source evidence is ready for review (${adequacy.reason}). Use "continue" unless the latest draft is a real external blocker.`,
+    );
+  }
+
+  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,
@@ -226,19 +260,215 @@ function buildCompletionDecisionPrompt({
       : '',
     `Current iteration: ${iteration} of ${maxIterations}.`,
     `Available tools in this run: ${summarizeAvailableTools(tools) || 'none'}`,
-    `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 8) || 'none'}`,
+    `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 12) || 'none'}`,
+    adequacy.intensity !== 'none'
+      ? `Research evidence catalog:\n${summarizeResearchEvidenceCatalog(toolExecutions) || 'none'}`
+      : '',
+    adequacy.intensity !== 'none'
+      ? `Research preflight: intensity=${adequacy.intensity}; structurally_ready=${adequacy.structurallyReady}; semantic_review_required=true; reason=${adequacy.reason}`
+      : '',
+    adequacy.targets.length
+      ? `Research targets: ${adequacy.targets.join('; ')}`
+      : '',
+    formatResearchAdequacyGuidance(adequacy),
     `Latest draft reply:\n${draftReply || '(empty)'}`,
   );
   return lines.filter(Boolean).join('\n');
 }
 
+function normalizeEvidenceIndexes(value) {
+  if (!Array.isArray(value)) return [];
+  return [...new Set(value
+    .map((entry) => Number(entry))
+    .filter((entry) => Number.isInteger(entry) && entry > 0))]
+    .slice(0, 20);
+}
+
+function normalizeResearchReview(raw = null) {
+  const review = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  const targetCoverage = Array.isArray(review.target_coverage || review.targetCoverage)
+    ? (review.target_coverage || review.targetCoverage)
+      .filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+      .map((entry) => ({
+        target: String(entry.target || '').trim(),
+        support: ['primary', 'secondary', 'context', 'none'].includes(
+          String(entry.support || '').trim().toLowerCase(),
+        )
+          ? String(entry.support).trim().toLowerCase()
+          : 'none',
+        evidence_indexes: normalizeEvidenceIndexes(
+          entry.evidence_indexes || entry.evidenceIndexes,
+        ),
+      }))
+      .filter((entry) => entry.target)
+      .slice(0, 12)
+    : [];
+  return {
+    required: review.required === true,
+    adequate: review.adequate === true,
+    overall_support: ['primary', 'secondary', 'context', 'none'].includes(
+      String(review.overall_support || review.overallSupport || '').trim().toLowerCase(),
+    )
+      ? String(review.overall_support || review.overallSupport).trim().toLowerCase()
+      : 'none',
+    evidence_indexes: normalizeEvidenceIndexes(
+      review.evidence_indexes || review.evidenceIndexes,
+    ),
+    target_coverage: targetCoverage,
+    missing_targets: normalizeGoalCriteria(
+      review.missing_targets || review.missingTargets || [],
+    ),
+  };
+}
+
 function normalizeCompletionDecision(raw, fallbackStatus = 'continue') {
   const allowed = new Set(['continue', 'complete', 'blocked']);
   const requestedStatus = String(raw.status || '').trim().toLowerCase();
+  const rawBlockerReview = raw.blocker_review || raw.blockerReview;
+  const blockerReview = rawBlockerReview
+    && typeof rawBlockerReview === 'object'
+    && !Array.isArray(rawBlockerReview)
+    ? rawBlockerReview
+    : {};
+  const blockerKind = String(blockerReview.kind || '').trim().toLowerCase();
   return {
     status: allowed.has(requestedStatus) ? requestedStatus : fallbackStatus,
     reason: String(raw.reason || '').trim().slice(0, 400),
+    blocker_review: {
+      kind: [
+        'user_input',
+        'permission',
+        'external_dependency',
+        'unavailable_capability',
+        'none',
+      ].includes(blockerKind)
+        ? blockerKind
+        : 'none',
+      resolvable_in_run: blockerReview.resolvable_in_run !== false
+        && blockerReview.resolvableInRun !== false,
+      required_value: String(
+        blockerReview.required_value || blockerReview.requiredValue || '',
+      ).trim().slice(0, 300),
+    },
+    research_review: normalizeResearchReview(
+      raw.research_review || raw.researchReview,
+    ),
+  };
+}
+
+function validateResearchReview(review, researchAdequacy, toolExecutions = []) {
+  if (!researchAdequacy || researchAdequacy.intensity === 'none') {
+    return { valid: true, reason: '' };
+  }
+  if (researchAdequacy.structurallyReady === false) {
+    return {
+      valid: false,
+      reason: researchAdequacy.reason || 'No successful source evidence is available.',
+    };
+  }
+  if (!review?.required || review.adequate !== true) {
+    return {
+      valid: false,
+      reason: 'The completion judge did not confirm adequate research evidence.',
+    };
+  }
+
+  const isValidEvidenceIndex = (index) => {
+    const execution = (Array.isArray(toolExecutions) ? toolExecutions : [])[index - 1];
+    return Boolean(
+      execution
+      && execution.ok === true
+      && execution.evidenceRelevant !== false
+      && execution.evidenceSource !== 'messaging',
+    );
   };
+  const hasValidEvidence = (indexes) => (
+    Array.isArray(indexes) && indexes.some(isValidEvidenceIndex)
+  );
+  const requiredTargets = Array.isArray(researchAdequacy.targets)
+    ? researchAdequacy.targets
+    : [];
+
+  if (requiredTargets.length === 0) {
+    const reviewIndexes = [
+      ...(review.evidence_indexes || []),
+      ...(review.target_coverage || []).flatMap((entry) => entry.evidence_indexes || []),
+    ];
+    if (!hasValidEvidence(reviewIndexes)) {
+      return { valid: false, reason: 'The research review cites no successful evidence entry.' };
+    }
+    if (researchAdequacy.intensity === 'deep' && review.overall_support !== 'primary') {
+      return { valid: false, reason: 'Deep research lacks primary source support.' };
+    }
+    if (review.overall_support === 'none') {
+      return { valid: false, reason: 'The research review did not classify its source support.' };
+    }
+    return { valid: true, reason: '' };
+  }
+
+  const coverageByTarget = new Map(
+    (review.target_coverage || []).map((entry) => [
+      String(entry.target || '').trim().toLowerCase(),
+      entry,
+    ]),
+  );
+  for (const target of requiredTargets) {
+    const coverage = coverageByTarget.get(String(target).trim().toLowerCase());
+    if (!coverage || coverage.support === 'none' || !hasValidEvidence(coverage.evidence_indexes)) {
+      return {
+        valid: false,
+        reason: `The research review does not cite supporting evidence for "${target}".`,
+      };
+    }
+    if (researchAdequacy.intensity === 'deep' && coverage.support !== 'primary') {
+      return {
+        valid: false,
+        reason: `Deep research still lacks primary evidence for "${target}".`,
+      };
+    }
+  }
+  return { valid: true, reason: '' };
+}
+
+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 (decision?.status === 'blocked') {
+    const blockerReview = decision.blocker_review;
+    if (
+      blockerReview
+      && blockerReview.kind !== 'none'
+      && blockerReview.resolvable_in_run === false
+      && blockerReview.required_value
+    ) {
+      return decision;
+    }
+    return {
+      ...decision,
+      status: 'continue',
+      reason: 'The completion judge did not substantiate a blocker that requires external input or state.',
+    };
+  }
+  if (decision?.status === 'complete') {
+    const reviewValidation = validateResearchReview(
+      decision.research_review,
+      researchAdequacy,
+      options.toolExecutions || [],
+    );
+    if (reviewValidation.valid) return decision;
+    return {
+      status: 'continue',
+      reason: reviewValidation.reason,
+      research_review: decision.research_review,
+    };
+  }
+  return decision;
 }
 
 // Intentionally lightweight (200-token cap, self-contained) so the model can
@@ -249,11 +479,18 @@ 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?',
-    'Schema: {"assessment":"progressing|churn|blocked","reason":"one short concrete sentence"}',
+    'Schema: {"assessment":"progressing|churn|blocked","reason":"one short concrete sentence","blocker_kind":"user_input|permission|external_dependency|unavailable_capability|none","resolvable_in_run":true}',
     '',
     `Context: ${readOnlyCount} consecutive iteration(s) with only read/search/inspect operations — no concrete state changes yet.`,
     alreadyRead ? `Already inspected: ${alreadyRead}.` : '',
@@ -263,21 +500,63 @@ function buildChurnAssessmentPrompt({
       : '',
     `Iteration: ${iteration}`,
     `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 6) || 'none'}`,
+    adequacy.intensity !== 'none'
+      ? `Research preflight: intensity=${adequacy.intensity}; evidence_candidates=${adequacy.evidenceCandidateCount}; semantic target coverage must be judged from the evidence summaries.`
+      : '',
+    adequacy.targets.length
+      ? `Requested research targets: ${adequacy.targets.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.',
+    '- Use "blocked" only with a non-none blocker_kind and resolvable_in_run=false. Partial evidence, a failed attempt, or uncertainty is not by itself an 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.structurallyReady === false
+      ? '- No successful source evidence exists yet. Prefer "progressing" if a concrete source-gathering step remains, but use "blocked" for a genuine external dependency or required user input.'
+      : '',
   ];
   return lines.filter(Boolean).join('\n');
 }
 
+function enforceChurnAssessment(assessment) {
+  const normalized = normalizeChurnAssessment(assessment);
+  if (
+    normalized.assessment === 'blocked'
+    && (
+      normalized.blocker_kind === 'none'
+      || normalized.resolvable_in_run !== false
+    )
+  ) {
+    return {
+      ...normalized,
+      assessment: 'churn',
+      reason: 'The churn assessment did not identify a concrete external blocker.',
+    };
+  }
+  return normalized;
+}
+
 function normalizeChurnAssessment(raw) {
   const allowed = new Set(['progressing', 'churn', 'blocked']);
   const assessment = String(raw?.assessment || '').trim().toLowerCase();
+  const blockerKind = String(raw?.blocker_kind || raw?.blockerKind || '').trim().toLowerCase();
   return {
     assessment: allowed.has(assessment) ? assessment : 'churn',
     reason: String(raw?.reason || '').trim().slice(0, 300),
+    blocker_kind: [
+      'user_input',
+      'permission',
+      'external_dependency',
+      'unavailable_capability',
+      'none',
+    ].includes(blockerKind)
+      ? blockerKind
+      : 'none',
+    resolvable_in_run: raw?.resolvable_in_run !== false
+      && raw?.resolvableInRun !== false,
   };
 }
 
@@ -285,11 +564,15 @@ module.exports = {
   buildChurnAssessmentPrompt,
   buildCompletionDecisionPrompt,
   buildGoalContractPrompt,
+  enforceTerminalReplyDecision,
   goalContractFromAnalysis,
   goalContractFromPlan,
   mergeGoalContracts,
+  enforceChurnAssessment,
   normalizeChurnAssessment,
   normalizeCompletionDecision,
+  normalizeResearchReview,
   normalizeGoalContract,
   resolveRunGoalContext,
+  validateResearchReview,
 };