neoagent 3.2.1-beta.9 → 3.3.0

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

@@ -2,14 +2,11 @@
 
 const { normalizeCompletionConfidence } = require('../completion');
 const { normalizeOutgoingMessage } = require('../messagingFallback');
-const {
-  isDeferredWorkReply,
-  isTerminalQuestionOrBlockerReply,
-} = require('../terminal_reply');
 const {
   assessResearchAdequacy,
   formatResearchAdequacyGuidance,
   summarizeAvailableTools,
+  summarizeResearchEvidenceCatalog,
   summarizeToolExecutions,
 } = require('../toolEvidence');
 
@@ -212,7 +209,7 @@ function buildCompletionDecisionPrompt({
   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.',
@@ -223,18 +220,26 @@ 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.`,
-    '- 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.',
+    '- 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}. Current coverage: primary=${adequacy.primarySourceCount}/${adequacy.requiredPrimarySources}, secondary=${adequacy.secondarySourceCount}, targets_covered=${adequacy.coveredTargets.length}/${Math.max(adequacy.requiredTargetCoverage, adequacy.targets.length)}.`,
+      `- 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.adequate === false) {
+  if (adequacy.structurallyReady === false) {
     lines.push(
-      `- Research is still incomplete (${adequacy.reason}). Use "continue" unless the latest draft is an explicit blocker naming the exact missing evidence.`,
+      `- No source evidence is ready for review (${adequacy.reason}). Use "continue" unless the latest draft is a real external blocker.`,
     );
   }
 
@@ -255,61 +260,212 @@ 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 adequacy: intensity=${adequacy.intensity}; adequate=${adequacy.adequate}; reason=${adequacy.reason}`
+      ? `Research preflight: intensity=${adequacy.intensity}; structurally_ready=${adequacy.structurallyReady}; semantic_review_required=true; 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');
 }
 
+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 enforceTerminalReplyDecision(decision, lastReply, options = {}) {
-  if (isDeferredWorkReply(lastReply)) {
+function validateResearchReview(review, researchAdequacy, toolExecutions = []) {
+  if (!researchAdequacy || researchAdequacy.intensity === 'none') {
+    return { valid: true, reason: '' };
+  }
+  if (researchAdequacy.structurallyReady === false) {
     return {
-      status: 'continue',
-      reason: 'The latest reply only announces or promises unfinished work; the run must continue or return a concrete blocker.',
+      valid: false,
+      reason: researchAdequacy.reason || 'No successful source evidence is available.',
     };
   }
-  if (decision?.status === 'continue' && isTerminalQuestionOrBlockerReply(lastReply)) {
+  if (!review?.required || review.adequate !== true) {
     return {
-      status: 'blocked',
-      reason: 'The latest reply asks for user input or states a concrete blocker, so the run must wait instead of repeating it.',
+      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 (
-    researchAdequacy
-    && researchAdequacy.adequate === false
-    && (decision?.status === 'complete' || decision?.status === 'blocked')
-    && !isTerminalQuestionOrBlockerReply(lastReply)
-  ) {
+  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: researchAdequacy.reason
-        || 'Research evidence is still incomplete for the requested targets; continue gathering sources before finishing.',
+      reason: reviewValidation.reason,
+      research_review: decision.research_review,
     };
   }
   return decision;
@@ -334,7 +490,7 @@ function buildChurnAssessmentPrompt({
   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}.` : '',
@@ -345,28 +501,62 @@ 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}.`
+      ? `Research preflight: intensity=${adequacy.intensity}; evidence_candidates=${adequacy.evidenceCandidateCount}; semantic target coverage must be judged from the evidence summaries.`
       : '',
-    adequacy.uncoveredTargets.length
-      ? `Still uncovered research targets: ${adequacy.uncoveredTargets.join('; ')}.`
+    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,
   };
 }
 
@@ -378,8 +568,11 @@ module.exports = {
   goalContractFromAnalysis,
   goalContractFromPlan,
   mergeGoalContracts,
+  enforceChurnAssessment,
   normalizeChurnAssessment,
   normalizeCompletionDecision,
+  normalizeResearchReview,
   normalizeGoalContract,
   resolveRunGoalContext,
+  validateResearchReview,
 };

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

@@ -153,8 +153,8 @@ const {
   buildDeterministicMessagingErrorReply,
   buildModelFailureLoopPrompt,
 } = require('../messagingFallback');
-const { isDeferredWorkReply } = require('../terminal_reply');
 const {
+  assessResearchAdequacy,
   classifyToolExecution,
   gatheredNewEvidence,
   isSubstantiveProgressToolName,
@@ -303,13 +303,34 @@ function summarizeReadTargets(toolExecutions = []) {
   return targets.join('; ');
 }
 
-function buildNoProgressWrapupPrompt({ readOnlyCount = 0, alreadyRead = '', platform = null } = {}) {
+function buildNoProgressWrapupPrompt({
+  readOnlyCount = 0,
+  alreadyRead = '',
+  platform = null,
+  researchAdequacy = null,
+} = {}) {
+  const adequacy = researchAdequacy && typeof researchAdequacy === 'object'
+    ? researchAdequacy
+    : null;
+  const researchIncomplete = adequacy
+    && adequacy.adequate === false
+    && adequacy.intensity
+    && adequacy.intensity !== 'none';
   return [
     `This is the final turn for this run (no further tool calls; ${Math.max(0, Number(readOnlyCount) || 0)} read-only turns without a state change).`,
     alreadyRead ? `Already gathered: ${alreadyRead}.` : '',
+    researchIncomplete
+      ? `Research coverage is incomplete: ${adequacy.reason || 'requested targets still lack primary evidence.'}`
+      : '',
+    researchIncomplete && adequacy.uncoveredTargets?.length
+      ? `Uncovered research targets: ${adequacy.uncoveredTargets.join('; ')}.`
+      : '',
     'Write the answer now from everything you have already gathered in this conversation. Deliver the useful result you DO have — calendar, weather, emails, search findings, whatever was collected — formatted as the actual answer to the original request.',
     'If one part could not be retrieved, still deliver everything else and note the missing part in at most one short clause. Never withhold a useful answer because a single detail is missing.',
-    'Only report a pure blocker if you genuinely gathered nothing usable at all. Do not describe the result as unfinished, unconfirmed, "blocked", or "still working" when you have something useful — this IS the final answer.',
+    'Do not invent entities, products, people, files, outcomes, or next-step work that is not already supported by tool evidence in this conversation.',
+    researchIncomplete
+      ? 'Because research is incomplete, clearly label assumptions and missing targets. Prefer a partial verified answer or a concrete blocker over a confident fabricated comparison.'
+      : 'Only report a pure blocker if you genuinely gathered nothing usable at all. Do not describe the result as unfinished, unconfirmed, "blocked", or "still working" when you have something useful — this IS the final answer.',
     buildMaxIterationWrapupPrompt(platform),
   ].filter(Boolean).join('\n\n');
 }
@@ -770,6 +791,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       ? {
         platform: options.source || null,
         chatId: options.chatId || null,
+        behavior: options.context?.socialIntelligence || null,
       }
       : null,
     goalContract: carriedGoalContract,
@@ -784,7 +806,9 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     progressLedger,
     goalContract: carriedGoalContract,
   });
-  engine.startMessagingProgressSupervisor(runId);
+  if (options.context?.socialIntelligence?.isGroup !== true) {
+    engine.startMessagingProgressSupervisor(runId);
+  }
   engine.emit(userId, 'run:start', {
     runId,
     agentId,
@@ -821,6 +845,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     userMessage,
     agentId,
     triggerSource,
+    memoryAudience: options.memoryAudience || 'owner',
   });
   // Pass short descriptions so the model always knows every available tool.
   // compactToolDefinition caps tool desc at 120 chars, param desc at 70 chars.
@@ -971,7 +996,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           // Reuse the run's real system prompt so the update follows the same voice and
           // formatting guidelines as every other message (single source of truth).
           const sysContent = [systemPrompt?.stable, systemPrompt?.dynamic].filter(Boolean).join('\n\n')
-            || 'You are a helpful assistant.';
+            || 'Respond directly and accurately using only the verified progress evidence.';
           const resp = await runAbortableModelCall(
             (signal) => provider.chat(
               [
@@ -1373,6 +1398,47 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
               continue;
             }
             alreadyRead = summarizeReadTargets(toolExecutions);
+            const researchAdequacyAtCap = assessResearchAdequacy({
+              analysis,
+              goalContext: runGoalCtx,
+              toolExecutions,
+            });
+            // Incomplete multi-target research is not "stuck" yet if primary sources
+            // remain uncovered. Give one guided research continuation instead of
+            // force-finishing with a guessed comparison.
+            if (
+              researchAdequacyAtCap.adequate === false
+              && researchAdequacyAtCap.intensity !== 'none'
+              && iterMeta
+              && iterMeta.researchAdequacyDeferralUsed !== true
+              && (
+                researchAdequacyAtCap.uncoveredTargets.length > 0
+                || researchAdequacyAtCap.primarySourceCount < researchAdequacyAtCap.requiredPrimarySources
+              )
+            ) {
+              iterMeta.researchAdequacyDeferralUsed = true;
+              iterMeta.consecutiveReadOnlyIterations = Math.max(0, churnNudgeThreshold - 1);
+              messages.push({
+                role: 'system',
+                content: [
+                  'Research self-check: evidence is still incomplete, so this run must not force-finish yet.',
+                  researchAdequacyAtCap.reason ? `Gap: ${researchAdequacyAtCap.reason}` : '',
+                  researchAdequacyAtCap.nextActions?.length
+                    ? `Next safe steps:\n- ${researchAdequacyAtCap.nextActions.join('\n- ')}`
+                    : '',
+                  'Open or fetch primary sources for uncovered targets now. Do not invent the missing comparison from memory or search snippets alone.',
+                ].filter(Boolean).join('\n'),
+              });
+              engine.recordRunEvent(userId, runId, 'read_only_wrapup_deferred_for_research', {
+                iteration,
+                readOnlyCount,
+                intensity: researchAdequacyAtCap.intensity,
+                uncoveredTargets: researchAdequacyAtCap.uncoveredTargets,
+                primarySourceCount: researchAdequacyAtCap.primarySourceCount,
+                requiredPrimarySources: researchAdequacyAtCap.requiredPrimarySources,
+              }, { agentId });
+              continue;
+            }
             triggerForceWrapup = true;
           } else if (readOnlyCount >= churnNudgeThreshold) {
             alreadyRead = summarizeReadTargets(toolExecutions);
@@ -1447,6 +1513,11 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
                         readOnlyCount,
                         alreadyRead,
                         platform: options?.source || null,
+                        researchAdequacy: assessResearchAdequacy({
+                          analysis,
+                          goalContext: runGoalCtx,
+                          toolExecutions,
+                        }),
                       }),
                     },
                   ]),
@@ -1466,8 +1537,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
               console.warn(`[Run ${shortenRunId(runId)}] no_progress_wrapup failed: ${summarizeForLog(wrapErr?.message || wrapErr, 180)}`);
             }
             totalTokens += wrapTokens;
-            const usableWrap = normalizeOutgoingMessage(lastContent, options?.source || null)
-              && !isDeferredWorkReply(lastContent);
+            const usableWrap = normalizeOutgoingMessage(lastContent, options?.source || null);
             if (!usableWrap) {
               lastContent = buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
             }
@@ -1697,15 +1767,6 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           lastContent = '';
           continue;
         }
-        if (engine.shouldFastCompleteVoiceReply({
-          options,
-          toolExecutions,
-          failedStepCount,
-          messagingSent: engine.activeRuns.get(runId)?.messagingSent || false,
-          lastReply: lastContent,
-        })) {
-          break;
-        }
         if (shouldContinueAfterBlankToolFailure({
           lastContent,
           failedStepCount,
@@ -1761,13 +1822,23 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           iteration,
         }, { agentId });
         if (loopDecision.decision.status === 'continue') {
+          const researchGuidance = loopDecision.researchAdequacy?.adequate === false
+            ? [
+              `Research still incomplete: ${loopDecision.researchAdequacy.reason || 'gather primary evidence for remaining targets.'}`,
+              loopDecision.researchAdequacy.nextActions?.length
+                ? `Next safe steps: ${loopDecision.researchAdequacy.nextActions.join(' ')}`
+                : '',
+            ].filter(Boolean).join(' ')
+            : '';
           messages.push({
             role: 'system',
             content: [
               'The run self-check determined the latest assistant text is not terminal.',
               'Continue with the next safe tool/model step.',
               'If the text was only a progress note, do not repeat it; either make progress or provide a real final/blocker reply.',
-            ].join(' '),
+              'Do not invent missing targets, outcomes, or tool results. Gather evidence or return a truthful partial/blocker answer.',
+              researchGuidance,
+            ].filter(Boolean).join(' '),
           });
           lastContent = '';
           continue;
@@ -2399,8 +2470,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
         // On budget exhaustion the model's last text is an untrustworthy mid-thought
         // fragment. Replace it with the wrap-up answer, or a clean deterministic
         // fallback if the wrap-up came back empty — never deliver the fragment.
-        const usableWrap = normalizeOutgoingMessage(wrapText, options?.source || null)
-          && !isDeferredWorkReply(wrapText);
+        const usableWrap = normalizeOutgoingMessage(wrapText, options?.source || null);
         lastContent = usableWrap
           ? wrapText
           : buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
@@ -2455,8 +2525,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       // evidence) instead of second-guessing it into a generic blob. Only fall back to
       // a deterministic message when the model returned nothing usable.
       const recoveredVisible = Boolean(
-        normalizeOutgoingMessage(lastContent, options?.source || null)
-        && !isDeferredWorkReply(lastContent),
+        normalizeOutgoingMessage(lastContent, options?.source || null),
       );
       if (!recoveredVisible) {
         lastContent = buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
@@ -2603,18 +2672,8 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       });
     }
 
-    if (!messagingSent && isDeferredWorkReply(finalResponseText)) {
-      engine.recordRunEvent(userId, runId, 'non_terminal_final_reply_rejected', {
-        iteration,
-        contentPreview: String(finalResponseText || '').slice(0, 240),
-      }, { agentId });
-      finalResponseText = buildDeterministicMessagingFallback({
-        failedStepCount,
-        stepIndex,
-        toolExecutions,
-      });
-      lastContent = finalResponseText;
-    }
+    // Final reply terminality is decided by the AI completion judge / task_complete path.
+    // Do not phrase-match natural-language drafts here.
 
     if (deliverableWorkflow && deliverablePlan) {
       engine.recordRunEvent(userId, runId, 'deliverable_validation_started', {
@@ -2883,7 +2942,6 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           const drafted = sanitizeModelOutput(modelReply.content || '', { model });
           if (
             normalizeOutgoingMessage(drafted, options?.source || null)
-            && !isDeferredWorkReply(drafted)
           ) {
             messagingFailureContent = drafted.trim();
           }