neoagent 2.5.2-beta.16 → 2.5.2-beta.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "2.5.2-beta.16",
+  "version": "2.5.2-beta.18",
   "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 @@
-5acb38c4eeee836df0a631d5ed3f863e
+f7852ae0fc3e8f369c66383642692e12

package/server/public/flutter_bootstrap.js

@@ -37,6 +37,6 @@ _flutter.buildConfig = {"engineRevision":"77e2e94772b6eb43759e34ed1ad7da4674e19c
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "1920445875" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "1291084377" /* 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("mqgdktti-6bc08d8").length!==0&&r.b}if(r){r=s.d
+r=B.b.u("mqgevy6k-3f81df2").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("mqgdktti-6bc08d8").length===0||s.a!=null)return
+if(B.b.u("mqgevy6k-3f81df2").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,"mqgdktti-6bc08d8")){s=1
+if(J.bi(j)===0||J.d(j,"mqgevy6k-3f81df2")){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("mqgdktti-6bc08d8").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.u("mqgevy6k-3f81df2").length===0||n.c){s=1
 break}n.c=!0
 n.F()
 p=4

package/server/services/ai/deliverables/artifact_helpers.js

@@ -86,6 +86,25 @@ const CANDIDATE_KEYS = [
   'downloadUris',
 ];
 
+const GENERIC_CANDIDATE_KEYS = new Set([
+  'path',
+  'paths',
+  'file',
+  'files',
+  'filePath',
+  'filePaths',
+  'fullPath',
+  'fullPaths',
+  'downloadUrl',
+  'downloadUrls',
+  'downloadUri',
+  'downloadUris',
+]);
+
+const EXPLICIT_CANDIDATE_KEYS = new Set(
+  CANDIDATE_KEYS.filter((key) => !GENERIC_CANDIDATE_KEYS.has(key))
+);
+
 const ARTIFACT_CONTAINER_KEYS = new Set([
   'artifact',
   'artifacts',
@@ -105,8 +124,22 @@ const ARTIFACT_CONTAINER_KEYS = new Set([
 
 const CONTAINER_URL_KEYS = new Set(['url', 'urls', 'uri', 'uris', 'href', 'hrefs']);
 
-function isExplicitCandidateKey(keyHint = '', parentKeyHint = '') {
-  if (CANDIDATE_KEYS.includes(keyHint)) return true;
+const EVIDENCE_RESULT_TOOLS = /^(execute_command|github_|list_|search_|read_|get_|find_|http_request|web_search|browser_get|browser_read|code_navigate|query_structured_data|memory_|session_search|recordings_|read_health_data)/;
+
+function allowsGenericCandidateKeys(toolName = '') {
+  return !EVIDENCE_RESULT_TOOLS.test(String(toolName || ''));
+}
+
+function isExplicitCandidateKey(keyHint = '', parentKeyHint = '', options = {}) {
+  if (EXPLICIT_CANDIDATE_KEYS.has(keyHint)) return true;
+  if (
+    ARTIFACT_CONTAINER_KEYS.has(parentKeyHint)
+    && CANDIDATE_KEYS.includes(keyHint)
+    && (!GENERIC_CANDIDATE_KEYS.has(parentKeyHint) || options.allowGenericKeys === true)
+  ) {
+    return true;
+  }
+  if (GENERIC_CANDIDATE_KEYS.has(keyHint)) return options.allowGenericKeys === true;
   if (!CONTAINER_URL_KEYS.has(keyHint)) return false;
   return ARTIFACT_CONTAINER_KEYS.has(parentKeyHint);
 }
@@ -198,6 +231,7 @@ async function extractArtifactsFromResult(toolName, result) {
   const seen = new Set();
   const seenCandidates = new Set();
   const fallbackKind = inferArtifactKind(toolName, 'artifact');
+  const allowGenericKeys = allowsGenericCandidateKeys(toolName);
 
   async function pushCandidate(candidate) {
     const candidateKey = String(candidate || '').trim();
@@ -214,7 +248,7 @@ async function extractArtifactsFromResult(toolName, result) {
   async function visit(value, keyHint = '', parentKeyHint = '') {
     if (value == null) return;
     if (typeof value === 'string') {
-      const explicit = isExplicitCandidateKey(keyHint, parentKeyHint);
+      const explicit = isExplicitCandidateKey(keyHint, parentKeyHint, { allowGenericKeys });
       if (explicit) {
         if (normalizePathOrUri(value)) await pushCandidate(value);
         return;
@@ -240,6 +274,7 @@ async function extractArtifactsFromResult(toolName, result) {
 }
 
 module.exports = {
+  allowsGenericCandidateKeys,
   extractArtifactsFromResult,
   inferArtifactKind,
   inferMimeType,

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

@@ -125,6 +125,9 @@ const {
   getAvailableTools: getAvailableToolsImpl,
   isReadOnlyToolCall: isReadOnlyToolCallImpl,
 } = require('./tool_dispatch');
+const {
+  isProgressToolCall,
+} = require('./progress_classification');
 const {
   normalizeOutgoingMessage,
   clampRunContext,
@@ -225,8 +228,17 @@ function buildErrorPatternGuidance(key, count) {
 
 const OUTPUT_FINGERPRINT_TOOLS = /^(list_|search_|read_|get_|find_|github_list|github_get|github_search)/;
 
-function fingerprintOutput(toolName, result) {
-  if (!toolName || !OUTPUT_FINGERPRINT_TOOLS.test(toolName)) return null;
+function fingerprintOutput(toolName, result, toolArgs = {}) {
+  const name = String(toolName || '');
+  if (
+    !name
+    || (
+      !OUTPUT_FINGERPRINT_TOOLS.test(name)
+      && !(name === 'execute_command' && !isProgressToolCall(name, toolArgs))
+    )
+  ) {
+    return null;
+  }
   const raw = typeof result === 'string' ? result : JSON.stringify(result ?? '');
   if (raw.length < 200) return null;
   // djb2 hash over first 3000 chars — fast, collision-unlikely for our sizes
@@ -236,18 +248,6 @@ function fingerprintOutput(toolName, result) {
   return h >>> 0;
 }
 
-// Tools that represent concrete forward progress (write, create, send, update, run).
-// Anything NOT in this set is considered read-only for the analysis-paralysis gate.
-// execute_command counts as progress — it can do anything, including modify state.
-function isProgressTool(toolName) {
-  if (!toolName) return false;
-  // Neutral / bookkeeping — don't count either way
-  if (toolName === 'activate_tools' || toolName === 'save_widget_snapshot') return false;
-  // Explicitly read-only patterns
-  if (/^(list_|search_|read_file|get_file|find_files?|github_list|github_get|github_search|browser_get|browser_read)/.test(toolName)) return false;
-  return true;
-}
-
 function cloneInterimHistory(history = []) {
   if (!Array.isArray(history)) return [];
   return history.map((item) => ({
@@ -564,9 +564,16 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
 
   const runTitle = generateTitle(userMessage);
   const initialRunMetadata = buildInitialRunMetadata(options);
-  db.prepare(`INSERT OR REPLACE INTO agent_runs(
+  db.prepare(`INSERT INTO agent_runs(
     id, user_id, agent_id, title, status, trigger_type, trigger_source, model, metadata_json
-  ) VALUES(?, ?, ?, ?, 'running', ?, ?, ?, ?)`).run(
+  ) VALUES(?, ?, ?, ?, 'running', ?, ?, ?, ?)
+  ON CONFLICT(id) DO UPDATE SET
+    status = 'running',
+    model = excluded.model,
+    updated_at = datetime('now'),
+    completed_at = NULL,
+    error = NULL,
+    metadata_json = COALESCE(agent_runs.metadata_json, excluded.metadata_json)`).run(
     runId,
     userId,
     agentId,
@@ -762,7 +769,14 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   let iteration = 0;
   let totalTokens = 0;
   let lastContent = '';
-  let stepIndex = 0;
+  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 failedStepCount = 0;
   let modelFailureRecoveries = 0;
   let promptMetrics = {};
@@ -1070,7 +1084,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. You must take ONE concrete action this turn (create a file, open a PR, run a command that modifies state, send a message) or call task_complete to report what you found and why you cannot proceed. Do not read or list anything further.`,
+            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.`,
           });
         }
       }
@@ -1718,7 +1732,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           // Output fingerprint guard: steer away from re-fetching data already seen.
           if (!toolErrorMessage) {
             const currentRunMeta = engine.getRunMeta(runId);
-            const fp = fingerprintOutput(toolName, toolResult);
+            const fp = fingerprintOutput(toolName, toolResult, toolArgs);
             if (fp !== null && currentRunMeta?.seenOutputHashes) {
               const prior = currentRunMeta.seenOutputHashes.get(fp);
               if (prior) {
@@ -1728,24 +1742,6 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
                 });
               } else {
                 currentRunMeta.seenOutputHashes.set(fp, { toolName, iteration });
-                // External state: persist large read results to disk so the
-                // model can reference them after context compaction without
-                // re-fetching. Only for significant payloads.
-                const persistRaw = typeof toolResult === 'string' ? toolResult : JSON.stringify(toolResult ?? '');
-                if (persistRaw.length >= 1000 && runId) {
-                  const persistPath = `/tmp/run-${runId.slice(0, 8)}-${toolName}.json`;
-                  try {
-                    require('fs').writeFileSync(persistPath, persistRaw.slice(0, 40000));
-                    if (!currentRunMeta.persistedDataPaths) currentRunMeta.persistedDataPaths = [];
-                    if (!currentRunMeta.persistedDataPaths.includes(persistPath)) {
-                      currentRunMeta.persistedDataPaths.push(persistPath);
-                      messages.push({
-                        role: 'system',
-                        content: `Data from "${toolName}" (iteration ${iteration}) persisted to ${persistPath}. If context compacts and you need this data again, use execute_command with \`cat ${persistPath}\` instead of re-fetching.`,
-                      });
-                    }
-                  } catch { /* non-fatal — disk full or permissions */ }
-                }
               }
             }
           }
