neoagent 3.2.1-beta.2 → 3.2.1-beta.3

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

@@ -6,7 +6,12 @@ const {
 const {
   normalizeOutgoingMessage,
 } = require('../messagingFallback');
-const { withProviderRetry, isTransientError } = require('../providerRetry');
+const { withProviderRetry } = require('../providerRetry');
+const {
+  abortableDelay,
+  getErrorCode,
+  getHttpStatus,
+} = require('../../../utils/retry');
 const { shortenRunId, summarizeForLog } = require('../logFormat');
 const {
   TICK_MS,
@@ -16,6 +21,15 @@ const {
   evaluateProgressLiveness,
 } = require('./progress_monitor');
 
+const SAFE_PRE_DELIVERY_NETWORK_CODES = new Set([
+  'EAI_AGAIN',
+  'ENOTFOUND',
+  'ECONNREFUSED',
+  'ENETUNREACH',
+  'EHOSTUNREACH',
+  'UND_ERR_CONNECT_TIMEOUT',
+]);
+
 function isoNow() {
   return new Date().toISOString();
 }
@@ -39,9 +53,26 @@ function requireSuccessfulMessagingDelivery(result, label = 'Messaging delivery'
   const error = new Error(`${label} failed: ${reason}`);
   error.code = 'MESSAGING_DELIVERY_FAILED';
   error.deliveryResult = result || null;
+  error.safeToRetry = result?.safeToRetry === true;
+  error.deliveryAmbiguous = result?.deliveryAmbiguous === true;
   throw error;
 }
 
+function isSafeMessagingDeliveryRetry(error) {
+  if (!error || error.retryable === false || error.deliveryAmbiguous === true) return false;
+  if (error.safeToRetry === true) return true;
+  const result = error.deliveryResult;
+  if (result?.deliveryAmbiguous === true || result?.retryable === false) return false;
+  if (result?.success === false) return true;
+
+  // A rate-limit response explicitly rejected the request. DNS/connect failures
+  // happen before a platform can accept it. Timeouts, resets, broken pipes, and
+  // generic 5xx responses are intentionally excluded because the message may
+  // already have been accepted and retrying would duplicate it.
+  if (getHttpStatus(error) === 429) return true;
+  return SAFE_PRE_DELIVERY_NETWORK_CODES.has(String(getErrorCode(error) || ''));
+}
+
 // Harness-driven progress: the originating chat must see autonomous updates during
 // long runs even when a weak model never calls send_interim_update itself. The
 // supervisor paces this call (FIRST/REPEAT thresholds + a repeat guard). The update
@@ -66,13 +97,30 @@ async function sendRuntimeMessagingHeartbeat(engine, runId, options = {}) {
     && typeof runMeta.composeProgressUpdate === 'function') {
     let statusMsg = '';
     try {
-      const composed = await runMeta.composeProgressUpdate({ stalled: options.stalled === true });
+      const composed = await runMeta.composeProgressUpdate({
+        stalled: options.stalled === true,
+        signal: runMeta.messagingProgressSupervisor?.abortController?.signal || null,
+      });
       if (normalizeOutgoingMessage(composed, platform)) statusMsg = String(composed).trim();
     } catch { /* no dynamic update available this tick */ }
+    const currentRunMeta = engine.getRunMeta(runId);
+    if (
+      currentRunMeta !== runMeta
+      || runMeta.aborted
+      || runMeta.status !== 'running'
+      || runMeta.terminalInterim
+      || runMeta.finalDeliverySent
+      || runMeta.deliveryState?.finalContentDelivered === true
+    ) {
+      return { sent: false, skipped: true, terminal: true };
+    }
     if (statusMsg) try {
       const delivery = await engine.messagingManager.sendMessage(runMeta.userId, platform, chatId, statusMsg, {
         runId,
         agentId: runMeta.agentId,
+        signal: runMeta.messagingProgressSupervisor?.abortController?.signal
+          || runMeta.abortController?.signal
+          || null,
       });
       if (delivery?.success === true && delivery?.suppressed !== true) {
         const nowIso = isoNow();
@@ -157,11 +205,12 @@ async function deliverMessagingFinalFallback(engine, {
   console.info(
     `[Run ${shortenRunId(runId)}] messaging_fallback chunks=${chunks.length} to=${summarizeForLog(chatId, 80)}`
   );
+  const deliveredChunks = [];
   for (let i = 0; i < chunks.length; i++) {
     if (i > 0) {
       const delay = Math.max(1000, Math.min(chunks[i].length * 30, 4000));
       await engine.messagingManager.sendTyping(userId, platform, chatId, true, { agentId }).catch(() => {});
-      await new Promise((resolve) => setTimeout(resolve, delay));
+      await abortableDelay(delay, runMeta.abortController?.signal || null);
     }
     try {
       await withProviderRetry(async () => {
@@ -170,32 +219,34 @@ async function deliverMessagingFinalFallback(engine, {
           platform,
           chatId,
           chunks[i],
-          { runId, agentId },
+          {
+            runId,
+            agentId,
+            idempotencyKey: `${runId}:final:${i}`,
+            signal: runMeta.abortController?.signal || null,
+          },
         );
         return requireSuccessfulMessagingDelivery(deliveryResult, 'Final messaging delivery');
       }, {
         ...engine.messagingDeliveryRetry,
         label: `MessagingDelivery ${platform}`,
-        isRetryable: (error) => (
-          error?.retryable !== false
-          && (
-            error?.code === 'MESSAGING_DELIVERY_FAILED'
-            || isTransientError(error)
-          )
-        ),
+        signal: runMeta.abortController?.signal || null,
+        isRetryable: isSafeMessagingDeliveryRetry,
       });
     } catch (error) {
       error.disableAutonomousRetry = true;
+      error.deliveredChunks = deliveredChunks.slice();
       throw error;
     }
+    deliveredChunks.push(chunks[i]);
+    runMeta.lastSentMessage = chunks[i];
+    if (!Array.isArray(runMeta.sentMessages)) runMeta.sentMessages = [];
+    runMeta.sentMessages.push(chunks[i]);
   }
 
-  runMeta.lastSentMessage = chunks[chunks.length - 1] || cleanedContent;
-  runMeta.sentMessages = Array.isArray(runMeta.sentMessages)
-    ? [...runMeta.sentMessages, ...chunks]
-    : chunks.slice();
+  runMeta.lastSentMessage = deliveredChunks[deliveredChunks.length - 1] || cleanedContent;
   engine.markRunFinalDelivery(runId, runMeta.lastSentMessage);
-  return { sent: true, chunks };
+  return { sent: true, chunks: deliveredChunks };
 }
 
 async function tickMessagingProgressSupervisor(engine, runId) {
@@ -206,54 +257,71 @@ async function tickMessagingProgressSupervisor(engine, runId) {
   if (runMeta.terminalInterim) {
     return { sent: false, skipped: true };
   }
+  if (runMeta.progressSupervisorTickInFlight === true) {
+    return { sent: false, skipped: true, inFlight: true };
+  }
+  runMeta.progressSupervisorTickInFlight = true;
+  let settleTick;
+  const tickPromise = new Promise((resolve) => { settleTick = resolve; });
+  runMeta.progressSupervisorTickPromise = tickPromise;
 
-  const ledger = runMeta.progressLedger || buildInitialProgressLedger({
-    startedAt: runMeta.startedAtIso || isoNow(),
-  });
-  runMeta.progressLedger = ledger;
-  const liveness = evaluateProgressLiveness(runMeta);
-  const stalled = liveness.stalled;
-
-  if (stalled && !ledger.stallNotifiedAt) {
-    engine.updateRunProgress(runId, {
-      stallNotifiedAt: isoNow(),
-      progressState: 'stalled',
+  try {
+    const ledger = runMeta.progressLedger || buildInitialProgressLedger({
+      startedAt: runMeta.startedAtIso || isoNow(),
     });
-    engine.recordRunEvent(runMeta.userId, runId, 'progress_stalled', {
-      currentTool: ledger.currentTool || null,
-      currentStep: ledger.currentStep || null,
-      phase: ledger.currentPhase || 'idle',
-    }, { agentId: runMeta.agentId });
-  }
+    runMeta.progressLedger = ledger;
+    const liveness = evaluateProgressLiveness(runMeta);
+    const stalled = liveness.stalled;
 
-  if (!liveness.shouldNudge) {
-    return { sent: false, skipped: true };
-  }
+    if (stalled && !ledger.stallNotifiedAt) {
+      engine.updateRunProgress(runId, {
+        stallNotifiedAt: isoNow(),
+        progressState: 'stalled',
+      });
+      engine.recordRunEvent(runMeta.userId, runId, 'progress_stalled', {
+        currentTool: ledger.currentTool || null,
+        currentStep: ledger.currentStep || null,
+        phase: ledger.currentPhase || 'idle',
+      }, { agentId: runMeta.agentId });
+    }
 
-  const lastSupervisorNudgeAtMs = timestampMs(runMeta.lastSupervisorNudgeAt, 0);
-  if (lastSupervisorNudgeAtMs > 0 && (Date.now() - lastSupervisorNudgeAtMs) < REPEAT_UPDATE_MS) {
-    return { sent: false, skipped: true };
-  }
+    if (!liveness.shouldNudge) {
+      return { sent: false, skipped: true };
+    }
 
-  if (ledger.currentPhase === 'tool' || ledger.currentPhase === 'model') {
-    return sendRuntimeMessagingHeartbeat(engine, runId, { stalled });
-  }
+    const lastSupervisorNudgeAtMs = timestampMs(runMeta.lastSupervisorNudgeAt, 0);
+    if (lastSupervisorNudgeAtMs > 0 && (Date.now() - lastSupervisorNudgeAtMs) < REPEAT_UPDATE_MS) {
+      return { sent: false, skipped: true };
+    }
 
-  if (ledger.currentPhase !== 'idle') {
-    return { sent: false, skipped: true };
-  }
+    if (ledger.currentPhase === 'tool' || ledger.currentPhase === 'model') {
+      return await sendRuntimeMessagingHeartbeat(engine, runId, { stalled });
+    }
 
-  const queued = engine.enqueueSystemSteering(runId, buildProgressNudge({ stalled }), {
-    reason: stalled ? 'stalled_progress_check' : 'progress_check',
-  });
-  if (!queued) {
-    return { sent: false, skipped: true };
+    if (ledger.currentPhase !== 'idle') {
+      return { sent: false, skipped: true };
+    }
+
+    const queued = engine.enqueueSystemSteering(runId, buildProgressNudge({ stalled }), {
+      reason: stalled ? 'stalled_progress_check' : 'progress_check',
+    });
+    if (!queued) {
+      return { sent: false, skipped: true };
+    }
+    runMeta.lastSupervisorNudgeAt = isoNow();
+    engine.updateRunProgress(runId, {
+      lastUserVisibleUpdateAt: ledger.lastUserVisibleUpdateAt || null,
+    });
+    return { sent: false, queued: true };
+  } finally {
+    settleTick();
+    if (engine.getRunMeta(runId) === runMeta) {
+      runMeta.progressSupervisorTickInFlight = false;
+      if (runMeta.progressSupervisorTickPromise === tickPromise) {
+        runMeta.progressSupervisorTickPromise = null;
+      }
+    }
   }
-  runMeta.lastSupervisorNudgeAt = isoNow();
-  engine.updateRunProgress(runId, {
-    lastUserVisibleUpdateAt: ledger.lastUserVisibleUpdateAt || null,
-  });
-  return { sent: false, queued: true };
 }
 
 function startMessagingProgressSupervisor(engine, runId) {
@@ -264,25 +332,29 @@ function startMessagingProgressSupervisor(engine, runId) {
   if (runMeta.messagingProgressSupervisor?.timer) {
     return true;
   }
+  const abortController = new AbortController();
   const timer = setInterval(() => {
     tickMessagingProgressSupervisor(engine, runId).catch((error) => {
       console.warn('[Engine] Messaging progress supervisor failed:', error?.message || error);
     });
   }, TICK_MS);
   timer.unref?.();
-  runMeta.messagingProgressSupervisor = { timer };
+  runMeta.messagingProgressSupervisor = { timer, abortController };
   return true;
 }
 
 function stopMessagingProgressSupervisor(engine, runId) {
   const runMeta = engine.getRunMeta(runId);
+  const inFlight = runMeta?.progressSupervisorTickPromise || null;
   const timer = runMeta?.messagingProgressSupervisor?.timer || null;
   if (timer) {
     clearInterval(timer);
   }
+  runMeta?.messagingProgressSupervisor?.abortController?.abort('Progress supervisor stopped.');
   if (runMeta?.messagingProgressSupervisor) {
     runMeta.messagingProgressSupervisor = null;
   }
+  return inFlight || Promise.resolve();
 }
 
 module.exports = {

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

@@ -0,0 +1,91 @@
+'use strict';
+
+const MODEL_CALL_TIMEOUT_MS = 5 * 60 * 1000;
+
+function formatElapsedDuration(durationMs) {
+  const totalSeconds = Math.max(1, Math.floor(Number(durationMs || 0) / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (seconds === 0) return `${minutes}m`;
+  return `${minutes}m ${seconds}s`;
+}
+
+function resolveModelCallTimeoutMs(options = {}) {
+  const requested = Number(options?.modelCallTimeoutMs);
+  if (Number.isFinite(requested) && requested > 0) {
+    return Math.max(10, requested);
+  }
+  return MODEL_CALL_TIMEOUT_MS;
+}
+
+function abortError(reason = null) {
+  if (reason instanceof Error) return reason;
+  const error = new Error(String(reason || 'Model call aborted.'));
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
+async function withModelCallTimeout(promise, options = {}, label = 'Model call') {
+  const timeoutMs = resolveModelCallTimeoutMs(options);
+  const signal = options?.modelAbortController?.signal || options?.signal || null;
+  let timer = null;
+  let abortListener = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const error = new Error(`${label} timed out after ${formatElapsedDuration(timeoutMs)}.`);
+      error.code = 'MODEL_CALL_TIMEOUT';
+      options?.modelAbortController?.abort(error);
+      reject(error);
+    }, timeoutMs);
+  });
+  const aborted = new Promise((_, reject) => {
+    if (!signal) return;
+    abortListener = () => reject(abortError(signal.reason));
+    if (signal.aborted) abortListener();
+    else signal.addEventListener('abort', abortListener, { once: true });
+  });
+
+  try {
+    return await Promise.race([Promise.resolve(promise), timeout, aborted]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (abortListener) signal?.removeEventListener('abort', abortListener);
+  }
+}
+
+async function runAbortableModelCall(factory, options = {}, label = 'Model call') {
+  const modelAbortController = new AbortController();
+  const parentSignals = [...new Set([
+    options?.signal,
+    ...(Array.isArray(options?.signals) ? options.signals : []),
+  ].filter((signal) => signal && typeof signal.addEventListener === 'function'))];
+  const parentListeners = new Map();
+  for (const parentSignal of parentSignals) {
+    const abortFromParent = () => modelAbortController.abort(parentSignal.reason);
+    parentListeners.set(parentSignal, abortFromParent);
+    if (parentSignal.aborted) abortFromParent();
+    else parentSignal.addEventListener('abort', abortFromParent, { once: true });
+  }
+
+  try {
+    const promise = Promise.resolve().then(() => factory(modelAbortController.signal));
+    return await withModelCallTimeout(
+      promise,
+      { ...options, modelAbortController },
+      label,
+    );
+  } finally {
+    for (const [parentSignal, abortFromParent] of parentListeners) {
+      parentSignal.removeEventListener('abort', abortFromParent);
+    }
+  }
+}
+
+module.exports = {
+  abortError,
+  resolveModelCallTimeoutMs,
+  runAbortableModelCall,
+  withModelCallTimeout,
+};

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

@@ -5,48 +5,16 @@ const { sanitizeModelOutput } = require('../outputSanitizer');
 const { parseJsonObject } = require('../taskAnalysis');
 const { withProviderRetry, isTransientError } = require('../providerRetry');
 const { normalizeUsage, recordModelUsage } = require('../usage');
-
-const MODEL_CALL_TIMEOUT_MS = 5 * 60 * 1000;
+const {
+  resolveModelCallTimeoutMs,
+  runAbortableModelCall,
+  withModelCallTimeout,
+} = require('./model_call_guard');
 
 function isoNow() {
   return new Date().toISOString();
 }
 
-function formatElapsedDuration(durationMs) {
-  const totalSeconds = Math.max(1, Math.floor(Number(durationMs || 0) / 1000));
-  if (totalSeconds < 60) return `${totalSeconds}s`;
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  if (seconds === 0) return `${minutes}m`;
-  return `${minutes}m ${seconds}s`;
-}
-
-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(() => {
-      options?.modelAbortController?.abort(`${label} timed out.`);
-      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);
-  }
-}
-
 async function requestStructuredJson(engine, {
   provider,
   providerName,
@@ -76,7 +44,6 @@ async function requestStructuredJson(engine, {
     });
   }
 
-  let completed = false;
   try {
     const response = await withProviderRetry(
       () => withModelCallTimeout(
@@ -99,9 +66,9 @@ async function requestStructuredJson(engine, {
       {
         label: `Engine ${model} (structured)`,
         isRetryable: (err) => !modelAbortController.signal.aborted && isTransientError(err),
+        signal: modelAbortController.signal,
       }
     );
-    completed = true;
     if (telemetry?.runId && telemetry?.userId) {
       recordModelUsage({
         runId: telemetry.runId,
@@ -132,8 +99,6 @@ async function requestStructuredJson(engine, {
         currentStep: null,
         currentTool: null,
         currentStepStartedAt: null,
-      }, {
-        verified: completed,
       });
     }
   }
@@ -235,6 +200,7 @@ async function requestModelResponse(engine, {
           phase: 'recovering',
         });
       },
+      signal: modelAbortController.signal,
     }));
   } finally {
     parentSignal?.removeEventListener('abort', abortFromParent);
@@ -279,5 +245,6 @@ module.exports = {
   requestModelResponse,
   requestStructuredJson,
   resolveModelCallTimeoutMs,
+  runAbortableModelCall,
   withModelCallTimeout,
 };

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

@@ -4,7 +4,10 @@ const { v4: uuidv4 } = require('uuid');
 const db = require('../../../db/database');
 const { globalHooks } = require('../hooks');
 const { summarizeForLog } = require('../logFormat');
-const { inferToolFailureMessage } = require('../toolEvidence');
+const {
+  inferToolFailureMessage,
+  resolveDeclaredToolAccess,
+} = require('../toolEvidence');
 
 function getAvailableTools(_engine, app, options = {}) {
   const { getAvailableTools: loadAvailableTools } = require('../tools');
@@ -16,8 +19,21 @@ async function executeTool(engine, toolName, args, context) {
   return runTool(toolName, args, context, engine);
 }
 
-function isReadOnlyToolCall(toolCall) {
+function isReadOnlyToolCall(toolCall, toolDefinition = null) {
   const name = String(toolCall?.function?.name || '');
+  let toolArgs = {};
+  try {
+    toolArgs = typeof toolCall?.function?.arguments === 'string'
+      ? JSON.parse(toolCall.function.arguments || '{}')
+      : (toolCall?.function?.arguments || {});
+  } catch {
+    return false;
+  }
+
+  const declaredAccess = resolveDeclaredToolAccess(toolDefinition, toolArgs);
+  if (declaredAccess === 'read') return true;
+  if (declaredAccess === 'write') return false;
+
   const readOnly = new Set([
     'read_file',
     'read_files',
@@ -35,12 +51,7 @@ function isReadOnlyToolCall(toolCall) {
     'read_health_data',
   ]);
   if (name === 'http_request') {
-    try {
-      const args = JSON.parse(toolCall.function.arguments || '{}');
-      return String(args.method || 'GET').toUpperCase() === 'GET';
-    } catch {
-      return false;
-    }
+    return String(toolArgs.method || 'GET').toUpperCase() === 'GET';
   }
   return readOnly.has(name);
 }

package/server/services/ai/loopPolicy.js

@@ -1,9 +1,9 @@
-// Limits resolve in priority order: per-run options → agent AI settings → hardcoded defaults.
+// Limits resolve in priority order: per-run options → agent AI settings → conservative defaults.
 // They are safety nets only; task_complete / progress guards are the real exit signals.
 
 // The iteration ceiling is a pure runaway safety net, NOT the primary stop signal.
 // A run stops when it makes no real progress (consecutiveReadOnlyIterations cap,
-// which resets the moment the agent does anything state-changing), or when the
+// which resets on a state change or genuinely new evidence), or when the
 // repetition / tool-failure / model-recovery guards fire, or when the model signals
 // task_complete. These ceilings are set high so they only ever catch a genuine
 // runaway and never guillotine a long, legitimately-progressing complex task.
@@ -13,8 +13,8 @@ const DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS = 250;
 // Less aggressive than 0.60 so the model retains file contents it already read for
 // longer, instead of losing them to compaction and re-reading the same files.
 const DEFAULT_COMPACTION_THRESHOLD = 0.80;
-// The real "stop when stuck" guard. Counts consecutive turns of pure reading/
-// searching/inspecting with zero state change; resets to 0 on any concrete progress.
+// The real "stop when stuck" guard. Counts consecutive turns with no state
+// change and no new evidence; resets to 0 on any concrete progress.
 const DEFAULT_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS = 8;
 const DEFAULT_MAX_CONSECUTIVE_TOOL_FAILURES = 5;
 const DEFAULT_MAX_MODEL_FAILURE_RECOVERIES = 3;
@@ -25,8 +25,9 @@ const MAX_ALLOWED_TOOL_FAILURES = 50;
 const MAX_ALLOWED_MODEL_RECOVERIES = 10;
 const MAX_ALLOWED_BUDGET_CHARS = 500_000;
 
-function finitePositive(n, fallback) {
-  return Number.isFinite(n) && n > 0 ? n : fallback;
+function optionalNumber(value) {
+  if (value == null || value === '') return Number.NaN;
+  return Number(value);
 }
 
 function clampFinite(n, lo, hi, fallback) {
@@ -70,23 +71,27 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
 
   // ── Tool result size budget ───────────────────────────────────────────────
   // Must be a finite positive integer; bad values fall back to 2400.
-  const defaultBudget = clampFinite(
-    Math.floor(Number(aiSettings.tool_replay_budget_chars) || 0),
-    500,
-    MAX_ALLOWED_BUDGET_CHARS,
-    2400,
-  );
+  const requestedDefaultBudget = optionalNumber(aiSettings.tool_replay_budget_chars);
+  const defaultBudget = Number.isFinite(requestedDefaultBudget) && requestedDefaultBudget > 0
+    ? clampFinite(Math.floor(requestedDefaultBudget), 500, MAX_ALLOWED_BUDGET_CHARS, 2400)
+    : 2400;
 
   // ── Scalar policy fields ─────────────────────────────────────────────────
   const maxConsecutiveToolFailures = clampFinite(
-    Math.floor(Number(aiSettings.max_consecutive_tool_failures)),
+    Math.floor(optionalNumber(
+      options.maxConsecutiveToolFailures
+      ?? aiSettings.max_consecutive_tool_failures,
+    )),
     1,
     MAX_ALLOWED_TOOL_FAILURES,
     DEFAULT_MAX_CONSECUTIVE_TOOL_FAILURES,
   );
 
   const maxModelFailureRecoveries = clampFinite(
-    Math.floor(Number(aiSettings.max_model_failure_recoveries)),
+    Math.floor(optionalNumber(
+      options.maxModelFailureRecoveries
+      ?? aiSettings.max_model_failure_recoveries,
+    )),
     0,
     MAX_ALLOWED_MODEL_RECOVERIES,
     DEFAULT_MAX_MODEL_FAILURE_RECOVERIES,
@@ -94,7 +99,7 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
 
   const rawReadOnlyIterations = options.maxConsecutiveReadOnlyIterations != null
     ? Number(options.maxConsecutiveReadOnlyIterations)
-    : Number(aiSettings.max_consecutive_read_only_iterations);
+    : optionalNumber(aiSettings.max_consecutive_read_only_iterations);
   const maxConsecutiveReadOnlyIterations = clampFinite(
     Math.floor(rawReadOnlyIterations),
     3,
@@ -104,7 +109,7 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
 
   // compactionThreshold must be in (0, 1]; clamp to [0.1, 1].
   const compactionThreshold = clampFinite(
-    Number(aiSettings.compaction_threshold),
+    optionalNumber(options.compactionThreshold ?? aiSettings.compaction_threshold),
     0.1,
     1,
     DEFAULT_COMPACTION_THRESHOLD,
@@ -122,9 +127,9 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
     // Per-category tool result size budgets (chars)
     toolResultBudget: {
       default: defaultBudget,
-      file:    clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_file_chars)),    500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 6000)),
-      browser: clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_browser_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
-      command: clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_command_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
+      file:    clampFinite(Math.floor(optionalNumber(aiSettings.tool_replay_budget_file_chars)),    500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 6000)),
+      browser: clampFinite(Math.floor(optionalNumber(aiSettings.tool_replay_budget_browser_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
+      command: clampFinite(Math.floor(optionalNumber(aiSettings.tool_replay_budget_command_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
     },
 
     // Hard ceiling is always 2× soft, capped at a reasonable absolute max