neoagent 3.0.1-beta.5 → 3.0.1-beta.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "3.0.1-beta.5",
+  "version": "3.0.1-beta.6",
   "description": "Self-hosted AI agent for long-running tasks, automation, messaging, device control, and local memory",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",

package/server/public/.last_build_id

@@ -1 +1 @@
-5a04b7963f3a3e683486fb212ebbfe09
+504d057957ef960afb5bd462407c2c9f

package/server/public/flutter_bootstrap.js

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

package/server/public/main.dart.js

@@ -135597,7 +135597,7 @@ r===$&&A.b()
 p.push(A.jV(q,A.jd(!1,new A.a_(B.uM,A.db(new A.cC(B.jA,new A.a89(r,q),q),q,q),q),!1,B.I,!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("mqimox8o-0a587b7").length!==0&&r.b}if(r){r=s.d
+r=B.b.u("mqin9jwm-c5e3286").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.aP&&!r.ai?84:0
 s=s.e
@@ -141319,7 +141319,7 @@ $S:0}
 A.a_p.prototype={}
 A.T7.prototype={
 nd(a){var s=this
-if(B.b.u("mqimox8o-0a587b7").length===0||s.a!=null)return
+if(B.b.u("mqin9jwm-c5e3286").length===0||s.a!=null)return
 s.B_()
 s.a=A.ot(B.S2,new A.bde(s))},
 B_(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -141337,7 +141337,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.bj(j)===0||J.e(j,"mqimox8o-0a587b7")){s=1
+if(J.bj(j)===0||J.e(j,"mqin9jwm-c5e3286")){s=1
 break}n.b=!0
 n.F()
 p=2
@@ -141354,7 +141354,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$B_,r)},
 vI(){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$vI=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.u("mqimox8o-0a587b7").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.u("mqin9jwm-c5e3286").length===0||n.c){s=1
 break}n.c=!0
 n.F()
 p=4

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

@@ -21,7 +21,9 @@ const { shouldAcceptTaskComplete } = require('../completion');
 const { shortenRunId, summarizeForLog } = require('../logFormat');
 const { runConversation } = require('./conversation_loop');
 const {
+  buildChurnAssessmentPrompt,
   buildCompletionDecisionPrompt,
+  normalizeChurnAssessment,
   normalizeCompletionDecision,
   resolveRunGoalContext,
 } = require('./completion_judge');
@@ -812,6 +814,46 @@ class AgentEngine {
     };
   }
 
+  async assessChurnState({
+    provider,
+    providerName,
+    model,
+    messages,
+    analysis,
+    plan,
+    toolExecutions,
+    readOnlyCount,
+    alreadyRead,
+    iteration,
+    options,
+  }) {
+    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: buildChurnAssessmentPrompt({
+        readOnlyCount,
+        alreadyRead,
+        goalContext,
+        toolExecutions,
+        iteration,
+      }),
+      maxTokens: 200,
+      normalize: (raw) => normalizeChurnAssessment(raw),
+      fallback: { assessment: 'churn', reason: 'churn assessment unavailable' },
+      reasoningEffort: this.getReasoningEffort(providerName, options),
+      telemetry: options,
+      phase: 'churn_assessment',
+    });
+    return {
+      assessment: response.value,
+      usage: response.usage,
+    };
+  }
+
   async refreshConversationState({
     conversationId,
     runId,

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

@@ -241,12 +241,61 @@ function normalizeCompletionDecision(raw, fallbackStatus = 'continue') {
   };
 }
 
+/**
+ * Ask the model to self-assess whether it is making genuine progress or
+ * spinning in analysis-paralysis. This replaces the hardcoded nudge threshold
+ * with an AI-controlled signal: the model knows its own plan better than any
+ * regex over tool names can infer.
+ *
+ * Intentionally lightweight — the response is capped at 200 tokens and the
+ * prompt is self-contained so the model can answer without re-reading history.
+ */
+function buildChurnAssessmentPrompt({
+  readOnlyCount,
+  alreadyRead,
+  goalContext,
+  toolExecutions,
+  iteration,
+}) {
+  const lines = [
+    'Return JSON only.',
+    'Self-assess your current loop state — are you making genuine progress or spinning?',
+    'Schema: {"assessment":"progressing|churn|blocked","reason":"one short concrete sentence"}',
+    '',
+    `Context: ${readOnlyCount} consecutive iteration(s) with only read/search/inspect operations — no concrete state changes yet.`,
+    alreadyRead ? `Already inspected: ${alreadyRead}.` : '',
+    goalContext.effectiveGoal ? `Goal: ${goalContext.effectiveGoal}` : '',
+    goalContext.successCriteria.length > 0
+      ? `Success criteria:\n${goalContext.successCriteria.map((c, i) => `${i + 1}. ${c}`).join('\n')}`
+      : '',
+    `Iteration: ${iteration}`,
+    `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 6) || 'none'}`,
+    '',
+    'Assessment rules:',
+    '- "progressing": You are systematically gathering necessary context and the next concrete action is already determined — you know exactly what to do next.',
+    '- "churn": You are re-reading/re-searching information already in context, or exploring without a clear next concrete step. Accept the nudge and act.',
+    '- "blocked": No concrete action is available in this run. You have all the evidence needed to deliver a truthful final answer or a specific external blocker.',
+  ];
+  return lines.filter(Boolean).join('\n');
+}
+
+function normalizeChurnAssessment(raw) {
+  const allowed = new Set(['progressing', 'churn', 'blocked']);
+  const assessment = String(raw?.assessment || '').trim().toLowerCase();
+  return {
+    assessment: allowed.has(assessment) ? assessment : 'churn',
+    reason: String(raw?.reason || '').trim().slice(0, 300),
+  };
+}
+
 module.exports = {
+  buildChurnAssessmentPrompt,
   buildCompletionDecisionPrompt,
   buildGoalContractPrompt,
   goalContractFromAnalysis,
   goalContractFromPlan,
   mergeGoalContracts,
+  normalizeChurnAssessment,
   normalizeCompletionDecision,
   normalizeGoalContract,
   resolveRunGoalContext,

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

@@ -49,7 +49,7 @@ const {
   selectDeliverableWorkflow,
   validateDeliverableExecution,
 } = require('../deliverables');
-const { buildLoopPolicy, resolveToolResultLimits } = require('../loopPolicy');
+const { buildLoopPolicy, resolveToolResultLimits, resolveChurnNudgeThreshold } = require('../loopPolicy');
 const { globalHooks } = require('../hooks');
 const { normalizeCompletionConfidence, shouldAcceptTaskComplete } = require('../completion');
 const { enforceRateLimits } = require('../rate_limits');
@@ -1180,73 +1180,140 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       messages = steeringAtLoopStart.messages;
       messages = sanitizeConversationMessages(messages);
 
-      // Analysis-paralysis gate: fire at the start of every iteration where
-      // the agent has spent N turns only reading/listing/searching without
-      // taking any concrete action. Escalates in urgency each turn.
+      // Analysis-paralysis gate (EVE-style: AI self-assessment instead of
+      // hardcoded counters). The nudge threshold is derived from the goal
+      // contract complexity/autonomy_level that the model set during task
+      // analysis, making the loop budget sensitivity AI-controlled.
+      //
+      // Flow:
+      //   readOnlyCount >= maxConsecutiveReadOnlyIterations → hard safety net,
+      //     force wrap-up unconditionally (same as before).
+      //   readOnlyCount >= churnNudgeThreshold → ask the model to self-assess:
+      //     "progressing" → give grace (partial counter reset, loop continues).
+      //     "churn"       → inject the nudge so the model can course-correct.
+      //     "blocked"     → trigger the force wrap-up early (AI-authorised).
       if (analysis.mode === 'execute' || analysis.mode === 'plan_execute') {
         const readOnlyCount = engine.getRunMeta(runId)?.consecutiveReadOnlyIterations || 0;
-        if (readOnlyCount >= 3) {
-          const alreadyRead = summarizeReadTargets(toolExecutions);
-          messages.push({
-            role: 'system',
-            content: buildReadOnlyChurnGuidance({ readOnlyCount, alreadyRead }),
-          });
-        }
-        if (readOnlyCount >= loopPolicy.maxConsecutiveReadOnlyIterations) {
-          const alreadyRead = summarizeReadTargets(toolExecutions);
-          console.warn(
-            `[Run ${shortenRunId(runId)}] no_progress_wrapup readOnlyCount=${readOnlyCount}`
-          );
-          engine.updateRunProgress(runId, {
-            currentPhase: 'model',
-            currentStep: 'model:no_progress_wrapup',
-            currentTool: null,
-            currentStepStartedAt: isoNow(),
-          });
-          let wrapTokens = 0;
-          try {
-            const wrapResponse = await withModelCallTimeout(
-              provider.chat(
-                sanitizeConversationMessages([
-                  ...messages,
-                  {
-                    role: 'system',
-                    content: buildNoProgressWrapupPrompt({
-                      readOnlyCount,
-                      alreadyRead,
-                      platform: options?.source || null,
-                    }),
-                  },
-                ]),
-                [],
-                { model, reasoningEffort: engine.getReasoningEffort(providerName, options) },
-              ),
-              options,
-              'No-progress wrap-up',
-            );
-            wrapTokens = wrapResponse.usage?.totalTokens || 0;
-            lastContent = sanitizeModelOutput(wrapResponse.content || '', { model });
-          } catch (wrapErr) {
-            console.warn(`[Run ${shortenRunId(runId)}] no_progress_wrapup failed: ${summarizeForLog(wrapErr?.message || wrapErr, 180)}`);
-          }
-          totalTokens += wrapTokens;
-          const usableWrap = normalizeOutgoingMessage(lastContent, options?.source || null);
-          if (!usableWrap) {
-            lastContent = buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
+
+        if (readOnlyCount > 0) {
+          const runGoalCtx = resolveRunGoalContext(engine.getRunMeta(runId), analysis, plan);
+          const churnNudgeThreshold = resolveChurnNudgeThreshold(runGoalCtx.goalContract);
+
+          let triggerForceWrapup = false;
+          let forceWrapupSource = 'hard_limit';
+          // Compute alreadyRead lazily — only needed at or above the nudge threshold.
+          let alreadyRead = '';
+
+          if (readOnlyCount >= loopPolicy.maxConsecutiveReadOnlyIterations) {
+            alreadyRead = summarizeReadTargets(toolExecutions);
+            triggerForceWrapup = true;
+          } else if (readOnlyCount >= churnNudgeThreshold) {
+            alreadyRead = summarizeReadTargets(toolExecutions);
+            let churnResult;
+            try {
+              churnResult = await engine.assessChurnState({
+                provider,
+                providerName,
+                model,
+                messages,
+                analysis,
+                plan,
+                toolExecutions,
+                readOnlyCount,
+                alreadyRead,
+                iteration,
+                options: { ...options, triggerSource, runId, userId, agentId },
+              });
+            } catch (churnErr) {
+              console.warn(`[Run ${shortenRunId(runId)}] churn_assessment failed: ${summarizeForLog(churnErr?.message || churnErr, 120)}`);
+              churnResult = { assessment: { assessment: 'churn', reason: '' }, usage: 0 };
+            }
+            totalTokens += churnResult.usage || 0;
+            engine.recordRunEvent(userId, runId, 'churn_assessment', {
+              assessment: churnResult.assessment.assessment,
+              reason: churnResult.assessment.reason,
+              readOnlyCount,
+              churnNudgeThreshold,
+              iteration,
+            }, { agentId });
+
+            const churnVerdict = churnResult.assessment.assessment;
+            if (churnVerdict === 'blocked') {
+              triggerForceWrapup = true;
+              forceWrapupSource = 'ai_blocked';
+            } else if (churnVerdict === 'progressing') {
+              // Model is genuinely on track — partially reset so it gets
+              // re-assessed after one more read-only turn rather than immediately.
+              const iterMeta = engine.getRunMeta(runId);
+              if (iterMeta) {
+                iterMeta.consecutiveReadOnlyIterations = Math.max(0, churnNudgeThreshold - 1);
+              }
+            } else {
+              // 'churn' — model acknowledges it is spinning; inject the nudge
+              // so it can course-correct in the next iteration.
+              messages.push({
+                role: 'system',
+                content: buildReadOnlyChurnGuidance({ readOnlyCount, alreadyRead }),
+              });
+            }
           }
-          messages.push({ role: 'assistant', content: lastContent });
-          if (conversationId) {
-            db.prepare('INSERT INTO conversation_messages (conversation_id, role, content, tokens) VALUES (?, ?, ?, ?)')
-              .run(conversationId, 'assistant', lastContent, usableWrap ? wrapTokens : 0);
+
+          if (triggerForceWrapup) {
+            console.warn(
+              `[Run ${shortenRunId(runId)}] no_progress_wrapup source=${forceWrapupSource} readOnlyCount=${readOnlyCount}`
+            );
+            engine.updateRunProgress(runId, {
+              currentPhase: 'model',
+              currentStep: 'model:no_progress_wrapup',
+              currentTool: null,
+              currentStepStartedAt: isoNow(),
+            });
+            let wrapTokens = 0;
+            try {
+              const wrapResponse = await withModelCallTimeout(
+                provider.chat(
+                  sanitizeConversationMessages([
+                    ...messages,
+                    {
+                      role: 'system',
+                      content: buildNoProgressWrapupPrompt({
+                        readOnlyCount,
+                        alreadyRead,
+                        platform: options?.source || null,
+                      }),
+                    },
+                  ]),
+                  [],
+                  { model, reasoningEffort: engine.getReasoningEffort(providerName, options) },
+                ),
+                options,
+                'No-progress wrap-up',
+              );
+              wrapTokens = wrapResponse.usage?.totalTokens || 0;
+              lastContent = sanitizeModelOutput(wrapResponse.content || '', { model });
+            } catch (wrapErr) {
+              console.warn(`[Run ${shortenRunId(runId)}] no_progress_wrapup failed: ${summarizeForLog(wrapErr?.message || wrapErr, 180)}`);
+            }
+            totalTokens += wrapTokens;
+            const usableWrap = normalizeOutgoingMessage(lastContent, options?.source || null);
+            if (!usableWrap) {
+              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, usableWrap ? wrapTokens : 0);
+            }
+            engine.recordRunEvent(userId, runId, 'no_progress_wrapup_delivered', {
+              iteration,
+              readOnlyCount,
+              source: usableWrap ? 'model' : 'deterministic',
+              forceWrapupSource,
+              stepIndex,
+            }, { agentId });
+            directAnswerEligible = true;
+            break;
           }
-          engine.recordRunEvent(userId, runId, 'no_progress_wrapup_delivered', {
-            iteration,
-            readOnlyCount,
-            source: usableWrap ? 'model' : 'deterministic',
-            stepIndex,
-          }, { agentId });
-          directAnswerEligible = true;
-          break;
         }
       }
 

package/server/services/ai/loopPolicy.js

@@ -176,4 +176,21 @@ function resolveToolResultLimits(toolName, policy) {
   return { softLimit: soft, hardLimit: hard };
 }
 
-module.exports = { buildLoopPolicy, getToolCategory, resolveToolResultLimits };
+/**
+ * Resolve the read-only churn nudge threshold from the current goal contract.
+ * The AI itself sets complexity and autonomy_level during task analysis, so
+ * this threshold is indirectly AI-controlled rather than a hardcoded constant.
+ *
+ * Simple tasks get nudged sooner (2 read-only turns) because exploration is
+ * rarely needed. Complex/high-autonomy tasks get more latitude (5 turns) before
+ * the churn self-assessment fires.
+ */
+function resolveChurnNudgeThreshold(goalContract) {
+  const complexity = String(goalContract?.complexity || 'standard').toLowerCase();
+  const autonomyLevel = String(goalContract?.autonomyLevel || goalContract?.autonomy_level || 'normal').toLowerCase();
+  if (complexity === 'simple') return 2;
+  if (complexity === 'complex' || autonomyLevel === 'high') return 5;
+  return 3;
+}
+
+module.exports = { buildLoopPolicy, getToolCategory, resolveToolResultLimits, resolveChurnNudgeThreshold };