@@ -1816,7 +1812,11 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
         && (analysis.mode === 'execute' || analysis.mode === 'plan_execute')) {
         const iterMeta = engine.getRunMeta(runId);
         if (iterMeta) {
-          const calledProgress = response.toolCalls.some((tc) => isProgressTool(tc.function?.name || ''));
+          const calledProgress = response.toolCalls.some((tc) => {
+            let parsedArgs = {};
+            try { parsedArgs = JSON.parse(tc.function?.arguments || '{}'); } catch {}
+            return isProgressToolCall(tc.function?.name || '', parsedArgs);
+          });
           iterMeta.consecutiveReadOnlyIterations = calledProgress
             ? 0
             : (iterMeta.consecutiveReadOnlyIterations || 0) + 1;
@@ -2231,6 +2231,8 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
 
       const retryOptions = {
         ...options,
+        runId,
+        messagingRetryStepOffset: stepIndex,
         messagingAutonomousRetryCount: retryCount + 1,
         messagingRetryState: {
           lastFinalMessage: String(runMeta?.lastSentMessage || options?.messagingRetryState?.lastFinalMessage || '').trim(),
@@ -2257,7 +2259,6 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           ].filter(Boolean).join('\n\n')
         }
       };
-      delete retryOptions.runId;
 
       return engine.runWithModel(userId, userMessage, retryOptions, _modelOverride);
     }

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

