neoagent 2.5.2-beta.3 → 2.5.2-beta.5

package/server/services/ai/engine.js

@@ -117,6 +117,7 @@ const MESSAGING_PROGRESS_REPEAT_MS = 90 * 1000;
 const MESSAGING_PROGRESS_STALL_MS = 240 * 1000;
 const MESSAGING_PROGRESS_TICK_MS = 15 * 1000;
 const GOAL_CONTRACT_SUCCESS_CRITERIA_LIMIT = 12;
+const MODEL_CALL_TIMEOUT_MS = 5 * 60 * 1000;
 
 function isoNow() {
   return new Date().toISOString();
@@ -136,6 +137,62 @@ function formatElapsedDuration(durationMs) {
   return `${minutes}m ${seconds}s`;
 }
 
+function normalizeErrorKey(errorMsg) {
+  const msg = String(errorMsg || '').toLowerCase();
+  if (/outside.*(workspace|per-user)/i.test(msg)) return 'outside_workspace';
+  if (/eisdir|illegal operation on a directory/i.test(msg)) return 'eisdir';
+  if (/enoent|no such file/i.test(msg)) return 'enoent';
+  if (/can.?t cd to|no such directory/i.test(msg)) return 'bad_cwd';
+  if (/not found/i.test(msg)) return 'not_found';
+  return msg.slice(0, 60);
+}
+
+function trackErrorPattern(errorMsg, runMeta) {
+  if (!errorMsg) return;
+  const key = normalizeErrorKey(errorMsg);
+  if (!runMeta.errorPatterns) runMeta.errorPatterns = new Map();
+  runMeta.errorPatterns.set(key, (runMeta.errorPatterns.get(key) || 0) + 1);
+}
+
+function buildErrorPatternGuidance(key, count) {
+  if (count < 3) return null;
+  const guides = {
+    outside_workspace: 'read_file cannot access /tmp paths. Use execute_command with `cat <path>` instead.',
+    eisdir: 'That path is a directory, not a file. Use list_directory or execute_command with `ls` to inspect it.',
+    enoent: 'That path does not exist. Use execute_command with `find . -name "..."` to locate the correct path first.',
+    bad_cwd: 'The VM home directory is not ~/. Use absolute paths starting from /tmp or discover the workspace root first.',
+    not_found: 'This path or resource was not found. Try listing the parent directory or checking with a broader search first.',
+  };
+  const guide = guides[key];
+  if (!guide) return null;
+  return `REPEATED ERROR (${count}×): ${guide}`;
+}
+
+function resolveModelCallTimeoutMs(options = {}) {
+  const requested = Number(options?.modelCallTimeoutMs);
+  if (Number.isFinite(requested) && requested > 0) {
+    return Math.max(10, requested);
+  }
+  return MODEL_CALL_TIMEOUT_MS;
+}
+
+async function withModelCallTimeout(promise, options = {}, label = 'Model call') {
+  const timeoutMs = resolveModelCallTimeoutMs(options);
+  let timer = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const error = new Error(`${label} timed out after ${formatElapsedDuration(timeoutMs)}.`);
+      error.code = 'MODEL_CALL_TIMEOUT';
+      reject(error);
+    }, timeoutMs);
+  });
+  try {
+    return await Promise.race([Promise.resolve(promise), timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 function cloneInterimHistory(history = []) {
   if (!Array.isArray(history)) return [];
   return history.map((item) => ({
@@ -187,6 +244,23 @@ function hasVisibleInterimActivity(runMeta) {
   );
 }
 
+function requireSuccessfulMessagingDelivery(result, label = 'Messaging delivery') {
+  if (result?.success === true && result?.suppressed !== true) {
+    return result;
+  }
+  const reason = String(
+    result?.error
+    || result?.reason
+    || result?.result?.error
+    || result?.result?.reason
+    || 'the platform did not confirm delivery',
+  ).trim();
+  const error = new Error(`${label} failed: ${reason}`);
+  error.code = 'MESSAGING_DELIVERY_FAILED';
+  error.deliveryResult = result || null;
+  throw error;
+}
+
 function normalizeGoalCriteria(value) {
   if (!Array.isArray(value)) return [];
   const seen = new Set();
@@ -257,7 +331,7 @@ function mergeGoalContracts(existing = null, patch = null) {
   const nextPatch = normalizeGoalContract(patch) || null;
   if (!current && !nextPatch) return null;
 
-  const goal = String(nextPatch?.goal || current?.goal || '').trim();
+  const goal = String(current?.goal || nextPatch?.goal || '').trim();
   const successCriteria = normalizeGoalCriteria([
     ...(current?.successCriteria || []),
     ...(nextPatch?.successCriteria || []),
@@ -363,7 +437,6 @@ function resolveRunGoalContext(runMeta, analysis = null, plan = null) {
 }
 
 function buildCompletionDecisionPrompt({
-  mode,
   triggerSource,
   messagingSent = false,
   goalContext,
@@ -373,52 +446,28 @@ function buildCompletionDecisionPrompt({
   lastReply,
   iteration,
   maxIterations,
-  progressSummary = '',
-  platform = null,
 }) {
-  const draftReply = mode === 'messaging'
-    ? (normalizeOutgoingMessage(lastReply || '', platform, { collapseWhitespace: false })
-      ? String(lastReply || '').trim()
-      : '')
-    : normalizeOutgoingMessage(lastReply) || '';
+  const draftReply = normalizeOutgoingMessage(lastReply) || '';
   const lines = [
     'Return JSON only.',
+    'Decide whether this run should continue autonomously or stop now.',
+    'Schema: {"status":"continue|complete|blocked","reason":"short concrete reason"}',
+    'Rules:',
+    '- Use "continue" whenever any safe next step remains in this same run.',
+    '- Use "complete" only when the requested outcome is actually achieved and the latest draft is the finished user-facing answer.',
+    '- Use "blocked" only when a specific external dependency, missing user input, or permission outside this run is required and the latest draft is the blocker reply.',
+    '- If the latest draft asks the user for a missing required value, confirmation, or choice needed to proceed, use "blocked" so the run waits instead of repeating the same ask.',
+    '- A progress note, next-step note, apology, plan, or promise to investigate is "continue", not "complete".',
+    '- A single failed tool attempt is not blocked if another safe retry, verification step, or alternative path remains.',
+    '- 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.',
+    `- 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.',
   ];
 
-  if (mode === 'messaging') {
-    lines.push(
-      'A messaging run is about to stop after sending user-visible progress, but no final delivery has happened yet.',
-      'Decide whether the run should keep working, finish with the completed result now, or stop with one blocker reply now.',
-      'Schema: {"status":"continue|complete|blocked","reason":"short concrete reason","final_reply":"string"}',
-      'Rules:',
-      '- Use "continue" whenever any safe next step remains in this same run.',
-      '- Use "complete" only when the requested outcome is actually achieved and final_reply is the finished user-facing answer to send now.',
-      '- Use "blocked" only when a specific external dependency, missing user input, or permission outside this run is required and final_reply is the concise blocker reply to send now.',
-      '- A progress note, next-step note, apology, plan, or "I will investigate" draft is "continue", not "complete" and not "blocked".',
-      '- If user-visible progress was already sent and no final delivery exists yet, do not stop silently and do not stop on a status-only draft.',
-      '- final_reply must be empty when status is "continue".',
-    );
-  } else {
-    lines.push(
-      'Decide whether this run should continue autonomously or stop now.',
-      'Schema: {"status":"continue|complete|blocked","reason":"short concrete reason"}',
-      'Rules:',
-      '- Use "continue" whenever any safe next step remains in this same run.',
-      '- Use "complete" only when the requested outcome is actually achieved or a truthful final user reply is already ready now.',
-      '- Use "blocked" only when a specific external dependency outside this run is required.',
-      '- If the latest draft asks the user for a missing required value, confirmation, or choice needed to proceed, use "blocked" so the run waits instead of repeating the same ask.',
-      '- A progress update is not complete.',
-      '- A single failed tool attempt is not blocked if another safe retry, verification step, or alternative path remains.',
-      '- 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.',
-      `- 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 reply was already delivered to the user via send_message. Use "complete" unless there is concrete remaining work (e.g., a tool call you still need to make) before the task is truly done. Do not send follow-up elaborations or re-introductions.'
-        : triggerSource === 'messaging'
-          ? '- For messaging, do not stop on a partial status message. Continue unless the task is actually complete or externally blocked. If you already asked for missing user input, choose "blocked" and wait.'
-          : '- 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,
@@ -428,44 +477,14 @@ function buildCompletionDecisionPrompt({
       : '',
     `Current iteration: ${iteration} of ${maxIterations}.`,
     `Available tools in this run: ${summarizeAvailableTools(tools) || 'none'}`,
-    mode === 'messaging' && progressSummary ? `Progress ledger: ${progressSummary}` : '',
     `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 8) || 'none'}`,
     `Latest draft reply:\n${draftReply || '(empty)'}`,
-    mode === 'messaging' ? buildPlatformFormattingGuide(platform) : '',
   );
   return lines.filter(Boolean).join('\n');
 }
 
-function normalizeCompletionDecision(raw, {
-  mode,
-  fallbackStatus = 'continue',
-  platform = null,
-  draftReply = '',
-}) {
+function normalizeCompletionDecision(raw, fallbackStatus = 'continue') {
   const allowed = new Set(['continue', 'complete', 'blocked']);
-  if (mode === 'messaging') {
-    let status = allowed.has(String(raw.status || '').trim().toLowerCase())
-      ? String(raw.status || '').trim().toLowerCase()
-      : 'continue';
-    let finalReply = normalizeOutgoingMessage(raw.final_reply || '', platform, {
-      collapseWhitespace: false,
-    })
-      ? String(raw.final_reply || '').trim()
-      : '';
-    if (status === 'continue') {
-      finalReply = '';
-    } else if (!finalReply && draftReply) {
-      finalReply = draftReply;
-    } else if (!finalReply) {
-      status = 'continue';
-    }
-    return {
-      status,
-      reason: String(raw.reason || '').trim().slice(0, 400),
-      final_reply: finalReply,
-    };
-  }
-
   const requestedStatus = String(raw.status || '').trim().toLowerCase();
   return {
     status: allowed.has(requestedStatus) ? requestedStatus : fallbackStatus,
@@ -473,16 +492,6 @@ function normalizeCompletionDecision(raw, {
   };
 }
 
-function shouldRequireMessagingFinalityCheck(runMeta) {
-  return Boolean(
-    runMeta
-    && runMeta.triggerSource === 'messaging'
-    && runMeta.finalDeliverySent !== true
-    && !runMeta.terminalInterim
-    && hasVisibleInterimActivity(runMeta)
-  );
-}
-
 function planningDepthForForceMode(forceMode) {
   return forceMode === 'plan_execute' ? 'deep' : 'light';
 }
@@ -706,6 +715,7 @@ class AgentEngine {
     this.taskRuntime = services.taskRuntime || null;
     this.memoryManager = services.memoryManager || null;
     this.voiceRuntimeManager = services.voiceRuntimeManager || null;
+    this.messagingDeliveryRetry = services.messagingDeliveryRetry || {};
   }
 
   async buildSystemPrompt(userId, context = {}) {
@@ -926,21 +936,6 @@ class AgentEngine {
       .run(JSON.stringify(next), runId);
   }
 
-  replaceLatestConversationAssistantMessage(conversationId, content) {
-    if (!conversationId) return false;
-    const messageId = db.prepare(
-      `SELECT id
-       FROM conversation_messages
-       WHERE conversation_id = ? AND role = 'assistant'
-       ORDER BY id DESC
-       LIMIT 1`
-    ).get(conversationId)?.id;
-    if (!messageId) return false;
-    db.prepare('UPDATE conversation_messages SET content = ? WHERE id = ?')
-      .run(content, messageId);
-    return true;
-  }
-
   updateRunGoalContract(runId, patch = {}, options = {}) {
     const runMeta = this.getRunMeta(runId);
     if (!runMeta) return null;
@@ -1031,6 +1026,7 @@ class AgentEngine {
   markRunFinalDelivery(runId, content = '', timestamp = isoNow()) {
     const runMeta = this.getRunMeta(runId);
     if (!runMeta) return null;
+    runMeta.messagingSent = true;
     runMeta.finalDeliverySent = true;
     runMeta.lastSentMessage = String(content || '').trim() || runMeta.lastSentMessage || '';
     const ledger = this.updateRunProgress(runId, {
@@ -1142,13 +1138,14 @@ class AgentEngine {
       if (!platform || !chatId || !this.messagingManager) {
         return { sent: false, skipped: true, reason: 'Messaging context is not available.' };
       }
-      await this.messagingManager.sendMessage(userId, platform, chatId, normalizedContent, {
+      const deliveryResult = await this.messagingManager.sendMessage(userId, platform, chatId, normalizedContent, {
         agentId,
         runId,
         persistConversation: true,
         metadata,
         deliveryKind: 'interim',
       });
+      requireSuccessfulMessagingDelivery(deliveryResult, 'Interim messaging delivery');
     } else if (triggerSource === 'voice_live') {
       const voiceSessionId = runMeta.voiceSessionId || null;
       const manager = this.voiceRuntimeManager || this.app?.locals?.voiceRuntimeManager || null;
@@ -1242,42 +1239,72 @@ class AgentEngine {
     phase = 'structured',
   }) {
     const startedAt = Date.now();
-    const response = await withProviderRetry(
-      () => provider.chat(
-        sanitizeConversationMessages([
-          ...messages,
-          { role: 'system', content: prompt },
-        ]),
-        [],
-        {
-          model,
-          maxTokens,
-          reasoningEffort: reasoningEffort || this.getReasoningEffort(providerName, {}),
-        }
-      ),
-      { label: `Engine ${model} (structured)` }
-    );
-    if (telemetry?.runId && telemetry?.userId) {
-      recordModelUsage({
-        runId: telemetry.runId,
-        stepId: telemetry.stepId || null,
-        userId: telemetry.userId,
-        agentId: telemetry.agentId || null,
-        provider: providerName,
-        model,
-        phase,
-        usage: response.usage,
-        latencyMs: Date.now() - startedAt,
+    const structuredStep = `model:${phase}`;
+    if (telemetry?.runId) {
+      this.updateRunProgress(telemetry.runId, {
+        currentPhase: 'model',
+        currentStep: structuredStep,
+        currentTool: null,
+        currentStepStartedAt: isoNow(),
       });
     }
 
-    const parsed = parseJsonObject(response.content || '');
-    const normalizedUsage = normalizeUsage(response.usage);
-    return {
-      value: normalize(parsed || {}, fallback),
-      raw: response.content || '',
-      usage: normalizedUsage?.totalTokens || 0,
-    };
+    let completed = false;
+    try {
+      const response = await withProviderRetry(
+        () => withModelCallTimeout(
+          provider.chat(
+            sanitizeConversationMessages([
+              ...messages,
+              { role: 'system', content: prompt },
+            ]),
+            [],
+            {
+              model,
+              maxTokens,
+              reasoningEffort: reasoningEffort || this.getReasoningEffort(providerName, {}),
+            }
+          ),
+          telemetry || {},
+          `${phase} model call`,
+        ),
+        { label: `Engine ${model} (structured)` }
+      );
+      completed = true;
+      if (telemetry?.runId && telemetry?.userId) {
+        recordModelUsage({
+          runId: telemetry.runId,
+          stepId: telemetry.stepId || null,
+          userId: telemetry.userId,
+          agentId: telemetry.agentId || null,
+          provider: providerName,
+          model,
+          phase,
+          usage: response.usage,
+          latencyMs: Date.now() - startedAt,
+        });
+      }
+
+      const parsed = parseJsonObject(response.content || '');
+      const normalizedUsage = normalizeUsage(response.usage);
+      return {
+        value: normalize(parsed || {}, fallback),
+        raw: response.content || '',
+        usage: normalizedUsage?.totalTokens || 0,
+      };
+    } finally {
+      const runMeta = telemetry?.runId ? this.getRunMeta(telemetry.runId) : null;
+      if (runMeta?.progressLedger?.currentStep === structuredStep) {
+        this.updateRunProgress(telemetry.runId, {
+          currentPhase: 'idle',
+          currentStep: null,
+          currentTool: null,
+          currentStepStartedAt: null,
+        }, {
+          verified: completed,
+        });
+      }
+    }
   }
 
   async requestModelResponse({
@@ -1304,8 +1331,16 @@ class AgentEngine {
       if (options.stream !== false) {
         let emittedContent = false;
         const stream = provider.stream(requestMessages, tools, callOptions);
+        const iterator = stream[Symbol.asyncIterator]();
         try {
-          for await (const chunk of stream) {
+          while (true) {
+            const next = await withModelCallTimeout(
+              iterator.next(),
+              options,
+              `Model stream iteration ${iteration}`,
+            );
+            if (next.done) break;
+            const chunk = next.value;
             if (chunk.type === 'content') {
               emittedContent = true;
               streamContent += chunk.content;
@@ -1329,13 +1364,18 @@ class AgentEngine {
             }
           }
         } catch (err) {
+          Promise.resolve(iterator.return?.()).catch(() => {});
           // Once tokens have streamed to the client a retry would duplicate
           // output, so only the pre-stream window is safe to replay.
           if (emittedContent) err.__providerRetryUnsafe = true;
           throw err;
         }
       } else {
-        response = await provider.chat(requestMessages, tools, callOptions);
+        response = await withModelCallTimeout(
+          provider.chat(requestMessages, tools, callOptions),
+          options,
+          `Model iteration ${iteration}`,
+        );
       }
 
       return { response, streamContent };
@@ -1459,60 +1499,6 @@ class AgentEngine {
     };
   }
 
-  async decideLoopState({
-    provider,
-    providerName,
-    model,
-    messages,
-    tools,
-    analysis,
-    plan,
-    toolExecutions,
-    lastReply,
-    triggerSource,
-    messagingSent,
-    iteration,
-    maxIterations,
-    options,
-    fallbackStatus,
-  }) {
-    const runMeta = options?.runId ? this.getRunMeta(options.runId) : null;
-    const goalContext = resolveRunGoalContext(runMeta, analysis, plan);
-
-    const response = await this.requestStructuredJson({
-      provider,
-      providerName,
-      model,
-      messages,
-      prompt: buildCompletionDecisionPrompt({
-        mode: 'loop',
-        triggerSource,
-        messagingSent,
-        goalContext,
-        parallelWork: analysis?.parallel_work === true,
-        tools,
-        toolExecutions,
-        lastReply,
-        iteration,
-        maxIterations,
-      }),
-      maxTokens: 320,
-      normalize: (raw) => normalizeCompletionDecision(raw, {
-        mode: 'loop',
-        fallbackStatus,
-      }),
-      fallback: { status: fallbackStatus },
-      reasoningEffort: this.getReasoningEffort(providerName, options),
-      telemetry: options,
-      phase: 'loop_decision',
-    });
-
-    return {
-      decision: response.value,
-      usage: response.usage,
-    };
-  }
-
   async verifyFinalResponse({
     provider,
     providerName,
@@ -1623,11 +1609,15 @@ class AgentEngine {
       }
     ];
 
-    const response = await provider.chat(promptMessages, [], {
-      model,
-      maxTokens: 800,
-      reasoningEffort: this.getReasoningEffort(providerName, options),
-    });
+    const response = await withModelCallTimeout(
+      provider.chat(promptMessages, [], {
+        model,
+        maxTokens: 800,
+        reasoningEffort: this.getReasoningEffort(providerName, options),
+      }),
+      options,
+      'Conversation state refresh',
+    );
     const parsed = parseJsonObject(response.content || '') || {};
     const nextState = {
       summary: String(parsed.summary || existingState?.summary || '').trim(),
@@ -1662,69 +1652,6 @@ class AgentEngine {
     return nextState;
   }
 
-  async recoverBlankMessagingReply({
-    userId,
-    runId,
-    messages,
-    provider,
-    model,
-    providerName,
-    options,
-    stepIndex,
-    failedStepCount,
-    toolExecutions = [],
-    tools = []
-  }) {
-    const attempts = 3;
-    let recoveredContent = '';
-    let totalTokens = 0;
-
-    for (let attempt = 1; attempt <= attempts; attempt++) {
-      console.warn(
-        `[Run ${shortenRunId(runId)}] blank_reply_recovery attempt=${attempt} model=${model}`
-      );
-      try {
-        const response = await provider.chat(
-          sanitizeConversationMessages([
-            ...messages,
-            {
-              role: 'system',
-              content: buildBlankMessagingReplyPrompt(attempt, options?.source || null)
-            }
-          ]),
-          [],
-          {
-            model,
-            reasoningEffort: this.getReasoningEffort(providerName, options)
-          }
-        );
-        totalTokens += response.usage?.totalTokens || 0;
-        recoveredContent = sanitizeModelOutput(response.content || '', { model });
-        if (normalizeOutgoingMessage(recoveredContent)) {
-          console.info(
-            `[Run ${shortenRunId(runId)}] blank_reply_recovery succeeded attempt=${attempt}`
-          );
-          return { content: recoveredContent, tokens: totalTokens, recovered: true };
-        }
-      } catch (recoverErr) {
-        console.warn(
-          `[Run ${shortenRunId(runId)}] blank_reply_recovery attempt=${attempt} failed: ${summarizeForLog(recoverErr?.message || recoverErr, 180)}`
-        );
-      }
-    }
-
-    const error = new Error(
-      buildDeterministicMessagingFallback({
-        failedStepCount,
-        stepIndex,
-        toolExecutions,
-      })
-    );
-    error.code = 'BLANK_MESSAGING_REPLY';
-    error.recoveryTokens = totalTokens;
-    throw error;
-  }
-
   getAvailableTools(app, options = {}) {
     const { getAvailableTools } = require('./tools');
     return getAvailableTools(app, options);
@@ -2127,169 +2054,6 @@ class AgentEngine {
     return { messages, appliedCount: queued.length };
   }
 
-  async decideMessagingCompletionState({
-    provider,
-    providerName,
-    model,
-    messages,
-    analysis,
-    plan,
-    tools,
-    toolExecutions,
-    lastReply,
-    iteration,
-    maxIterations,
-    runId,
-    options,
-  }) {
-    const runMeta = this.getRunMeta(runId);
-    const goalContext = resolveRunGoalContext(runMeta, analysis, plan);
-    const platform = options?.source || null;
-    const normalizedDraft = normalizeOutgoingMessage(lastReply || '', platform, {
-      collapseWhitespace: false,
-    });
-    const draftReply = normalizedDraft ? String(lastReply || '').trim() : '';
-    const ledger = runMeta?.progressLedger || null;
-    const progressSummary = [
-      `progress_state=${ledger?.progressState || 'active'}`,
-      `current_phase=${ledger?.currentPhase || 'idle'}`,
-      `current_tool=${ledger?.currentTool || 'none'}`,
-      `heartbeat_count=${Number(ledger?.heartbeatCount || 0)}`,
-      `last_visible_update=${ledger?.lastUserVisibleUpdateAt || 'none'}`,
-      `last_verified_progress=${ledger?.lastVerifiedProgressAt || 'none'}`,
-      `last_final_delivery=${ledger?.lastFinalDeliveryAt || 'none'}`,
-    ].join('; ');
-
-    const response = await this.requestStructuredJson({
-      provider,
-      providerName,
-      model,
-      messages,
-      prompt: buildCompletionDecisionPrompt({
-        mode: 'messaging',
-        goalContext,
-        parallelWork: analysis?.parallel_work === true,
-        tools,
-        toolExecutions,
-        lastReply: draftReply,
-        iteration,
-        maxIterations,
-        progressSummary,
-        platform,
-      }),
-      maxTokens: 480,
-      normalize: (raw) => normalizeCompletionDecision(raw, {
-        mode: 'messaging',
-        platform,
-        draftReply,
-      }),
-      fallback: {
-        status: 'continue',
-        reason: '',
-        final_reply: '',
-      },
-      reasoningEffort: this.getReasoningEffort(providerName, options),
-      telemetry: options,
-      phase: 'messaging_completion',
-    });
-
-    return {
-      decision: response.value,
-      usage: response.usage,
-    };
-  }
-
-  async resolveMessagingCompletionDecision({
-    provider,
-    providerName,
-    model,
-    messages,
-    analysis,
-    plan,
-    tools,
-    toolExecutions,
-    lastReply,
-    iteration,
-    maxIterations,
-    runId,
-    conversationId,
-    options,
-  }) {
-    const runMeta = this.getRunMeta(runId);
-    if (!shouldRequireMessagingFinalityCheck(runMeta)) {
-      return {
-        action: 'none',
-        content: lastReply,
-        reason: '',
-        usage: 0,
-      };
-    }
-
-    let completionDecision;
-    try {
-      completionDecision = await this.decideMessagingCompletionState({
-        provider,
-        providerName,
-        model,
-        messages,
-        analysis,
-        plan,
-        tools,
-        toolExecutions,
-        lastReply,
-        iteration,
-        maxIterations,
-        runId,
-        options,
-      });
-    } catch (error) {
-      if (iteration >= maxIterations) {
-        const wrapped = new Error(
-          `Messaging completion check failed after visible progress: ${error?.message || error}`,
-        );
-        wrapped.disableAutonomousRetry = error?.disableAutonomousRetry === true;
-        throw wrapped;
-      }
-      return {
-        action: 'continue',
-        content: '',
-        reason: 'The run still needs an explicit final result or blocker decision.',
-        usage: 0,
-      };
-    }
-
-    const decision = completionDecision.decision || { status: 'continue', reason: '' };
-    if (decision.status === 'continue') {
-      if (iteration >= maxIterations) {
-        throw new Error(
-          'Messaging run reached the iteration limit before producing a final answer or blocker after visible progress.',
-        );
-      }
-      return {
-        action: 'continue',
-        content: '',
-        reason: decision.reason || 'The current draft is still only progress.',
-        usage: completionDecision.usage || 0,
-      };
-    }
-
-    const finalContent = String(decision.final_reply || lastReply || '').trim();
-    if (finalContent && messages[messages.length - 1]?.role === 'assistant') {
-      messages[messages.length - 1] = {
-        ...messages[messages.length - 1],
-        content: finalContent,
-      };
-      this.replaceLatestConversationAssistantMessage(conversationId, finalContent);
-    }
-
-    return {
-      action: decision.status === 'blocked' ? 'blocked' : 'complete',
-      content: finalContent,
-      reason: decision.reason || '',
-      usage: completionDecision.usage || 0,
-    };
-  }
-
   buildMessagingHeartbeatText(runMeta, options = {}) {
     const stalled = options.stalled === true;
     const now = Date.now();
@@ -2305,14 +2069,16 @@ class AgentEngine {
       runStartedAtMs,
     ));
     const currentTool = String(runMeta?.progressLedger?.currentTool || '').trim();
+    const runTitle = String(runMeta?.title || '').trim().slice(0, 60);
+    const titlePrefix = runTitle ? `[${runTitle}] ` : '';
     if (currentTool) {
       return stalled
-        ? `Still working on ${currentTool}. Run active ${runElapsed}; no verified progress for ${unverifiedElapsed}.`
-        : `Still working on ${currentTool}. Run active ${runElapsed}; current step ${stepElapsed} so far.`;
+        ? `${titlePrefix}Still working on ${currentTool}. Run active ${runElapsed}; no verified progress for ${unverifiedElapsed}.`
+        : `${titlePrefix}Still working on ${currentTool}. Run active ${runElapsed}; current step ${stepElapsed} so far.`;
     }
     return stalled
-      ? `Still working on this. Run active ${runElapsed}; no verified progress for ${unverifiedElapsed}.`
-      : `Still working on this. Run active ${runElapsed}.`;
+      ? `${titlePrefix}Still working on this. Run active ${runElapsed}; no verified progress for ${unverifiedElapsed}.`
+      : `${titlePrefix}Still working on this. Run active ${runElapsed}.`;
   }
 
   async sendRuntimeMessagingHeartbeat(runId, options = {}) {
@@ -2327,7 +2093,7 @@ class AgentEngine {
 
     const createdAt = isoNow();
     const content = this.buildMessagingHeartbeatText(runMeta, options);
-    await this.messagingManager.sendMessage(
+    const deliveryResult = await this.messagingManager.sendMessage(
       runMeta.userId,
       runMeta.messagingContext.platform,
       runMeta.messagingContext.chatId,
@@ -2345,6 +2111,7 @@ class AgentEngine {
         deliveryKind: 'interim',
       },
     );
+    requireSuccessfulMessagingDelivery(deliveryResult, 'Messaging heartbeat delivery');
 
     runMeta.lastInterimMessage = content;
     if (!Array.isArray(runMeta.interimMessages)) {
@@ -2369,8 +2136,8 @@ class AgentEngine {
     }, { agentId: runMeta.agentId });
     this.enqueueSystemSteering(
       runId,
-      'A runtime-generated progress update was already sent while the run was blocked. Do not repeat that same status. When control returns, either keep working silently, send a materially new update, or finish with the actual result.',
-      { reason: 'runtime_heartbeat' },
+      'A runtime progress update was just sent on your behalf because you were blocked in a tool. On your NEXT free turn: use send_interim_update to write 1-2 sentences in your own words describing what you are doing and why. Keep it short and concrete. Then continue toward the final answer.',
+      { reason: 'heartbeat_ai_followup' },
     );
     return { sent: true, content };
   }
@@ -2421,9 +2188,31 @@ class AgentEngine {
         await this.messagingManager.sendTyping(userId, platform, chatId, true, { agentId }).catch(() => {});
         await new Promise((resolve) => setTimeout(resolve, delay));
       }
-      await this.messagingManager.sendMessage(userId, platform, chatId, chunks[i], { runId, agentId }).catch((err) =>
-        console.error('[Engine] Auto-reply fallback failed:', err.message)
-      );
+      try {
+        await withProviderRetry(async () => {
+          const deliveryResult = await this.messagingManager.sendMessage(
+            userId,
+            platform,
+            chatId,
+            chunks[i],
+            { runId, agentId },
+          );
+          return requireSuccessfulMessagingDelivery(deliveryResult, 'Final messaging delivery');
+        }, {
+          ...this.messagingDeliveryRetry,
+          label: `MessagingDelivery ${platform}`,
+          isRetryable: (error) => (
+            error?.retryable !== false
+            && (
+              error?.code === 'MESSAGING_DELIVERY_FAILED'
+              || isTransientError(error)
+            )
+          ),
+        });
+      } catch (error) {
+        error.disableAutonomousRetry = true;
+        throw error;
+      }
     }
 
     runMeta.lastSentMessage = chunks[chunks.length - 1] || cleanedContent;
@@ -2474,7 +2263,10 @@ class AgentEngine {
       return { sent: false, skipped: true };
     }
 
-    if (ledger.currentPhase === 'tool' && ledger.currentStepStartedAt) {
+    if (
+      (ledger.currentPhase === 'tool' || ledger.currentPhase === 'model')
+      && ledger.currentStepStartedAt
+    ) {
       return this.sendRuntimeMessagingHeartbeat(runId, { stalled });
     }
 
@@ -2487,9 +2279,10 @@ class AgentEngine {
       return { sent: false, skipped: true };
     }
 
+    const elapsed = formatElapsedDuration(now - startedAtMs);
     const nudge = stalled
-      ? 'The messaging user has only seen progress updates so far, and the run now appears stalled. Decide explicitly whether to continue, send one concise blocker update, or finish with the final answer. Do not leave the run with only an interim status.'
-      : 'The messaging user has not received a final answer yet. Decide explicitly whether to keep working, send one concise progress update, or finish with the final answer. Do not stop with only an interim status.';
+      ? `You have been running for ${elapsed} and appear stalled. Use send_interim_update RIGHT NOW to write 1-2 sentences explaining the blocker in your own words, then either resolve it or call task_complete with what you have. Do not leave the user without an answer.`
+      : `You have been running for ${elapsed} without sending an update to the user. Use send_interim_update RIGHT NOW to write 1-2 sentences explaining what you are currently doing. Keep it short and concrete. Then continue working toward the final answer.`;
     const queued = this.enqueueSystemSteering(runId, nudge, {
       reason: stalled ? 'stalled_progress_check' : 'progress_check',
     });
@@ -2788,7 +2581,12 @@ class AgentEngine {
     const carriedExplicitMessageSent = retryMessagingState.explicitMessageSent === true;
     const carriedInterimHistory = cloneInterimHistory(retryMessagingState.interimHistory);
     const carriedLastInterimMessage = carriedInterimHistory[carriedInterimHistory.length - 1]?.content || '';
-    const carriedGoalContract = normalizeGoalContract(retryMessagingState.goalContract);
+    const carriedGoalContract = mergeGoalContracts(
+      normalizeGoalContract({
+        goal: clampRunContext(userMessage, 1200),
+      }),
+      retryMessagingState.goalContract,
+    );
     const startedAtIso = isoNow();
     const progressLedger = buildInitialProgressLedger({
       startedAt: startedAtIso,
@@ -3248,14 +3046,16 @@ class AgentEngine {
           currentStep: `model:${iteration}`,
           currentTool: null,
           currentStepStartedAt: isoNow(),
-        }, {
-          verified: true,
         });
 
         let metrics = this.estimatePromptMetrics(messages, tools);
         const contextWindow = provider.getContextWindow(model);
         if (metrics.totalEstimatedTokens > contextWindow * loopPolicy.compactionThreshold) {
-          messages = await compact(messages, provider, model, contextWindow);
+          messages = await withModelCallTimeout(
+            compact(messages, provider, model, contextWindow),
+            options,
+            `Context compaction before iteration ${iteration}`,
+          );
           messages = sanitizeConversationMessages(messages);
           this.emit(userId, 'run:compaction', { runId, iteration });
           metrics = this.estimatePromptMetrics(messages, tools);
@@ -3393,6 +3193,9 @@ class AgentEngine {
           toolCallCount: response.toolCalls?.length || 0,
           contentPreview: String(lastContent || streamContent || '').slice(0, 240),
         }, { agentId });
+        this.updateRunProgress(runId, {}, {
+          verified: true,
+        });
 
         const assistantMessage = { role: 'assistant', content: lastContent };
         if (response.toolCalls?.length) assistantMessage.tool_calls = response.toolCalls;
@@ -3416,9 +3219,10 @@ class AgentEngine {
             currentStep: null,
             currentTool: null,
             currentStepStartedAt: null,
-          }, {
-            verified: true,
           });
+          // Check for queued steering first — if something was injected while the
+          // model was responding (e.g. a heartbeat nudge), give the model a chance
+          // to act on it before we treat this as a final answer.
           const systemSteeringAfterResponse = this.applyQueuedSystemSteering(runId, messages);
           messages = systemSteeringAfterResponse.messages;
           if (systemSteeringAfterResponse.appliedCount > 0) {
@@ -3436,99 +3240,17 @@ class AgentEngine {
             lastContent = '';
             continue;
           }
-          const messagingSent = this.activeRuns.get(runId)?.messagingSent || false;
           if (this.shouldFastCompleteVoiceReply({
             options,
             toolExecutions,
             failedStepCount,
-            messagingSent,
+            messagingSent: this.activeRuns.get(runId)?.messagingSent || false,
             lastReply: lastContent,
           })) {
             break;
           }
-          const runMetaAfterResponse = this.getRunMeta(runId);
-          if (shouldRequireMessagingFinalityCheck(runMetaAfterResponse)) {
-            const messagingCompletion = await this.resolveMessagingCompletionDecision({
-              provider,
-              providerName,
-              model,
-              messages,
-              analysis,
-              plan,
-              tools,
-              toolExecutions,
-              lastReply: lastContent,
-              iteration,
-              maxIterations,
-              runId,
-              conversationId,
-              options: { ...options, runId, userId, agentId },
-            });
-            totalTokens += messagingCompletion.usage || 0;
-            if (messagingCompletion.action === 'continue') {
-              messages.push({
-                role: 'system',
-                content: [
-                  messagingCompletion.reason
-                    ? `Continue working: ${messagingCompletion.reason}.`
-                    : 'Continue working autonomously.',
-                  'The messaging user has already seen progress. Do not stop until you either have the finished answer now or a concrete blocker reply now.',
-                ].join(' ')
-              });
-              lastContent = '';
-              continue;
-            }
-            if (typeof messagingCompletion.content === 'string') {
-              lastContent = messagingCompletion.content;
-            }
-            break;
-          }
-          if (iteration < maxIterations) {
-            const proactiveRunNeedsDecision = (
-              (triggerSource === 'schedule' || triggerSource === 'tasks')
-              && this.activeRuns.get(runId)?.noResponse !== true
-              && options.deliveryState?.noResponse !== true
-            );
-            const visibleInterimActivity = hasVisibleInterimActivity(this.activeRuns.get(runId));
-            const fallbackStatus = (
-              proactiveRunNeedsDecision
-              || toolExecutions.length > 0
-              || failedStepCount > 0
-              || messagingSent
-              || visibleInterimActivity
-            ) ? 'continue' : 'complete';
-            const loopState = await runWithModelFallback('loop decision', () => this.decideLoopState({
-              provider,
-              providerName,
-              model,
-              messages,
-              tools,
-              analysis,
-              plan,
-              toolExecutions,
-              lastReply: lastContent,
-              triggerSource,
-              messagingSent,
-              iteration,
-              maxIterations,
-              options: { ...options, runId, userId, agentId },
-              fallbackStatus,
-            }));
-            totalTokens += loopState.usage || 0;
-            if (loopState.decision.status === 'continue') {
-              messages.push({
-                role: 'system',
-                content: [
-                  loopState.decision.reason ? `Continue working: ${loopState.decision.reason}.` : 'Continue working autonomously.',
-                  messagingSent
-                    ? 'You already sent a user-facing message in this run. Keep working silently unless you have a materially new finished result or a real external blocker.'
-                    : 'Use send_interim_update sparingly if a short real update or question would help. Otherwise keep working until you have the result or a real blocker.',
-                ].join(' ')
-              });
-              lastContent = '';
-              continue;
-            }
-          }
+          // AI returned text with no tool calls → trust it as the final answer.
+          directAnswerEligible = true;
           break;
         }
 
@@ -3537,6 +3259,15 @@ class AgentEngine {
           && response.toolCalls.every((toolCall) => this.isReadOnlyToolCall(toolCall))
         );
         if (canRunParallelBatch) {
+          const parallelToolNames = response.toolCalls
+            .map((toolCall) => toolCall.function?.name)
+            .filter(Boolean);
+          this.updateRunProgress(runId, {
+            currentPhase: 'tool',
+            currentStep: `parallel:${iteration}`,
+            currentTool: parallelToolNames.join(', ') || 'parallel tools',
+            currentStepStartedAt: isoNow(),
+          });
           const batch = await this.executeReadOnlyBatch(response.toolCalls, {
             userId,
             runId,
@@ -3588,6 +3319,14 @@ class AgentEngine {
             deliverableArtifacts,
             compactionMetrics: compactionMetrics.slice(-20),
           });
+          this.updateRunProgress(runId, {
+            currentPhase: 'idle',
+            currentStep: null,
+            currentTool: null,
+            currentStepStartedAt: null,
+          }, {
+            verified: true,
+          });
           continue;
         }
 
@@ -3605,53 +3344,20 @@ class AgentEngine {
           }
 
           // ── task_complete: AI explicitly signals the task is fully done ──
-          // Handle before DB insert / before_tool_call hook — this is not a
-          // regular tool execution, it is a loop-exit signal.
+          // Trust the model — no separate judge LLM call needed.
           if (toolName === 'task_complete') {
             const finalMessage = String(toolArgs.message || '').trim();
-            const confidence = normalizeCompletionConfidence(toolArgs.confidence || 'medium');
-            const completionDecision = shouldAcceptTaskComplete({
-              confidence,
-              requiredConfidence: analysis?.completion_confidence_required || 'medium',
-              iteration,
-              maxIterations,
-            });
             this.recordRunEvent(userId, runId, 'task_complete_signaled', {
-              confidence,
-              requiredConfidence: analysis?.completion_confidence_required || 'medium',
-              accepted: completionDecision.accept,
+              accepted: true,
               iteration,
               messageLength: finalMessage.length,
             }, { agentId });
             console.info(
-              `[Run ${shortenRunId(runId)}] task_complete signaled at iteration=${iteration} confidence=${confidence} accepted=${completionDecision.accept}`
+              `[Run ${shortenRunId(runId)}] task_complete accepted at iteration=${iteration}`
             );
-            if (!completionDecision.accept) {
-              messages.push({
-                role: 'tool',
-                name: toolName,
-                tool_call_id: toolCall.id,
-                content: JSON.stringify({
-                  status: 'continue',
-                  reason: completionDecision.reason,
-                  required_confidence: analysis?.completion_confidence_required || 'medium',
-                }),
-              });
-              messages.push({
-                role: 'system',
-                content: `${completionDecision.reason} Do not ask the user to decide the next step unless external input is truly required.`
-              });
-              continue;
-            }
-            if (completionDecision.reason) {
-              messages.push({
-                role: 'system',
-                content: completionDecision.reason,
-              });
-            }
-            lastContent = finalMessage; // empty string is valid; downstream handles it
+            lastContent = finalMessage;
             directAnswerEligible = true;
-            break; // exit the for-loop; the while condition will also exit
+            break;
           }
 
           const repetitionGuard = this.getRunMeta(runId)?.repetitionGuard;
@@ -3712,7 +3418,6 @@ class AgentEngine {
             currentTool: toolName,
             currentStepStartedAt: isoNow(),
           }, {
-            verified: true,
             stepId,
           });
 
@@ -3862,6 +3567,11 @@ class AgentEngine {
 
           if (toolErrorMessage) {
             consecutiveToolFailures += 1;
+            const currentRunMeta = this.getRunMeta(runId);
+            trackErrorPattern(toolErrorMessage, currentRunMeta);
+            const errorKey = normalizeErrorKey(toolErrorMessage);
+            const errorCount = currentRunMeta?.errorPatterns?.get(errorKey) || 0;
+            const patternGuide = buildErrorPatternGuidance(errorKey, errorCount);
             const alternativeTools = summarizeAvailableTools(tools, { exclude: toolName });
             messages.push({
               role: 'system',
@@ -3870,6 +3580,7 @@ class AgentEngine {
                 'This tool failure is not, by itself, a user-facing blocker.',
                 'Continue autonomously: retry with corrected arguments, try an alternative tool/path, or verify the outcome using other available tools.',
                 alternativeTools ? `Other available tools in this run: ${alternativeTools}.` : '',
+                patternGuide || '',
                 'Only stop and tell the user you are blocked if the remaining issue truly requires an external dependency or user action outside this run.'
               ].filter(Boolean).join(' ')
             });
@@ -3978,26 +3689,43 @@ class AgentEngine {
       const lastToolWasMessaging = runMeta?.lastToolName === 'send_message' || runMeta?.lastToolName === 'make_call';
 
       if (triggerSource === 'messaging' && !normalizeOutgoingMessage(lastContent, options?.source || null) && !messagingSent) {
-        const recovered = await this.recoverBlankMessagingReply({
-          userId,
-          runId,
-          messages,
-          provider,
-          model,
-          providerName,
-          options: { ...options, runId, userId, agentId },
-          stepIndex,
-          failedStepCount,
-          toolExecutions,
-          tools
-        });
-        lastContent = recovered.content;
-        totalTokens += recovered.tokens || 0;
+        // Simplified blank reply recovery: one model call with direct instruction,
+        // then fall back to a deterministic message. No multi-attempt LLM loop.
+        console.warn(`[Run ${shortenRunId(runId)}] blank_reply_recovery model=${model}`);
+        let recoveredTokens = 0;
+        try {
+          const recoveryResponse = await withModelCallTimeout(
+            provider.chat(
+              sanitizeConversationMessages([
+                ...messages,
+                {
+                  role: 'system',
+                  content: buildBlankMessagingReplyPrompt(1, options?.source || null)
+                }
+              ]),
+              [],
+              {
+                model,
+                reasoningEffort: this.getReasoningEffort(providerName, options)
+              }
+            ),
+            options,
+            'Blank messaging reply recovery',
+          );
+          recoveredTokens = recoveryResponse.usage?.totalTokens || 0;
+          lastContent = sanitizeModelOutput(recoveryResponse.content || '', { model });
+        } catch (recoverErr) {
+          console.warn(`[Run ${shortenRunId(runId)}] blank_reply_recovery failed: ${summarizeForLog(recoverErr?.message || recoverErr, 180)}`);
+        }
+        totalTokens += recoveredTokens;
+        if (!normalizeOutgoingMessage(lastContent, options?.source || null)) {
+          lastContent = buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
+        }
         if (normalizeOutgoingMessage(lastContent, options?.source || null)) {
           messages.push({ role: 'assistant', content: lastContent });
           if (conversationId) {
             db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
-              .run(conversationId, 'assistant', lastContent, recovered.tokens || 0);
+              .run(conversationId, 'assistant', lastContent, recoveredTokens);
           }
         }
       }
@@ -4139,20 +3867,6 @@ class AgentEngine {
           refreshConversationSummary(conversationId, provider, model, historyWindow).catch((err) => {
             console.error('[AI] Conversation summary refresh failed:', err.message);
           });
-          await this.refreshConversationState({
-            conversationId,
-            runId,
-            provider,
-            providerName,
-            model,
-            finalReply: finalResponseText,
-            analysis,
-            verification,
-            historyWindow,
-            options: { ...options, userId, agentId },
-          }).catch((err) => {
-            console.error('[AI] Conversation working state refresh failed:', err.message);
-          });
         }
       }
 
@@ -4186,6 +3900,23 @@ class AgentEngine {
         }
       }
 
+      if (conversationId && options.skipConversationMaintenance !== true) {
+        await this.refreshConversationState({
+          conversationId,
+          runId,
+          provider,
+          providerName,
+          model,
+          finalReply: finalResponseText,
+          analysis,
+          verification,
+          historyWindow,
+          options: { ...options, userId, agentId },
+        }).catch((err) => {
+          console.error('[AI] Conversation working state refresh failed:', err.message);
+        });
+      }
+
       console.info(
         `[Run ${shortenRunId(runId)}] completed trigger=${triggerSource} steps=${stepIndex} tokens=${totalTokens} durationMs=${runMeta?.startedAt ? Date.now() - runMeta.startedAt : 0} finalResponse=${finalResponseText ? 'yes' : 'no'} sentMessages=${runMeta?.sentMessages?.length || 0}`
       );
@@ -4272,6 +4003,8 @@ class AgentEngine {
         triggerSource === 'messaging'
         && options.source
         && options.chatId
+        && runMeta?.finalDeliverySent !== true
+        && runMeta?.messagingSent !== true
         && err?.disableAutonomousRetry !== true
         && !isRateLimitError
         && retryCount < this.getMessagingRetryLimit(maxIterations)
@@ -4342,7 +4075,7 @@ class AgentEngine {
       let messagingFailureContent = '';
       let sendSucceeded = false;
       if (triggerSource === 'messaging' && options.source && options.chatId) {
-        if (!runMeta?.messagingSent) {
+        if (!runMeta?.finalDeliverySent && !runMeta?.messagingSent) {
           const manager = this.messagingManager;
           if (manager) {
             const failureScenario = buildMessagingFailureScenario({
@@ -4359,10 +4092,14 @@ class AgentEngine {
                   content: `The run encountered a runtime error and cannot continue reliably. Use the actual run scenario below to explain the blocker naturally.\n\nScenario:\n${failureScenario || 'No additional scenario details were captured.'}\n\nDo not call tools. Write exactly one short user message. Do not ask the user to resend or restate the same task. Only ask the user for something if a specific external input, permission, or configuration change is actually required. Do not promise future work unless it will happen automatically before this reply is sent.\n\n${buildPlatformFormattingGuide(options?.source || null)}`
                 }
               ]);
-              const modelReply = await provider.chat(failedMessage, [], {
-                model,
-                reasoningEffort: this.getReasoningEffort(providerName, options)
-              });
+              const modelReply = await withModelCallTimeout(
+                provider.chat(failedMessage, [], {
+                  model,
+                  reasoningEffort: this.getReasoningEffort(providerName, options)
+                }),
+                options,
+                'Messaging failure reply',
+              );
               const drafted = sanitizeModelOutput(modelReply.content || '', { model });
               if (normalizeOutgoingMessage(drafted, options?.source || null)) {
                 messagingFailureContent = drafted.trim();
@@ -4381,7 +4118,14 @@ class AgentEngine {
             }
 
             try {
-              await manager.sendMessage(userId, options.source, options.chatId, messagingFailureContent, { runId, agentId });
+              const deliveryResult = await manager.sendMessage(
+                userId,
+                options.source,
+                options.chatId,
+                messagingFailureContent,
+                { runId, agentId },
+              );
+              requireSuccessfulMessagingDelivery(deliveryResult, 'Messaging failure delivery');
               sendSucceeded = true;
               if (runMeta) {
                 runMeta.lastSentMessage = messagingFailureContent;