neoagent 3.2.1-beta.9 → 3.3.1-beta.0

package/server/services/ai/taskAnalysis.js

@@ -4,6 +4,7 @@ const COMPLEXITY_LEVELS = ['simple', 'standard', 'complex'];
 const AUTONOMY_LEVELS = ['minimal', 'normal', 'high'];
 const PROGRESS_UPDATE_POLICIES = ['none', 'optional', 'required'];
 const COMPLETION_CONFIDENCE_LEVELS = ['medium', 'high'];
+const DRAFT_STATUSES = ['final', 'needs_execution', 'needs_user_input'];
 const TASK_ANALYSIS_SUGGESTED_TOOLS_LIMIT = 12;
 const TASK_ANALYSIS_SUCCESS_CRITERIA_LIMIT = 8;
 const PLAN_STEP_SUGGESTED_TOOLS_LIMIT = 8;
@@ -17,14 +18,15 @@ const TASK_ANALYSIS_CONFIDENCE_DEFAULT = 0.55;
 const VERIFICATION_CONFIDENCE_VERIFIED = 0.85;
 const VERIFICATION_CONFIDENCE_DEFAULT = 0.5;
 const JSON_ONLY_RESPONSE_RULE = 'Return JSON only. No markdown, no prose, no code fences.';
-const { isDeferredWorkReply } = require('./terminal_reply');
 const ANALYSIS_SCHEMA_EXAMPLE = {
   mode: 'execute',
   needs_verification: true,
   draft_reply: '',
+  draft_status: 'needs_execution',
   goal: 'Answer the user accurately.',
   success_criteria: ['Final reply is correct and specific.'],
   research_targets: [],
+  research_depth: 'none',
   suggested_tools: ['web_search', 'browser_navigate'],
   complexity: 'standard',
   autonomy_level: 'normal',
@@ -45,11 +47,13 @@ const PLAN_SCHEMA_EXAMPLE = {
   verification_focus: ['Confirm the most time-sensitive claim before replying.'],
 };
 const ANALYSIS_PROMPT_INSTRUCTIONS = [
-  'Choose the lightest routing mode that still handles the task well.',
-  'Use mode="direct_answer" only when a final user-facing reply can be given immediately without tool work.',
-  'For short immediate questions, greetings, small explanations, or quick conversational replies, prefer mode="direct_answer" with progress_update_policy="none"; speed matters more than creating plans or tasks.',
+  'Choose the lightest routing mode that still handles the task well. Prefer speed for simple work and depth only when the request needs tools or multi-step evidence.',
+  'Use mode="direct_answer" only when a final user-facing reply can be given immediately without tool work. The draft_reply must be the actual answer, not a promise to check later.',
+  'Set draft_status="final" only when draft_reply fully answers the request now. Use "needs_execution" when any autonomous work remains, and "needs_user_input" only when the draft asks for information that is genuinely required before work can continue.',
+  'For short immediate questions, greetings, small explanations, quick conversational replies, or pure opinion/advice that does not need live lookup, prefer mode="direct_answer" with progress_update_policy="none", complexity="simple", autonomy_level="minimal", and an empty research_targets list. Speed matters more than creating plans or tasks.',
   'Use mode="execute" for normal tool-driven work without a separate planning step.',
   'Use mode="plan_execute" only when the task is genuinely multi-step, broad, or coordination-heavy.',
+  'Never invent entities, products, people, files, or outcomes to fill gaps. If the user refers to multiple targets but only one is known, ask once or research only the known ones and mark the rest unknown.',
   'Set needs_verification=true when the final answer should be checked against tool evidence before it is sent.',
   'Set goal to a concise restatement of what the user is asking for in this message. Never leave goal empty.',
   'Keep goal and success_criteria short and practical.',
@@ -61,6 +65,7 @@ const ANALYSIS_PROMPT_INSTRUCTIONS = [
   'Set parallel_work=true when independent tool calls or subagents can materially reduce latency.',
   'Set completion_confidence_required="high" when wrong completion would be costly, state-changing, user-visible, or hard to recover.',
   'For research, product/device comparisons, reviews, fact-checks, or multi-entity look-into requests, use mode="execute" or mode="plan_execute", never direct_answer. Set needs_verification=true, freshness_risk="possible" or higher, and completion_confidence_required="high".',
+  'Set research_depth="none" when external source research is not needed, "light" for a focused lookup, and "deep" for comparisons, multi-source synthesis, disputed claims, or broad investigation. This is the authoritative research-routing field; do not infer it from tool names.',
   'When the user asks to look into multiple devices, products, options, or entities, put each named target into research_targets and success_criteria and keep them exact. Prefer suggested_tools that can open primary sources (web_search plus browser_navigate/http_request) rather than answering from memory.',
 ];
 const PLAN_PROMPT_INSTRUCTIONS = [
@@ -87,7 +92,9 @@ const VERIFIER_PROMPT_INSTRUCTIONS = [
   'If external evidence conflicts with memory, history, or another tool result, preserve the uncertainty instead of flattening it into a single confident claim.',
   'When the draft reply is already correct and fully supported by the evidence, return it unchanged. Do not rewrite for style.',
   'For multi-entity research or comparison replies, every compared target needs supporting tool evidence. If a target was never searched or opened, mark insufficient_evidence and rewrite the reply so it does not invent that target\'s specs.',
+  'Do not invent missing targets, products, people, or outcomes. If the draft invents an entity that is not in the task and not in tool evidence, rewrite it out or mark insufficient_evidence.',
   'Search-result snippets alone are weak evidence for concrete product claims. Prefer opened pages, fetched docs, or other primary tool output. If only snippets exist, either keep the claim clearly provisional or mark missing_evidence.',
+  'Set safe_to_deliver=true only when final_reply is fully supported or has been rewritten into a truthful, clearly limited partial answer with every unsupported claim removed. Otherwise set it false.',
 ];
 const EXECUTION_GUIDANCE_ACTION_LINES = [
   'Act end-to-end. Run independent searches or inspections in parallel when possible. Prefer native integration tools and structured APIs over browser automation or shell scraping. Use exact IDs and required parameters; list or search first when you do not have them.',
@@ -111,6 +118,7 @@ function buildVerifierSchemaExample(finalReply) {
     evidence_sources: ['web_search'],
     missing_evidence: [],
     final_reply: finalReply || '',
+    safe_to_deliver: true,
     confidence: 0.83,
   };
 }
@@ -256,6 +264,10 @@ function promoteAnalysisMode(initialMode, { verificationNeed, freshnessRisk, dra
 function isDirectAnswerEligibleAnalysis(analysis) {
   if (!analysis || typeof analysis !== 'object') return false;
   const draftReply = String(analysis.draft_reply || '').trim();
+  const draftStatus = String(analysis.draft_status || '').trim().toLowerCase();
+  const researchTargets = Array.isArray(analysis.research_targets)
+    ? analysis.research_targets.filter(Boolean)
+    : [];
   const promotedMode = promoteAnalysisMode(analysis.mode, {
     verificationNeed: analysis.verification_need,
     freshnessRisk: analysis.freshness_risk,
@@ -263,10 +275,16 @@ function isDirectAnswerEligibleAnalysis(analysis) {
     planningDepth: analysis.planning_depth,
   });
 
+  // Direct answers are for zero-tool replies only. Any research targets or
+  // freshness/verification burden must enter the tool loop.
   return promotedMode === 'direct_answer'
     && !analysis.needs_subagents
     && Boolean(draftReply)
-    && !isDeferredWorkReply(draftReply);
+    && (draftStatus === 'final' || draftStatus === 'needs_user_input')
+    && researchTargets.length === 0
+    && String(analysis.research_depth || 'none') === 'none'
+    && String(analysis.verification_need || 'none') === 'none'
+    && String(analysis.freshness_risk || 'none') === 'none';
 }
 
 function extractJsonCandidate(text) {
@@ -330,8 +348,18 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
     'researchTargets',
     TASK_ANALYSIS_SUCCESS_CRITERIA_LIMIT,
   );
+  const declaredResearchDepth = pickEnum(
+    resolveAliasedValue(raw, fallback, 'research_depth', 'researchDepth', ''),
+    ['none', 'light', 'deep'],
+    '',
+  );
 
   const draftReply = resolveAliasedText(raw, fallback, 'draft_reply', 'draftReply', '');
+  const draftStatus = pickEnum(
+    resolveAliasedValue(raw, fallback, 'draft_status', 'draftStatus', ''),
+    DRAFT_STATUSES,
+    'needs_execution',
+  );
   const initialMode = pickEnum(
     raw.mode || fallback.mode,
     ANALYSIS_MODES,
@@ -377,13 +405,52 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
     ['none', 'possible', 'high'],
     freshnessRiskFor({ verificationNeed })
   );
+  let researchDepth = declaredResearchDepth;
+  if (researchTargets.length >= 2) {
+    researchDepth = 'deep';
+  } else if (researchTargets.length === 1 && researchDepth === 'none') {
+    researchDepth = 'light';
+  } else if (!researchDepth) {
+    if (freshnessRisk === 'high') {
+      researchDepth = 'deep';
+    } else if (freshnessRisk === 'possible') {
+      researchDepth = 'light';
+    } else {
+      researchDepth = 'none';
+    }
+  }
 
-  const mode = promoteAnalysisMode(initialMode, {
+  let mode = promoteAnalysisMode(initialMode, {
     verificationNeed,
     freshnessRisk,
     draftReply,
     planningDepth,
   });
+  if (mode === 'direct_answer' && draftStatus === 'needs_execution') {
+    mode = 'execute';
+  }
+  if (mode === 'direct_answer' && researchDepth !== 'none') {
+    mode = 'execute';
+  }
+
+  // Structural promotion: explicit research targets require tool work.
+  if (researchTargets.length > 0 && mode === 'direct_answer') {
+    mode = planningDepth === 'deep' || researchTargets.length >= 2 ? 'plan_execute' : 'execute';
+  }
+
+  let effectiveVerificationNeed = verificationNeed;
+  let effectiveFreshnessRisk = freshnessRisk;
+  if (researchTargets.length > 0) {
+    if (effectiveVerificationNeed === 'none') {
+      effectiveVerificationNeed = researchTargets.length >= 2 ? 'required' : 'light';
+    }
+    if (effectiveFreshnessRisk === 'none') {
+      effectiveFreshnessRisk = researchTargets.length >= 2 ? 'possible' : 'possible';
+    }
+    if (mode === 'execute' && researchTargets.length >= 2) {
+      mode = 'plan_execute';
+    }
+  }
 
   const normalizedComplexity = pickEnum(
     resolveAliasedValue(raw, fallback, 'complexity', 'complexity', ''),
@@ -398,20 +465,22 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
 
   return {
     mode,
-    freshness_risk: freshnessRisk,
-    verification_need: verificationNeed,
-    planning_depth: planningDepth,
+    freshness_risk: effectiveFreshnessRisk,
+    verification_need: effectiveVerificationNeed,
+    planning_depth: mode === 'plan_execute' ? 'deep' : mode === 'direct_answer' ? 'none' : 'light',
     confidence: clampConfidence(
       raw.confidence ?? fallback.confidence,
       draftReply ? TASK_ANALYSIS_CONFIDENCE_WITH_DRAFT : TASK_ANALYSIS_CONFIDENCE_DEFAULT,
     ),
     suggested_tools: suggestedTools,
     needs_subagents: resolveAliasedBoolean(raw, fallback, 'needs_subagents', 'needsSubagents'),
-    needs_verification: verificationNeed !== 'none',
+    needs_verification: effectiveVerificationNeed !== 'none',
     draft_reply: draftReply,
+    draft_status: draftStatus,
     goal: resolveAliasedText(raw, fallback, 'goal', 'goal', ''),
     success_criteria: successCriteria,
     research_targets: researchTargets,
+    research_depth: researchDepth,
     complexity: mode === 'plan_execute' ? 'complex' : normalizedComplexity,
     autonomy_level: mode === 'plan_execute' ? 'high' : normalizedAutonomyLevel,
     progress_update_policy: pickEnum(
@@ -423,7 +492,9 @@ function normalizeTaskAnalysis(raw = {}, fallback = {}) {
     completion_confidence_required: pickEnum(
       resolveAliasedValue(raw, fallback, 'completion_confidence_required', 'completionConfidenceRequired', ''),
       COMPLETION_CONFIDENCE_LEVELS,
-      verificationNeed === 'required' || mode === 'plan_execute' ? 'high' : 'medium',
+      effectiveVerificationNeed === 'required' || mode === 'plan_execute' || researchTargets.length >= 2
+        ? 'high'
+        : 'medium',
     ),
   };
 }
@@ -507,6 +578,8 @@ function normalizeVerificationResult(raw = {}, fallbackReply = '') {
   if (status === 'verified' && missingEvidence.length > 0) {
     status = 'insufficient_evidence';
   }
+  const safeToDeliver = status === 'verified'
+    || resolveAliasedBoolean(raw, null, 'safe_to_deliver', 'safeToDeliver', false);
 
   return {
     status,
@@ -519,7 +592,8 @@ function normalizeVerificationResult(raw = {}, fallbackReply = '') {
       VERIFICATION_EVIDENCE_SOURCES_LIMIT,
     ),
     missing_evidence: missingEvidence,
-    final_reply: finalReply,
+    final_reply: safeToDeliver ? finalReply : '',
+    safe_to_deliver: safeToDeliver,
     confidence: clampConfidence(
       raw.confidence,
       status === 'verified' ? VERIFICATION_CONFIDENCE_VERIFIED : VERIFICATION_CONFIDENCE_DEFAULT,

package/server/services/ai/toolEvidence.js

@@ -200,41 +200,6 @@ function isSubstantiveProgressToolName(toolName = '') {
   return true;
 }
 
-const PRIMARY_RESEARCH_SOURCES = new Set([
-  'browser',
-  'http',
-  'integration',
-  'files',
-  'command',
-  'mcp',
-  'android',
-  'data',
-  'vision',
-  'skills',
-  'subagent',
-]);
-
-const SECONDARY_RESEARCH_SOURCES = new Set([
-  'search',
-  'memory',
-]);
-
-// External/source-backed tools only. Local file/edit/shell work must not
-// inherit a research burden just because inspection tools are available.
-const RESEARCH_TOOL_HINTS = new Set([
-  'web_search',
-  'http_request',
-  'browser_navigate',
-  'browser_open',
-  'browser_click',
-  'browser_type',
-  'browser_snapshot',
-  'browser_evaluate',
-  'analyze_image',
-  'spawn_subagent',
-  'delegate_to_agent',
-]);
-
 function clampResearchText(value, maxChars = 220) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
   if (!text) return '';
@@ -257,88 +222,29 @@ function uniqueResearchTokens(values = [], { limit = 12 } = {}) {
   return tokens;
 }
 
-// Structural target extraction only: quoted spans and product-like proper names.
-// No phrase-based intent filters.
-function isProductLikeToken(token = '') {
-  const value = String(token || '').trim();
-  if (!value) return false;
-  if (/[0-9]/.test(value)) return true;
-  if (/[-_/]/.test(value)) return true;
-  if (/[a-z][A-Z]/.test(value)) return true;
-  return false;
-}
-
-function extractResearchTargets(text = '') {
-  const raw = String(text || '');
-  if (!raw.trim()) return [];
-
-  const targets = [];
-  const quoted = raw.match(/["“”'‘’`]([^"“”'‘’`]{2,80})["“”'‘’`]/g) || [];
-  for (const match of quoted) {
-    const cleaned = match.replace(/^["“”'‘’`]|["“”'‘’`]$/g, '').trim();
-    if (cleaned) targets.push(cleaned);
-  }
-
-  // Require each subsequent token to start with a capital letter or digit so
-  // ordinary sentence fragments ("Implement the pause...") do not become targets.
-  const productish = raw.match(
-    /\b[A-Z][A-Za-z0-9+./-]*(?:[ -][A-Z0-9][A-Za-z0-9+./-]*){0,5}\b/g,
-  ) || [];
-  for (const match of productish) {
-    const cleaned = match.replace(/\s+/g, ' ').trim();
-    const parts = cleaned.split(/\s+/).filter(Boolean);
-    if (parts.length === 0) continue;
-    if (parts.length === 1) {
-      if (!isProductLikeToken(parts[0]) || parts[0].length < 4) continue;
-    } else if (!parts.some(isProductLikeToken) && parts.length < 2) {
-      continue;
-    } else if (!parts.some(isProductLikeToken) && parts.every((part) => part.length <= 3)) {
-      continue;
-    }
-    // Drop pure sentence openers with no product-like signal.
-    if (parts.length >= 2 && !parts.some(isProductLikeToken)) {
-      // Keep multi-token proper names such as brand + model family only when
-      // at least one token is long enough to be a meaningful entity name.
-      if (!parts.some((part) => part.length >= 5)) continue;
-    }
-    targets.push(cleaned);
-  }
-
-  return uniqueResearchTokens(targets, { limit: 8 });
-}
-
+// Research targets come from structured task analysis / goal contract only.
+// Do not NLP-extract entity names from free text.
 function collectResearchTargets(analysis = null, goalContext = null) {
-  const explicit = uniqueResearchTokens([
+  return uniqueResearchTokens([
     ...(Array.isArray(analysis?.research_targets) ? analysis.research_targets : []),
     ...(Array.isArray(goalContext?.researchTargets) ? goalContext.researchTargets : []),
   ], { limit: 8 });
-  if (explicit.length > 0) return explicit;
-
-  const goalText = [
-    goalContext?.effectiveGoal,
-    analysis?.goal,
-    ...(Array.isArray(goalContext?.successCriteria) ? goalContext.successCriteria : []),
-    ...(Array.isArray(analysis?.success_criteria) ? analysis.success_criteria : []),
-  ].filter(Boolean).join(' ');
-
-  return extractResearchTargets(goalText);
-}
-
-function hasResearchToolHint(analysis = null) {
-  const tools = Array.isArray(analysis?.suggested_tools) ? analysis.suggested_tools : [];
-  return tools.some((name) => {
-    const tool = String(name || '').trim().toLowerCase();
-    if (!tool) return false;
-    if (RESEARCH_TOOL_HINTS.has(tool)) return true;
-    return tool.startsWith('browser_')
-      || tool.startsWith('mcp_')
-      || tool === 'web_search'
-      || tool.includes('web_search')
-      || tool.includes('http_request');
-  });
 }
 
 function resolveResearchIntensity(analysis = null, goalContext = null) {
+  const declaredDepth = String(
+    analysis?.research_depth
+    || analysis?.researchDepth
+    || '',
+  ).trim().toLowerCase();
+  const declaredTargets = collectResearchTargets(analysis, goalContext);
+  if (
+    ['none', 'light', 'deep'].includes(declaredDepth)
+    && !(declaredDepth === 'none' && declaredTargets.length > 0)
+  ) {
+    return declaredDepth;
+  }
+
   const mode = String(analysis?.mode || '').trim().toLowerCase();
   const complexity = String(
     goalContext?.effectiveComplexity
@@ -358,21 +264,16 @@ function resolveResearchIntensity(analysis = null, goalContext = null) {
   const verificationNeed = String(analysis?.verification_need || '').trim().toLowerCase();
   const freshnessRisk = String(analysis?.freshness_risk || '').trim().toLowerCase();
   const planningDepth = String(analysis?.planning_depth || '').trim().toLowerCase();
-  const targets = collectResearchTargets(analysis, goalContext);
-  const researchToolHint = hasResearchToolHint(analysis);
+  const targets = declaredTargets;
 
   if (mode === 'direct_answer' && verificationNeed === 'none' && freshnessRisk === 'none') {
     return 'none';
   }
 
-  // External/source-backed work only. Pure local implementation tasks must not
-  // inherit a research burden just because they are complex or multi-step.
   const needsExternalEvidence = (
     targets.length > 0
-    || researchToolHint
     || freshnessRisk === 'possible'
     || freshnessRisk === 'high'
-    || verificationNeed === 'required'
   );
   if (!needsExternalEvidence) {
     return 'none';
@@ -403,32 +304,32 @@ function isSuccessfulResearchExecution(item = {}) {
   return Boolean(item.evidenceRelevant || item.dependsOnOutput || item.stateChanged);
 }
 
-function isPrimaryResearchSource(source = '') {
-  return PRIMARY_RESEARCH_SOURCES.has(String(source || '').trim().toLowerCase());
+function selectResearchEvidenceCandidates(toolExecutions = [], maxItems = 80) {
+  const candidates = (Array.isArray(toolExecutions) ? toolExecutions : [])
+    .map((execution, index) => ({ execution, evidenceIndex: index + 1 }))
+    .filter(({ execution }) => isSuccessfulResearchExecution(execution));
+  if (candidates.length <= maxItems) return candidates;
+
+  const firstCount = Math.floor(maxItems / 4);
+  return [
+    ...candidates.slice(0, firstCount),
+    ...candidates.slice(-(maxItems - firstCount)),
+  ];
 }
 
-function isSecondaryResearchSource(source = '') {
-  return SECONDARY_RESEARCH_SOURCES.has(String(source || '').trim().toLowerCase());
+function summarizeResearchEvidenceCatalog(toolExecutions = [], maxItems = 80) {
+  return selectResearchEvidenceCandidates(toolExecutions, maxItems)
+    .map(({ execution, evidenceIndex }) => (
+      `E${evidenceIndex}. ${execution.toolName} [${execution.evidenceSource || 'tool'}] :: ${clampRunContext(execution.summary || '', 160)}`
+    ))
+    .join('\n');
 }
 
-function executionMentionsTarget(execution = {}, target = '') {
-  const needle = String(target || '').trim().toLowerCase();
-  if (!needle) return false;
-  const haystack = [
-    execution.summary,
-    execution.toolName,
-    execution.evidenceSource,
-    JSON.stringify(execution.input || {}),
-  ].join(' ').toLowerCase();
-  if (haystack.includes(needle)) return true;
-
-  const tokens = needle
-    .split(/[^a-z0-9+]+/i)
-    .map((token) => token.trim())
-    .filter((token) => token.length >= 3);
-  if (tokens.length === 0) return false;
-  const matched = tokens.filter((token) => haystack.includes(token)).length;
-  return matched >= Math.min(2, tokens.length);
+function researchExecutionSignature(execution = {}) {
+  return JSON.stringify([
+    String(execution.toolName || '').trim(),
+    execution.input && typeof execution.input === 'object' ? execution.input : {},
+  ]);
 }
 
 function assessResearchAdequacy({
@@ -441,111 +342,53 @@ function assessResearchAdequacy({
 
   const successful = (Array.isArray(toolExecutions) ? toolExecutions : [])
     .filter(isSuccessfulResearchExecution);
-  const primary = successful.filter((item) => isPrimaryResearchSource(item.evidenceSource));
-  const secondary = successful.filter((item) => isSecondaryResearchSource(item.evidenceSource));
-  const coveredTargets = targets.filter((target) => (
-    successful.some((item) => executionMentionsTarget(item, target))
-  ));
-  const primaryCoveredTargets = targets.filter((target) => (
-    primary.some((item) => executionMentionsTarget(item, target))
-  ));
-  const uncoveredTargets = targets.filter((target) => !coveredTargets.includes(target));
-  const primaryUncoveredTargets = targets.filter((target) => !primaryCoveredTargets.includes(target));
-
-  const requiredPrimarySources = intensity === 'deep'
-    ? (targets.length > 0 ? Math.min(4, targets.length) : 2)
-    : intensity === 'light'
-      ? 1
-      : 0;
-  const requiredSecondarySources = intensity === 'deep' ? 1 : 0;
-  const requiredTargetCoverage = intensity === 'deep'
-    ? targets.length
-    : intensity === 'light'
-      ? Math.min(targets.length, 1)
-      : 0;
-  const requiredPrimaryTargetCoverage = intensity === 'deep'
-    ? targets.length
-    : 0;
-
-  const missing = [];
-  if (primary.length < requiredPrimarySources) {
-    missing.push(
-      `Need ${requiredPrimarySources} primary source open/fetch/inspect step(s); have ${primary.length}.`,
-    );
-  }
-  if (secondary.length < requiredSecondarySources && primary.length < requiredPrimarySources) {
-    missing.push('Need at least one search lead before finishing deep research.');
-  }
-  if (targets.length > 0 && coveredTargets.length < requiredTargetCoverage) {
-    missing.push(
-      `Need evidence for: ${uncoveredTargets.slice(0, 4).join('; ') || targets.slice(0, 4).join('; ')}.`,
-    );
-  }
-  if (targets.length > 0 && primaryCoveredTargets.length < requiredPrimaryTargetCoverage) {
-    missing.push(
-      `Need primary-source evidence for: ${primaryUncoveredTargets.slice(0, 4).join('; ') || targets.slice(0, 4).join('; ')}.`,
-    );
-  }
-  if (intensity === 'deep' && primary.length === 0 && secondary.length > 0) {
-    missing.push('Search snippets alone are not enough; open primary sources for the key claims.');
-  }
-  if (intensity === 'light' && primary.length === 0 && secondary.length === 0) {
-    missing.push('Need at least one successful search or primary-source check before finishing.');
-  }
-
-  const adequate = intensity === 'none' ? true : missing.length === 0;
+  const uniqueEvidenceCandidateCount = new Set(
+    successful.map((item) => researchExecutionSignature(item)),
+  ).size;
+  const structurallyReady = intensity === 'none' || uniqueEvidenceCandidateCount > 0;
+  const missing = structurallyReady
+    ? []
+    : ['No successful source-bearing tool evidence is available for semantic review.'];
   const nextActions = [];
-  if (!adequate) {
-    if (primaryUncoveredTargets.length > 0) {
-      nextActions.push(
-        `Open or fetch primary sources for each remaining target: ${primaryUncoveredTargets.slice(0, 4).join('; ')}.`,
-      );
-    } else if (uncoveredTargets.length > 0) {
-      nextActions.push(
-        `Research each remaining target separately: ${uncoveredTargets.slice(0, 4).join('; ')}.`,
-      );
-    }
-    if (primary.length < requiredPrimarySources) {
-      nextActions.push('Open or fetch primary pages/docs for the remaining claims instead of guessing from memory or snippets.');
-    }
-    if (secondary.length === 0 && intensity === 'deep') {
-      nextActions.push('Run targeted searches, then open the strongest sources.');
-    }
+  if (!structurallyReady) {
+    nextActions.push('Gather source-backed evidence before requesting completion.');
+  } else if (intensity !== 'none') {
+    nextActions.push('Have the completion judge map each requested target to concrete evidence entries and assess source quality.');
   }
 
   return {
     intensity,
-    adequate,
-    requiredPrimarySources,
-    requiredSecondarySources,
-    requiredTargetCoverage,
-    requiredPrimaryTargetCoverage,
-    primarySourceCount: primary.length,
-    secondarySourceCount: secondary.length,
+    adequate: structurallyReady,
+    structurallyReady,
+    semanticReviewRequired: intensity !== 'none',
+    evidenceCandidateCount: successful.length,
+    uniqueEvidenceCandidateCount,
     targets,
-    coveredTargets,
-    primaryCoveredTargets,
-    uncoveredTargets,
-    primaryUncoveredTargets,
+    coveredTargets: [],
+    primaryCoveredTargets: [],
+    uncoveredTargets: intensity === 'none' ? [] : targets,
+    primaryUncoveredTargets: intensity === 'none' ? [] : targets,
     missing,
     nextActions,
-    reason: adequate
+    reason: structurallyReady
       ? (intensity === 'none'
         ? 'No research burden for this run.'
-        : 'Research evidence covers the requested targets.')
+        : 'Source candidates exist; the AI completion judge must still validate target coverage and source quality.')
       : clampResearchText(missing.join(' ') || 'Research evidence is still incomplete.', 320),
   };
 }
 
 function formatResearchAdequacyGuidance(assessment = null) {
-  if (!assessment || assessment.adequate !== false) return '';
+  if (!assessment || assessment.intensity === 'none') return '';
   const lines = [
-    'Research self-check: evidence is still incomplete for this run.',
+    assessment.structurallyReady
+      ? 'Research self-check: source candidates exist, but semantic target coverage is not inferred from tool names, arguments, or token overlap.'
+      : 'Research self-check: no successful source evidence is available yet.',
     assessment.reason ? `Gap: ${assessment.reason}` : '',
     assessment.nextActions?.length
       ? `Next safe steps:\n- ${assessment.nextActions.join('\n- ')}`
       : '',
-    'Do not complete with memory, guesses, or a partial comparison while these gaps remain. Gather the missing evidence first, or return a blocker that names exactly what could not be verified.',
+    'The completion judge must explicitly map every requested target to supporting evidence and judge whether that evidence is primary, secondary, or merely contextual.',
   ];
   return lines.filter(Boolean).join('\n');
 }
@@ -625,12 +468,13 @@ module.exports = {
   classifyToolExecution,
   deriveEvidenceSource,
   assessResearchAdequacy,
-  extractResearchTargets,
   formatResearchAdequacyGuidance,
   gatheredNewEvidence,
   isSubstantiveProgressEvidence,
   isSubstantiveProgressToolName,
   resolveResearchIntensity,
+  selectResearchEvidenceCandidates,
+  summarizeResearchEvidenceCatalog,
   summarizeProgressToolExecutions,
   summarizeToolExecutions,
   summarizeAvailableTools,