@@ -0,0 +1,164 @@
+'use strict';
+
+const READ_ONLY_COMMANDS = new Set([
+  'awk',
+  'cat',
+  'curl',
+  'diff',
+  'du',
+  'egrep',
+  'env',
+  'fgrep',
+  'find',
+  'git',
+  'grep',
+  'head',
+  'jq',
+  'less',
+  'ls',
+  'pwd',
+  'rg',
+  'sed',
+  'sort',
+  'tail',
+  'tee',
+  'test',
+  'tr',
+  'tree',
+  'wc',
+  'which',
+]);
+
+const GIT_READ_ONLY_SUBCOMMANDS = new Set([
+  'branch',
+  'diff',
+  'grep',
+  'log',
+  'ls-files',
+  'ls-remote',
+  'rev-parse',
+  'show',
+  'status',
+]);
+
+const STATE_CHANGING_COMMANDS = new Set([
+  'apply_patch',
+  'chmod',
+  'chown',
+  'cp',
+  'git-clone',
+  'git-commit',
+  'git-push',
+  'git-switch',
+  'git-checkout',
+  'git-merge',
+  'git-rebase',
+  'install',
+  'mkdir',
+  'mv',
+  'npm',
+  'pnpm',
+  'rm',
+  'rmdir',
+  'touch',
+  'yarn',
+]);
+
+function stripShellNoise(command = '') {
+  return String(command || '')
+    .replace(/(^|\n)\s*#.*(?=\n|$)/g, '\n')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function firstToken(segment = '') {
+  const match = String(segment || '').trim().match(/^([A-Za-z0-9_./-]+)/);
+  return match ? match[1] : '';
+}
+
+function normalizeCommandName(token = '') {
+  return String(token || '').trim().split('/').pop().toLowerCase();
+}
+
+function splitCommandSegments(command = '') {
+  return stripShellNoise(command)
+    .split(/\s*(?:&&|\|\||;|\||\n)\s*/g)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+}
+
+function stripEnvAssignments(segment = '') {
+  let text = String(segment || '').trim();
+  while (/^[A-Za-z_][A-Za-z0-9_]*=/.test(text)) {
+    text = text.replace(/^[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s*/, '').trim();
+  }
+  return text;
+}
+
+function gitSubcommand(segment = '') {
+  const parts = stripEnvAssignments(segment).split(/\s+/).filter(Boolean);
+  if (normalizeCommandName(parts[0]) !== 'git') return '';
+  return String(parts[1] || '').toLowerCase();
+}
+
+function isReadOnlyGitCommand(segment = '') {
+  const subcommand = gitSubcommand(segment);
+  if (!subcommand) return false;
+  return GIT_READ_ONLY_SUBCOMMANDS.has(subcommand);
+}
+
+function isReadOnlyInterpreterCommand(segment = '') {
+  const normalized = stripEnvAssignments(segment);
+  const commandName = normalizeCommandName(firstToken(normalized));
+  if (!['node', 'perl', 'python', 'python3'].includes(commandName)) return false;
+  if (/\b(open|write|writefile|appendfile|unlink|rename|mkdir|rmdir|remove|rm|spawn|exec)\b/i.test(normalized)) {
+    return false;
+  }
+  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 isStateChangingShellSegment(segment = '') {
+  const normalized = stripEnvAssignments(segment);
+  const command = normalizeCommandName(firstToken(normalized));
+  if (!command) return false;
+  if (command === 'git') {
+    const subcommand = gitSubcommand(normalized);
+    return subcommand && !GIT_READ_ONLY_SUBCOMMANDS.has(subcommand);
+  }
+  return STATE_CHANGING_COMMANDS.has(command);
+}
+
+function isClearlyReadOnlyShellCommand(command = '') {
+  const segments = splitCommandSegments(command);
+  if (segments.length === 0) return false;
+  return segments.every((segment) => {
+    const normalized = stripEnvAssignments(segment);
+    if (isStateChangingShellSegment(normalized)) return false;
+    if (isReadOnlyGitCommand(normalized)) return true;
+    if (isReadOnlyInterpreterCommand(normalized)) return true;
+    const commandName = normalizeCommandName(firstToken(normalized));
+    if (!commandName) return false;
+    return READ_ONLY_COMMANDS.has(commandName);
+  });
+}
+
+function isProgressToolCall(toolName, toolArgs = {}) {
+  const name = String(toolName || '');
+  if (!name) return false;
+  if (name === 'activate_tools' || name === 'save_widget_snapshot') 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;
+  }
+  if (name === 'http_request') {
+    return String(toolArgs?.method || 'GET').toUpperCase() !== 'GET';
+  }
+  if (name === 'execute_command') {
+    return !isClearlyReadOnlyShellCommand(toolArgs?.command || '');
+  }
+  return true;
+}
+
+module.exports = {
+  isClearlyReadOnlyShellCommand,
+  isProgressToolCall,
+};

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

@@ -60,11 +60,12 @@ function evaluateProgressLiveness(runMeta, now = Date.now()) {
 
 function buildProgressNudge({ stalled = false } = {}) {
   return [
-    'Internal progress check for the active messaging run.',
+    'Mandatory internal progress check for the active messaging run.',
     stalled
       ? 'No verified progress has been recorded for the stall threshold.'
       : 'The originating chat has not received a user-visible update for the progress threshold.',
-    'On the next normal agent turn, decide whether to continue silently, send a concise model-authored interim update with send_interim_update, report a real blocker, or finish with the final answer.',
+    'Before starting more tool work, either send a concise model-authored interim update with send_interim_update, report a real blocker, or finish with the final answer.',
+    'Do not continue silently once this check is present unless the immediate next action itself delivers a final answer or explicit no-response decision.',
     'Do not repeat previous status text and do not treat an interim update as final delivery.',
   ].join(' ');
 }

package/server/services/ai/taskAnalysis.js

@@ -81,6 +81,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.',
   '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.',

package/server/services/ai/toolEvidence.js

@@ -8,6 +8,9 @@
 const { compactToolResult } = require('./toolResult');
 const { summarizeForLog } = require('./logFormat');
 const { normalizeOutgoingMessage, clampRunContext } = require('./messagingFallback');
+const {
+  isClearlyReadOnlyShellCommand,
+} = require('./loop/progress_classification');
 
 // Ordered classification rules mapping a tool name to its evidence "source"
 // bucket. First matching rule wins, so order is significant. Declared as data
@@ -83,7 +86,11 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
 
   const evidenceRelevant = evidenceRelevantExact.has(name)
     || evidenceRelevantPrefixes.some((prefix) => name.startsWith(prefix));
-  const stateChanged = stateChangingExact.has(name)
+  const stateChanged = (
+    name === 'execute_command'
+      ? !isClearlyReadOnlyShellCommand(toolArgs?.command || '')
+      : stateChangingExact.has(name)
+  )
     || name.startsWith('android_')
     || ['browser_click', 'browser_type', 'browser_evaluate'].includes(name);