neoagent 2.5.2-beta.19 → 2.5.2-beta.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.5.2-beta.19",
+  "version": "2.5.2-beta.20",
   "description": "Proactive personal AI agent with no limits",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",

package/server/public/.last_build_id

@@ -1 +1 @@
-fd7d3312e49bd04c96b7a60923a554e0
+efe2ad6d1aff0358de22202a239e2829

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"77e2e94772b6eb43759e34ed1ad7da4674e19c
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1886254391" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "2093031085" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -134794,7 +134794,7 @@ r===$&&A.b()
 p.push(A.jP(q,A.j9(!1,new A.a_(B.uG,A.d8(new A.cA(B.jt,new A.a7N(r,q),q),q,q),q),!1,B.H,!0),q,q,0,0,0,q))}r=!1
 if(!s.ay)if(!s.ch){r=s.e
 r===$&&A.b()
-r=B.b.u("mqggr6tq-b5e1610").length!==0&&r.b}if(r){r=s.d
+r=B.b.u("mqgmwb41-5bb5db5").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.aP&&!r.ai?84:0
 s=s.e
@@ -140506,7 +140506,7 @@ $S:0}
 A.a_6.prototype={}
 A.SQ.prototype={
 nb(a){var s=this
-if(B.b.u("mqggr6tq-b5e1610").length===0||s.a!=null)return
+if(B.b.u("mqgmwb41-5bb5db5").length===0||s.a!=null)return
 s.AU()
 s.a=A.on(B.RH,new A.bc8(s))},
 AU(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -140524,7 +140524,7 @@ if(!t.f.b(k)){s=1
 break}i=J.a3(k,"buildId")
 h=i==null?null:B.b.u(J.p(i))
 j=h==null?"":h
-if(J.bi(j)===0||J.d(j,"mqggr6tq-b5e1610")){s=1
+if(J.bi(j)===0||J.d(j,"mqgmwb41-5bb5db5")){s=1
 break}n.b=!0
 n.F()
 p=2
@@ -140541,7 +140541,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$AU,r)},
 vE(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$vE=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.u("mqggr6tq-b5e1610").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.u("mqgmwb41-5bb5db5").length===0||n.c){s=1
 break}n.c=!0
 n.F()
 p=4

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

@@ -61,7 +61,6 @@ const {
   shouldContinueAfterBlankToolFailure,
 } = require('./blank_recovery');
 const {
-  shouldRetryMessagingRun,
   shouldSendMessagingErrorFallback,
 } = require('./error_recovery');
 const {
@@ -143,7 +142,6 @@ const {
   summarizeToolExecutions,
   summarizeAvailableTools,
   inferToolFailureMessage,
-  buildAutonomousRecoveryContext,
 } = require('../toolEvidence');
 const {
   buildMemoryConsolidationInstructions,
@@ -769,14 +767,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   let iteration = 0;
   let totalTokens = 0;
   let lastContent = '';
-  let stepIndex = Number(options.messagingRetryStepOffset || 0);
-  if (!Number.isFinite(stepIndex) || stepIndex < 0) {
-    stepIndex = 0;
-  }
-  if (options.messagingAutonomousRetryCount > 0) {
-    const existingStep = db.prepare('SELECT COALESCE(MAX(step_index), 0) AS maxStep FROM agent_steps WHERE run_id = ?').get(runId);
-    stepIndex = Math.max(stepIndex, Number(existingStep?.maxStep || 0));
-  }
+  let stepIndex = 0;
   let failedStepCount = 0;
   let modelFailureRecoveries = 0;
   let promptMetrics = {};
@@ -1084,7 +1075,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           const urgency = readOnlyCount >= 6 ? 'CRITICAL' : 'ACTION REQUIRED';
           messages.push({
             role: 'system',
-            content: `${urgency} — ${readOnlyCount} consecutive read-only turns: You have been gathering information for ${readOnlyCount} turns without writing, creating, sending, or running anything. Switch method now: establish or reuse a writable checkout, create a task branch, edit files, run verification, open/update a PR, send a concrete progress update, or call task_complete with the real blocker. Do not do more remote tree/list/content scraping first.`,
+            content: `${urgency} — ${readOnlyCount} consecutive read-only turns: You have been gathering information for ${readOnlyCount} turns without implementation progress such as writing, editing, creating a branch, running verification, or delivering a final/blocker. Switch method now: establish or reuse a writable checkout, create a task branch, edit files, run verification, open/update a PR, or call task_complete with the real blocker. If the user has been waiting, send one concise interim update, but that does not satisfy the method switch. Do not do more remote tree/list/content scraping first. Do not assume tool results exist at /tmp paths unless a tool explicitly returned that readable path.`,
           });
         }
       }
@@ -1911,12 +1902,23 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           reason: recoveryDecision.decision.reason,
         }, { agentId });
         if (recoveryDecision.decision.status === 'continue') {
-          throw new Error('Messaging run ended without a judged terminal reply.');
-        }
-        messages.push({ role: 'assistant', content: lastContent });
-        if (conversationId) {
-          db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
-            .run(conversationId, 'assistant', lastContent, recoveredTokens);
+          engine.recordRunEvent(userId, runId, 'blank_reply_recovery_blocker_used', {
+            reason: recoveryDecision.decision.reason,
+            stepIndex,
+            failedStepCount,
+          }, { agentId });
+          lastContent = buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
+          messages.push({ role: 'assistant', content: lastContent });
+          if (conversationId) {
+            db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
+              .run(conversationId, 'assistant', lastContent, 0);
+          }
+        } else {
+          messages.push({ role: 'assistant', content: lastContent });
+          if (conversationId) {
+            db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
+              .run(conversationId, 'assistant', lastContent, recoveredTokens);
+          }
         }
       }
     }
