neoagent 3.0.1-beta.13 → 3.0.1-beta.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "3.0.1-beta.13",
+  "version": "3.0.1-beta.15",
   "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/http/static.js

@@ -78,8 +78,10 @@ function registerStaticRoutes(app) {
   app.get(/^\/app(\/.*)?$/, serveFlutterApp);
 
   // Landing page at /
-  app.use(express.static(LANDING_DIR));
-  app.get('/', (req, res) => res.sendFile(path.join(LANDING_DIR, 'index.html')));
+  if (fs.existsSync(path.join(LANDING_DIR, 'index.html'))) {
+    app.use(express.static(LANDING_DIR));
+    app.get('/', (req, res) => res.sendFile(path.join(LANDING_DIR, 'index.html')));
+  }
 }
 
 function serveFlutterApp(req, res) {

package/server/public/.last_build_id

@@ -1 +1 @@
-6909cff5608bd6620d57f74f1cca0974
+8477300cc10bca3cb8a9dcb803dcb79d

package/server/public/flutter_bootstrap.js

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

package/server/public/main.dart.js

@@ -136637,7 +136637,7 @@ r===$&&A.b()
 p.push(A.ji(q,A.jm(!1,new A.a_(B.v1,A.cV(new A.cA(B.jF,new A.a8s(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.v("mql1l1zo-2895cea").length!==0&&r.b}if(r){r=s.d
+r=B.b.v("mql818rm-601e580").length!==0&&r.b}if(r){r=s.d
 r===$&&A.b()
 r=r.aC&&!r.au?84:0
 s=s.e
@@ -142407,7 +142407,7 @@ $S:0}
 A.a_G.prototype={}
 A.Tp.prototype={
 ng(a){var s=this
-if(B.b.v("mql1l1zo-2895cea").length===0||s.a!=null)return
+if(B.b.v("mql818rm-601e580").length===0||s.a!=null)return
 s.B2()
 s.a=A.ow(B.Sk,new A.bec(s))},
 B2(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -142425,7 +142425,7 @@ if(!t.f.b(k)){s=1
 break}i=J.a0(k,"buildId")
 h=i==null?null:B.b.v(J.p(i))
 j=h==null?"":h
-if(J.bf(j)===0||J.f(j,"mql1l1zo-2895cea")){s=1
+if(J.bf(j)===0||J.f(j,"mql818rm-601e580")){s=1
 break}n.b=!0
 n.D()
 p=2
@@ -142442,7 +142442,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$B2,r)},
 vK(){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$vK=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.v("mql1l1zo-2895cea").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.v("mql818rm-601e580").length===0||n.c){s=1
 break}n.c=!0
 n.D()
 p=4

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

@@ -2121,6 +2121,12 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       lastContent = 'Widget snapshot updated.';
     }
     const messagingSent = runMeta?.messagingSent || false;
+    const stagedProactiveReply = normalizeOutgoingMessage(
+      runMeta?.stagedProactiveMessage?.content
+      || options?.deliveryState?.stagedProactiveMessage?.content
+      || '',
+      options?.source || null,
+    );
     const lastToolWasMessaging = runMeta?.lastToolName === 'send_message' || runMeta?.lastToolName === 'make_call';
 
     // Hermes _handle_max_iterations: if the run exhausted its step budget without a
@@ -2226,6 +2232,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     if (
       !normalizeOutgoingMessage(lastContent, options?.source || null)
       && !messagingSent
+      && !stagedProactiveReply
       && runMeta?.widgetSnapshotSaved !== true
     ) {
       const explicitNoResponse = (
@@ -2275,10 +2282,11 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     const normalizedLastContent = normalizeOutgoingMessage(lastContent, options?.source || null);
     let finalResponseText = messagingSent
       ? (sentMessageText || (normalizedLastContent ? lastContent.trim() : ''))
-      : (normalizedLastContent ? lastContent.trim() : sentMessageText);
+      : (normalizedLastContent ? lastContent.trim() : (stagedProactiveReply || sentMessageText));
     const lastFinalDeliveryMessage = normalizeOutgoingMessage(
       runMeta?.lastSentMessage
       || (Array.isArray(runMeta?.sentMessages) ? runMeta.sentMessages[runMeta.sentMessages.length - 1] : '')
+      || runMeta?.stagedProactiveMessage?.content
       || '',
       options?.source || null
     );

package/server/services/ai/taskAnalysis.js

@@ -74,6 +74,8 @@ const VERIFIER_PROMPT_INSTRUCTIONS = [
   'Verify whether the draft final reply is adequately supported by the gathered evidence.',
   'If the evidence is insufficient, revise the reply so it states the uncertainty clearly instead of guessing.',
   'Cross-check every concrete claim against tool status and output. Remove or rewrite claims that are contradicted by the evidence.',
+  'When the task or prompt names a specific entity to check (for example a city, account, person, date, source, or destination), preserve that target exactly. If the gathered evidence is for a different entity, treat the draft as needing revision or insufficient evidence.',
+  'When the task says to include something only if it is available or only if a condition is met, omit that section when the evidence does not show the condition was satisfied.',
   'A non-zero execute_command exit code means partial or failed shell evidence. Do not treat later sections of a chained shell command as observed unless they were verified separately.',
   'A successful send_message or make_call means outbound delivery succeeded in this run unless a later messaging tool failed.',
   'Any claim that an outbound action already happened (sent/submitted/called/"already done") must be backed by a successful outbound tool execution in this run. If not backed, rewrite the reply to "not sent yet" and provide a draft or next concrete step.',

package/server/services/ai/tools.js

@@ -276,7 +276,33 @@ function getRunState(engine, runId) {
 
 function hasAlreadySentProactiveMessage({ triggerSource, runState, deliveryState, allowMultipleProactiveMessages }) {
     if (!isProactiveTrigger(triggerSource) || allowMultipleProactiveMessages) return false;
-    return Boolean(runState?.messagingSent || deliveryState?.messagingSent);
+    return Boolean(
+        runState?.messagingSent
+        || deliveryState?.messagingSent
+        || runState?.proactiveMessageStaged
+        || deliveryState?.proactiveMessageStaged
+    );
+}
+
+function markProactiveMessageStaged({ runState, deliveryState, platform, to, content, purpose, mediaPath = null }) {
+    const staged = {
+        platform: String(platform || '').trim(),
+        to: String(to || '').trim(),
+        content: String(content || '').trim(),
+        purpose: String(purpose || '').trim().toLowerCase(),
+        mediaPath: mediaPath || null,
+        stagedAt: new Date().toISOString(),
+    };
+
+    if (runState) {
+        runState.proactiveMessageStaged = true;
+        runState.stagedProactiveMessage = staged;
+    }
+
+    if (deliveryState) {
+        deliveryState.proactiveMessageStaged = true;
+        deliveryState.stagedProactiveMessage = staged;
+    }
 }
 
 function markProactiveMessageSent({ runState, deliveryState, content }) {
@@ -2485,6 +2511,26 @@ async function executeTool(toolName, args, context, engine) {
                 };
             }
 
+            if (isProactiveTrigger(triggerSource) && context.stageProactiveMessages === true && !suppressReply) {
+                markProactiveMessageStaged({
+                    runState,
+                    deliveryState,
+                    platform: args.platform,
+                    to: args.to,
+                    content: normalizedMessage,
+                    purpose: args.purpose,
+                    mediaPath: args.media_path,
+                });
+                return {
+                    success: true,
+                    staged: true,
+                    purpose: normalizeSendMessagePurpose(args.purpose),
+                    platform: args.platform,
+                    to: args.to,
+                    content: normalizedMessage,
+                };
+            }
+
             const sendResult = await manager.sendMessage(userId, args.platform, args.to, args.content, {
                 agentId,
                 mediaPath: args.media_path,

package/server/services/integrations/google/calendar.js

@@ -7,7 +7,7 @@ const calendarToolDefinitions = [
   {
     name: 'google_workspace_calendar_list_events',
     access: 'read',
-    description: 'List or search Google Calendar events for the connected account. Results include all-day/multi-day events (birthdays, anniversaries, full-day markers) that overlap the window — each event has an allDay flag, and the response reports timedCount and allDayCount. For "what is scheduled / starting soon", rely on timedCount and the allDay flag; do not re-query with different windows to filter out all-day entries.',
+    description: 'List or search Google Calendar events for the connected account. Results include all-day/multi-day events (birthdays, anniversaries, full-day markers) that overlap the window. Each event has an allDay flag, timedCount/allDayCount summarize the mix, and timedEvents/nextTimedEvent expose the real timed appointments directly. For "what is scheduled / starting soon", decide from that single result instead of re-querying nearby windows to filter out all-day entries.',
     parameters: {
       type: 'object',
       properties: {
@@ -167,6 +167,25 @@ function summarizeEvent(event) {
   };
 }
 
+function summarizeListedEvents(items) {
+  const events = Array.isArray(items) ? items.map(summarizeEvent) : [];
+  const timedEvents = events.filter((event) => !event.allDay);
+  const allDayEvents = events.filter((event) => event.allDay);
+  return {
+    count: events.length,
+    timedCount: timedEvents.length,
+    allDayCount: allDayEvents.length,
+    hasTimedEvents: timedEvents.length > 0,
+    hasOnlyAllDayEvents: timedEvents.length === 0 && allDayEvents.length > 0,
+    nextTimedEvent: timedEvents[0] || null,
+    timedEvents,
+    allDayEvents,
+    // Keep the legacy merged list for existing callers, but put timed items first so
+    // the most actionable event is visible without extra filtering.
+    events: [...timedEvents, ...allDayEvents],
+  };
+}
+
 async function executeCalendarTool(toolName, args, auth) {
   const calendar = google.calendar({ version: 'v3', auth });
   const calendarId = String(args.calendar_id || 'primary').trim() || 'primary';
@@ -183,19 +202,7 @@ async function executeCalendarTool(toolName, args, auth) {
         maxResults: Math.max(1, Math.min(Number(args.max_results) || 10, 50)),
       });
       const items = Array.isArray(response.data.items) ? response.data.items : [];
-      const events = items.map(summarizeEvent);
-      // Timed events first, then all-day markers, so the caller sees the entries it
-      // most likely cares about at the top. timedCount/allDayCount let a scheduled
-      // check conclude "nothing is actually scheduled" from one query instead of
-      // re-filtering the same flooded result set over and over.
-      const timed = events.filter((event) => !event.allDay);
-      const allDay = events.filter((event) => event.allDay);
-      return {
-        count: events.length,
-        timedCount: timed.length,
-        allDayCount: allDay.length,
-        events: [...timed, ...allDay],
-      };
+      return summarizeListedEvents(items);
     }
 
     case 'google_workspace_calendar_create_event': {
@@ -300,4 +307,5 @@ module.exports = {
   calendarToolDefinitions,
   executeCalendarTool,
   summarizeEvent,
+  summarizeListedEvents,
 };

package/server/services/tasks/runtime.js

@@ -462,6 +462,8 @@ class TaskRuntime {
     const deliveryState = {
       messagingSent: false,
       noResponse: false,
+      proactiveMessageStaged: false,
+      stagedProactiveMessage: null,
       lastSentMessage: '',
       sentMessages: [],
     };
@@ -489,7 +491,7 @@ class TaskRuntime {
       if (normalizedConfig.callTo) {
         notifyHint = `\n\nThis task is configured to notify the user by phone. Use the make_call tool to call "${normalizedConfig.callTo}" with an appropriate greeting based on your findings. The configured greeting hint is: "${normalizedConfig.callGreeting || 'Hello, this is your task reminder.'}"`;
       } else if (normalizedConfig.notifyPlatform && normalizedConfig.notifyTo) {
-        notifyHint = `\n\nIf your task result is worth notifying the user about, send it proactively via send_message to platform="${normalizedConfig.notifyPlatform}" to="${normalizedConfig.notifyTo}" and set purpose="final_result" for a concrete useful outcome or purpose="blocker" for a real issue the user should know about. If nothing important or actionable changed, call send_message with purpose="no_response" and content="[NO RESPONSE]".${manualRun ? '' : ' For this automatic scheduled run, plain assistant text is internal only and is NOT delivered. You MUST end the run with exactly one explicit send_message decision (purpose="final_result", "blocker", or "no_response") — if you produce a real result, deliver it with send_message or it is lost.'}`;
+        notifyHint = `\n\nIf your task result is worth notifying the user about, send it proactively via send_message to platform="${normalizedConfig.notifyPlatform}" to="${normalizedConfig.notifyTo}" and set purpose="final_result" for a concrete useful outcome or purpose="blocker" for a real issue the user should know about. If nothing important or actionable changed, call send_message with purpose="no_response" and content="[NO RESPONSE]" exactly; never leave content blank for no_response. When a tool result already gives you summary fields or flags that answer the task, decide from that evidence instead of re-running nearby variants of the same lookup.${manualRun ? '' : ' For this automatic scheduled run, plain assistant text is internal only and is NOT delivered. You MUST end the run with exactly one explicit send_message decision (purpose="final_result", "blocker", or "no_response") — if you produce a real result, deliver it with send_message or it is lost.'}`;
       }
 
       const triggerPayloadText = executionMeta.triggerPayload
@@ -521,13 +523,14 @@ class TaskRuntime {
           taskId,
           deliveryState,
           allowMultipleProactiveMessages: normalizedConfig.allowMultipleMessages === true || normalizedConfig.allow_multiple_messages === true,
+          stageProactiveMessages: true,
           skipTaskAnalysis: true,
           skipDeliverableWorkflow: true,
           skipGlobalRecall: true,
           skipConversationHistory: true,
           skipConversationMaintenance: true,
           skipRunContextPersistence: true,
-          skipVerifier: true,
+          skipVerifier: false,
           stream: false,
           context: executionMeta.triggerPayload || {},
         };
@@ -841,13 +844,19 @@ class TaskRuntime {
     if (!targets.length) return null;
     const resultText = stringifyTaskResult(result).trim();
     const resultLooksLikeError = Boolean(result?.error);
+    const stagedMessage = normalizeOutgoingMessageForPlatform(
+      deliveryState?.stagedProactiveMessage?.platform,
+      deliveryState?.stagedProactiveMessage?.content || '',
+      { stripNoResponseMarker: false },
+    );
+    const explicitStagedDelivery = deliveryState?.proactiveMessageStaged === true && Boolean(stagedMessage);
     // A forced terminal wrap-up (read-only/blocked hard-stop) is the model's final
     // answer produced WITHOUT the ability to call send_message itself. Gating it
     // would silently drop a stuck scheduled task's result, so deliver it even on an
     // automatic run. Ordinary mid-run plain text (model had send_message available
     // and chose not to use it) is still gated below.
     const forcedTerminal = deliveryState?.terminalWrapup === true && Boolean(resultText);
-    if (!allowPlainResultFallback && !resultLooksLikeError && !forcedTerminal) {
+    if (!allowPlainResultFallback && !resultLooksLikeError && !forcedTerminal && !explicitStagedDelivery) {
       // Automatic run produced substantive text but never made an explicit
       // send_message decision (a deliberate no_response would have short-circuited
       // above). We suppress to avoid recurring-check spam, but surface it so a
@@ -874,10 +883,17 @@ class TaskRuntime {
     }
 
     let lastError = null;
-    for (const target of targets) {
+    const resolvedTargets = explicitStagedDelivery
+      ? [{
+        platform: deliveryState.stagedProactiveMessage.platform,
+        to: deliveryState.stagedProactiveMessage.to,
+        mediaPath: deliveryState.stagedProactiveMessage.mediaPath || null,
+      }]
+      : targets;
+    for (const target of resolvedTargets) {
       const message = normalizeOutgoingMessageForPlatform(
         target.platform,
-        resultText,
+        resultText || stagedMessage,
         { stripNoResponseMarker: false },
       );
       if (!message || message.toUpperCase() === '[NO RESPONSE]') return null;
@@ -893,10 +909,13 @@ class TaskRuntime {
       try {
         const sendResult = await manager.sendMessage(userId, target.platform, target.to, message, {
           agentId,
+          mediaPath: target.mediaPath || null,
           runId: result?.runId || null,
           persistConversation: true,
         });
         deliveryState.messagingSent = true;
+        deliveryState.proactiveMessageStaged = false;
+        deliveryState.stagedProactiveMessage = null;
         deliveryState.lastSentMessage = message;
         if (!Array.isArray(deliveryState.sentMessages)) {
           deliveryState.sentMessages = [];