@@ -1944,10 +1946,28 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           stepIndex,
           failedStepCount,
         }, { agentId });
-        throw new Error(`Iteration budget exhausted before judged completion after ${maxIterations} iterations.`);
+        if (triggerSource === 'messaging') {
+          lastContent = buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
+          messages.push({ role: 'assistant', content: lastContent });
+          if (conversationId) {
+            db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
+              .run(conversationId, 'assistant', lastContent, 0);
+          }
+        } else {
+          throw new Error(`Iteration budget exhausted before judged completion after ${maxIterations} iterations.`);
+        }
       }
       if (stepIndex > 0 && !lastToolWasMessaging && iteration < maxIterations) {
-        throw new Error('Run ended without an explicit completion or blocker reply.');
+        if (triggerSource === 'messaging') {
+          lastContent = buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
+          messages.push({ role: 'assistant', content: lastContent });
+          if (conversationId) {
+            db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
+              .run(conversationId, 'assistant', lastContent, 0);
+          }
+        } else {
+          throw new Error('Run ended without an explicit completion or blocker reply.');
+        }
       }
     }
 
@@ -2190,78 +2210,6 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     }
 
     const runMeta = engine.activeRuns.get(runId);
-    const retryCount = Number(options.messagingAutonomousRetryCount || 0);
-    // Rate-limit errors (429) must not trigger messaging retries: the model
-    // won't be available in the milliseconds between retries, so spawning new
-    // runs just compounds the rate-limit pressure with no benefit.
-    const canRetryMessagingRun = shouldRetryMessagingRun({
-      triggerSource,
-      options,
-      runMeta,
-      error: err,
-      retryCount,
-      retryLimit: engine.getMessagingRetryLimit(maxIterations),
-    });
-
-    if (canRetryMessagingRun) {
-      const recoveryContext = buildAutonomousRecoveryContext({
-        err,
-        toolExecutions,
-        tools,
-        userMessage,
-        visibleMessageSent: Boolean(
-          runMeta?.lastSentMessage
-          || runMeta?.lastInterimMessage
-          || runMeta?.messagingSent === true
-        ),
-      });
-      db.prepare('UPDATE agent_runs SET status = ?, error = ?, updated_at = datetime(\'now\') WHERE id = ?')
-        .run('retrying', err.message, runId);
-      console.warn(
-        `[Run ${shortenRunId(runId)}] retrying_messaging_attempt=${retryCount + 1} reason=${summarizeForLog(err.message, 140)}`
-      );
-      engine.cleanupSubagentsForRun(runId, { cancelRunning: true });
-      engine.stopMessagingProgressSupervisor(runId);
-      engine.activeRuns.delete(runId);
-      engine.emit(userId, 'run:interim', {
-        runId,
-        message: 'Retrying internally after a transient failure.',
-        phase: 'retrying'
-      });
-
-      const retryOptions = {
-        ...options,
-        runId,
-        messagingRetryStepOffset: stepIndex,
-        messagingAutonomousRetryCount: retryCount + 1,
-        messagingRetryState: {
-          lastFinalMessage: String(runMeta?.lastSentMessage || options?.messagingRetryState?.lastFinalMessage || '').trim(),
-          explicitMessageSent: runMeta?.explicitMessageSent === true || options?.messagingRetryState?.explicitMessageSent === true,
-          interimHistory: cloneInterimHistory([
-            ...(Array.isArray(options?.messagingRetryState?.interimHistory) ? options.messagingRetryState.interimHistory : []),
-            ...(Array.isArray(runMeta?.interimMessages) ? runMeta.interimMessages : []),
-          ]),
-          goalContract: mergeGoalContracts(
-            options?.messagingRetryState?.goalContract || null,
-            runMeta?.goalContract || null,
-          ),
-          lastUserVisibleUpdateAt: runMeta?.progressLedger?.lastUserVisibleUpdateAt || options?.messagingRetryState?.lastUserVisibleUpdateAt || null,
-          lastFinalDeliveryAt: runMeta?.progressLedger?.lastFinalDeliveryAt || options?.messagingRetryState?.lastFinalDeliveryAt || null,
-          heartbeatCount: Number(runMeta?.progressLedger?.heartbeatCount || options?.messagingRetryState?.heartbeatCount || 0),
-          progressState: runMeta?.progressLedger?.progressState || options?.messagingRetryState?.progressState || 'active',
-          lastVerifiedProgressAt: runMeta?.progressLedger?.lastVerifiedProgressAt || options?.messagingRetryState?.lastVerifiedProgressAt || null,
-        },
-        context: {
-          ...(options.context || {}),
-          additionalContext: [
-            options.context?.additionalContext || '',
-            recoveryContext,
-          ].filter(Boolean).join('\n\n')
-        }
-      };
-
-      return engine.runWithModel(userId, userMessage, retryOptions, _modelOverride);
-    }
 
     const deliverableFailureResponse = err?.deliverableResult?.summary
       || err?.deliverableValidation?.summary

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

@@ -13,21 +13,10 @@ function isRateLimitError(error = null) {
   return /429|rate.?limit|free-models-per/i.test(String(error?.message || ''));
 }
 
-function shouldRetryMessagingRun({
-  triggerSource,
-  options = {},
-  runMeta = null,
-  error = null,
-  retryCount = 0,
-  retryLimit = 0,
-} = {}) {
-  return triggerSource === 'messaging'
-    && Boolean(options.source)
-    && Boolean(options.chatId)
-    && !hasTerminalMessagingDelivery(runMeta)
-    && error?.disableAutonomousRetry !== true
-    && !isRateLimitError(error)
-    && Number(retryCount || 0) < Number(retryLimit || 0);
+function shouldRetryMessagingRun() {
+  // Messaging recovery must stay inside the current run. Re-entering
+  // runWithModel starts over from the original task and repeats tool work.
+  return false;
 }
 
 function shouldSendMessagingErrorFallback({

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

@@ -16,9 +16,6 @@ const {
   evaluateProgressLiveness,
 } = require('./progress_monitor');
 
-// Force a visible WhatsApp status message after this long with no user-visible update
-const FORCE_VISIBLE_UPDATE_MS = 2 * 60 * 1000;
-
 function isoNow() {
   return new Date().toISOString();
 }
@@ -56,39 +53,7 @@ async function sendRuntimeMessagingHeartbeat(engine, runId, options = {}) {
   runMeta.lastSupervisorNudgeAt = createdAt;
   engine.updateRunProgress(runId, { heartbeatCount });
 
-  // If the user hasn't seen any update for FORCE_VISIBLE_UPDATE_MS, push one directly
-  // rather than just queuing another invisible steering message the AI may ignore.
   const ledger = runMeta.progressLedger || {};
-  const lastVisibleMs = timestampMs(ledger.lastUserVisibleUpdateAt, 0);
-  const startedMs = timestampMs(runMeta.startedAtIso, 0) || (Date.now() - 60000);
-  const silenceSince = Date.now() - (lastVisibleMs > 0 ? lastVisibleMs : startedMs);
-
-  if (silenceSince >= FORCE_VISIBLE_UPDATE_MS && engine.messagingManager && !runMeta.terminalInterim) {
-    const { platform, chatId } = runMeta.messagingContext || {};
-    if (platform && chatId) {
-      const stepNum = ledger.currentStep != null ? ledger.currentStep : '?';
-      const tool = ledger.currentTool || 'tools';
-      const statusMsg = options.stalled
-        ? 'still here, just taking a while on this one...'
-        : `still working on it... (step ${stepNum}, running ${tool})`;
-      try {
-        await engine.messagingManager.sendMessage(runMeta.userId, platform, chatId, statusMsg, {
-          runId,
-          agentId: runMeta.agentId,
-        });
-        const nowIso = isoNow();
-        runMeta.progressLedger = { ...ledger, lastUserVisibleUpdateAt: nowIso };
-        engine.updateRunProgress(runId, { lastUserVisibleUpdateAt: nowIso });
-        engine.recordRunEvent(runMeta.userId, runId, 'forced_progress_update_sent', {
-          stepNum, tool, silenceSince, stalled: options.stalled === true,
-        }, { agentId: runMeta.agentId });
-        return { sent: true, heartbeat: true, forced: true };
-      } catch (err) {
-        console.warn('[Engine] Forced progress update send failed:', err?.message || err);
-      }
-    }
-  }
-
   engine.recordRunEvent(runMeta.userId, runId, 'progress_heartbeat_sent', {
     stalled: options.stalled === true,
     currentTool: ledger.currentTool || null,

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

@@ -117,8 +117,20 @@ function isReadOnlyInterpreterCommand(segment = '') {
   return /\b(print|json\.|json_tool|json\.load|json\.loads|sys\.stdin|process\.exit|console\.log)\b|-m\s+json\.tool/i.test(normalized);
 }
 
+function hasStateChangingRedirect(segment = '') {
+  const matches = String(segment || '').matchAll(/(?:^|[^&|;])(?:>>?|1>)\s*(?:"([^"]+)"|'([^']+)'|(\S+))/g);
+  for (const match of matches) {
+    const target = String(match[1] || match[2] || match[3] || '').trim();
+    if (!target || target === '/dev/null') continue;
+    if (target.startsWith('/tmp/') || target.startsWith('/var/tmp/')) continue;
+    return true;
+  }
+  return false;
+}
+
 function isStateChangingShellSegment(segment = '') {
   const normalized = stripEnvAssignments(segment);
+  if (hasStateChangingRedirect(normalized)) return true;
   const command = normalizeCommandName(firstToken(normalized));
   if (!command) return false;
   if (command === 'git') {
@@ -146,6 +158,7 @@ function isProgressToolCall(toolName, toolArgs = {}) {
   const name = String(toolName || '');
   if (!name) return false;
   if (name === 'activate_tools' || name === 'save_widget_snapshot') return false;
+  if (name === 'send_interim_update') return false;
   if (/^(list_|search_|read_file|get_file|find_files?|github_list|github_get|github_search|browser_get|browser_read)/.test(name)) {
     return false;
   }

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

@@ -1,8 +1,8 @@
 'use strict';
 
-const FIRST_UPDATE_MS = 30 * 1000;
-const REPEAT_UPDATE_MS = 45 * 1000;
-const STALL_MS = 120 * 1000;
+const FIRST_UPDATE_MS = 60 * 1000;
+const REPEAT_UPDATE_MS = 90 * 1000;
+const STALL_MS = 240 * 1000;
 const TICK_MS = 15 * 1000;
 
 function isoNow() {

package/server/services/ai/repetitionGuard.js

@@ -1,6 +1,9 @@
 'use strict';
 
 const crypto = require('crypto');
+const {
+  isClearlyReadOnlyShellCommand,
+} = require('./loop/progress_classification');
 
 function canonicalize(value) {
   if (Array.isArray(value)) return value.map(canonicalize);
@@ -20,6 +23,47 @@ function stableHash(value) {
   return crypto.createHash('sha256').update(text).digest('hex');
 }
 
+function normalizeReadOnlyShellIntent(command = '') {
+  const text = String(command || '')
+    .replace(/(^|\n)\s*#.*(?=\n|$)/g, '\n')
+    .replace(/2?>\s*(?:"[^"]+"|'[^']+'|\S+)/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+  const urls = [...text.matchAll(/https?:\/\/[^\s"'`|;&)]+/gi)]
+    .map((match) => match[0].replace(/[?#].*$/, ''))
+    .sort();
+  const paths = [...text.matchAll(/(?:^|\s)(\/[A-Za-z0-9._~/%+-][^\s"'`|;&)]*)/g)]
+    .map((match) => match[1].replace(/[?#].*$/, ''))
+    .filter((item) => !item.startsWith('/tmp/'))
+    .sort();
+  const repoSearches = [...text.matchAll(/\brepo:[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+/gi)]
+    .map((match) => match[0].toLowerCase())
+    .sort();
+
+  if (urls.length || paths.length || repoSearches.length) {
+    return {
+      kind: 'read_only_shell_intent',
+      urls,
+      paths,
+      repoSearches,
+    };
+  }
+
+  return {
+    kind: 'read_only_shell_command',
+    command: text
+      .replace(/\|\s*(cat|head(?:\s+-n?\s+\d+)?|tail(?:\s+-n?\s+\d+)?|wc(?:\s+-[A-Za-z]+)?)\b[^|;&]*/g, '')
+      .trim(),
+  };
+}
+
+function canonicalToolArgs(toolName, args) {
+  if (toolName === 'execute_command' && isClearlyReadOnlyShellCommand(args?.command || '')) {
+    return normalizeReadOnlyShellIntent(args.command);
+  }
+  return args || {};
+}
+
 class ToolRepetitionGuard {
   constructor({ unchangedLimit = 2 } = {}) {
     this.unchangedLimit = Math.max(1, Number(unchangedLimit) || 2);
@@ -27,7 +71,7 @@ class ToolRepetitionGuard {
   }
 
   key(toolName, args) {
-    return `${String(toolName || '')}:${stableHash(args || {})}`;
+    return `${String(toolName || '')}:${stableHash(canonicalToolArgs(toolName, args))}`;
   }
 
   shouldBlock(toolName, args) {
@@ -44,7 +88,7 @@ class ToolRepetitionGuard {
       : 1;
     const next = {
       toolName,
-      argsHash: stableHash(args || {}),
+      argsHash: stableHash(canonicalToolArgs(toolName, args)),
       resultHash,
       unchangedCount,
     };
@@ -56,5 +100,6 @@ class ToolRepetitionGuard {
 module.exports = {
   ToolRepetitionGuard,
   canonicalize,
+  normalizeReadOnlyShellIntent,
   stableHash,
 };

package/server/services/ai/taskAnalysis.js

@@ -82,6 +82,7 @@ const VERIFIER_PROMPT_INSTRUCTIONS = [
 const EXECUTION_GUIDANCE_ACTION_LINES = [
   'Act end-to-end. Run independent searches or inspections in parallel when possible. Prefer native integration tools and structured APIs over browser automation or shell scraping. Use exact IDs and required parameters; list or search first when you do not have them.',
   'For GitHub issue implementation or PR work, fetch the issue once, then establish or reuse a writable local checkout, create a task branch, inspect/edit/test locally, and push/open the PR. Use direct GitHub file mutation tools only as a fallback when a local checkout is unavailable.',
+  'Tool results are already present in the conversation as tool output. Do not assume a tool result was persisted to a readable /tmp path unless that exact path was explicitly returned by the tool result.',
   'Use send_interim_update sparingly when a short real update or question would help.',
   'When you must ask for missing required user input, ask once, then wait for the reply instead of re-asking in the same run.',
   'For outbound messages, calls, emails, shared edits, installs, restarts, or task mutations, verify the action result before claiming it happened. If user confirmation is required and missing, draft or ask instead of sending.',
@@ -559,6 +560,9 @@ function buildExecutionGuidance({ analysis, plan = null, capabilityHealth }) {
       ? `Advisory tool suggestions: ${analysis.suggested_tools.join(', ')}`
       : '',
     `Autonomy contract: complexity=${analysis.complexity || 'standard'}; autonomy_level=${analysis.autonomy_level || 'normal'}; progress_update_policy=${analysis.progress_update_policy || 'optional'}; parallel_work=${analysis.parallel_work === true}; completion_confidence_required=${analysis.completion_confidence_required || 'medium'}.`,
+    analysis.progress_update_policy === 'required'
+      ? 'Progress updates are required for this run: when the work becomes slow, changes method, or hits a temporary blocker, use send_interim_update with a concise factual update. Do not use progress updates as completion, and do not continue long read-only work silently after a progress-check nudge.'
+      : '',
     capabilityHealth ? `Capability health:\n${capabilityHealth}` : '',
   ];