neoagent 3.0.1-beta.8 → 3.1.0

package/server/services/tasks/runtime.js

@@ -19,6 +19,10 @@ const { isTransientError } = require('../ai/providerRetry');
 const MAX_AUTONOMOUS_RETRIES = 1;
 const MAX_RECURRING_TASK_START_DELAY_MS = 90 * 1000;
 const INTEGRATION_TRIGGER_POLL_CRON = '* * * * *';
+const DEFAULT_TASK_LOOP_BUDGET = Object.freeze({
+  maxRunsPerDay: 24,
+  maxTokensPerDay: 250000,
+});
 
 function normalizeStoredString(value) {
   if (value == null) return '';
@@ -66,6 +70,37 @@ function stringifyTaskResult(result) {
   return '';
 }
 
+function finitePositiveInteger(value, fallback, max = Number.MAX_SAFE_INTEGER) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return Math.min(Math.floor(parsed), max);
+}
+
+function normalizeLoopBudgetConfig(taskConfig = {}) {
+  const raw = taskConfig.loopBudget && typeof taskConfig.loopBudget === 'object' && !Array.isArray(taskConfig.loopBudget)
+    ? taskConfig.loopBudget
+    : {};
+  const disabled = raw.enabled === false || raw.enabled === 'false';
+  const paused = raw.paused === true
+    || raw.pause === true
+    || taskConfig.loopPaused === true
+    || taskConfig.loop_paused === true;
+  return {
+    enabled: !disabled,
+    paused,
+    maxRunsPerDay: finitePositiveInteger(
+      raw.maxRunsPerDay ?? raw.max_runs_per_day,
+      DEFAULT_TASK_LOOP_BUDGET.maxRunsPerDay,
+      500,
+    ),
+    maxTokensPerDay: finitePositiveInteger(
+      raw.maxTokensPerDay ?? raw.max_tokens_per_day,
+      DEFAULT_TASK_LOOP_BUDGET.maxTokensPerDay,
+      20_000_000,
+    ),
+  };
+}
+
 class TaskRuntime {
   constructor(io, agentEngine, app = null, options = {}) {
     this.io = io;
@@ -90,6 +125,10 @@ class TaskRuntime {
     return this.app?.locals?.integrationManager || null;
   }
 
+  get timelineService() {
+    return this.app?.locals?.timelineService || null;
+  }
+
   getStatus() {
     return {
       state: this.state,
@@ -377,9 +416,18 @@ class TaskRuntime {
     if (!task.enabled) return;
     if ((task.trigger_type || 'schedule') !== 'schedule') return;
     const triggerConfig = this._normalizeJson(task.trigger_config);
-    if (triggerConfig.mode === 'one_time') return;
-    const cronExpression = String(triggerConfig.cronExpression || '').trim();
-    if (!cronExpression) return;
+    // Resolve the cron expression from the structured trigger_config, falling
+    // back to the legacy cron_expression column. An older migration could leave
+    // the expression in only one of the two places; as long as either still
+    // holds it, the task must keep being scheduled.
+    const cronExpression = String(
+      triggerConfig.cronExpression || task.cron_expression || '',
+    ).trim();
+    // One-time runs are driven by the one-time poller, not node-cron. Only skip
+    // here when there is genuinely no recurring cron expression to honor.
+    if (!cronExpression) {
+      return;
+    }
     const job = this.cron.schedule(cronExpression, async () => {
       try {
         await this._executeTask(task.id, task.user_id, {
@@ -410,6 +458,16 @@ class TaskRuntime {
     }
     const executionKey = `${userId}:${taskId}`;
     if (this.runningTaskExecutions.has(executionKey)) {
+      this._recordTaskLifecycle({
+        userId,
+        taskId,
+        taskName: this.taskRepository.getTaskById(taskId, userId)?.name || `Task ${taskId}`,
+        agentId: this.taskRepository.getTaskById(taskId, userId)?.agent_id || null,
+        eventKind: 'task_skipped',
+        reason: 'already_running_or_queued',
+        triggerType: executionMeta.triggerType || null,
+        triggerSource: executionMeta.triggerSource || null,
+      });
       this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
         taskId,
         reason: 'already_running_or_queued',
@@ -445,6 +503,16 @@ class TaskRuntime {
       && (Date.now() - scheduledAtMs) > MAX_RECURRING_TASK_START_DELAY_MS
     );
     if (isLateRecurringRun) {
+      this._recordTaskLifecycle({
+        userId,
+        taskId,
+        taskName: task.name || `Task ${taskId}`,
+        agentId,
+        eventKind: 'task_skipped',
+        reason: 'stale_start_delay',
+        triggerType: executionMeta.triggerType || null,
+        triggerSource: executionMeta.triggerSource || null,
+      });
       this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
         taskId,
         reason: 'stale_start_delay',
@@ -454,14 +522,52 @@ class TaskRuntime {
       return { skipped: true, reason: 'stale_start_delay' };
     }
 
+    const budgetDecision = this._evaluateTaskLoopBudget(task, taskConfig, userId, {
+      manual: executionMeta.manual === true,
+    });
+    if (budgetDecision.mode === 'paused' || budgetDecision.mode === 'exhausted') {
+      this._recordTaskLifecycle({
+        userId,
+        taskId,
+        taskName: task.name || `Task ${taskId}`,
+        agentId,
+        eventKind: 'task_skipped',
+        reason: budgetDecision.reason,
+        triggerType: executionMeta.triggerType || null,
+        triggerSource: executionMeta.triggerSource || null,
+      });
+      this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
+        taskId,
+        reason: budgetDecision.reason,
+        budget: budgetDecision.snapshot,
+        timestamp: new Date().toISOString(),
+      });
+      return {
+        skipped: true,
+        reason: budgetDecision.reason,
+        budget: budgetDecision.snapshot,
+      };
+    }
+
     this.taskRepository.markTaskRun(taskId, userId);
     this.io.to(`user:${userId}`).emit('tasks:task_running', { taskId, timestamp: new Date().toISOString() });
+    this._recordTaskLifecycle({
+      userId,
+      taskId,
+      taskName: task.name || `Task ${taskId}`,
+      agentId,
+      eventKind: 'task_started',
+      triggerType: executionMeta.triggerType || null,
+      triggerSource: executionMeta.triggerSource || null,
+    });
 
     let normalizedConfig = taskConfig;
     const taskName = task.name || `Task ${taskId}`;
     const deliveryState = {
       messagingSent: false,
       noResponse: false,
+      proactiveMessageStaged: false,
+      stagedProactiveMessage: null,
       lastSentMessage: '',
       sentMessages: [],
     };
@@ -478,6 +584,15 @@ class TaskRuntime {
           scheduledAt: executionMeta.scheduledAt || null,
         });
         this.io.to(`user:${userId}`).emit('tasks:task_complete', { taskId, result });
+        this._recordTaskLifecycle({
+          userId,
+          taskId,
+          taskName,
+          agentId,
+          eventKind: 'task_completed',
+          triggerType: executionMeta.triggerType || null,
+          triggerSource: executionMeta.triggerSource || null,
+        });
         return result;
       }
 
@@ -489,7 +604,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
@@ -514,20 +629,22 @@ class TaskRuntime {
         const finalPrompt = basePrompt + recoveryNote;
         const runOptions = {
           triggerType: task.trigger_type || 'schedule',
-          triggerSource: task.trigger_type || 'schedule',
+          triggerSource: executionMeta.triggerSource || task.trigger_type || 'schedule',
           agentId,
           app: this.app,
           conversationId,
           taskId,
+          bypassUserRateLimits: true,
           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 || {},
         };
@@ -563,6 +680,16 @@ class TaskRuntime {
             );
           }
           this.io.to(`user:${userId}`).emit('tasks:task_complete', { taskId, result });
+          this._recordTaskLifecycle({
+            userId,
+            taskId,
+            taskName,
+            agentId,
+            eventKind: 'task_completed',
+            runId: completedRunId,
+            triggerType: executionMeta.triggerType || null,
+            triggerSource: executionMeta.triggerSource || null,
+          });
           return result;
         } catch (err) {
           const transientExecutionError = isTransientError(err);
@@ -571,6 +698,18 @@ class TaskRuntime {
           }
           if (err?.code === 'TASK_DELIVERY_FAILED') throw err;
           if (transientExecutionError) {
+            this._recordTaskLifecycle({
+              userId,
+              taskId,
+              taskName,
+              agentId,
+              eventKind: 'task_skipped',
+              runId: completedRunId,
+              reason: 'transient_rate_limit',
+              error: err.message,
+              triggerType: executionMeta.triggerType || null,
+              triggerSource: executionMeta.triggerSource || null,
+            });
             this.io.to(`user:${userId}`).emit('tasks:task_skipped', {
               taskId,
               reason: 'transient_rate_limit',
@@ -620,10 +759,79 @@ class TaskRuntime {
         error: err.message,
         timestamp: new Date().toISOString(),
       });
+      this._recordTaskLifecycle({
+        userId,
+        taskId,
+        taskName,
+        agentId,
+        eventKind: 'task_failed',
+        runId: completedRunId,
+        error: err.message,
+        triggerType: executionMeta.triggerType || null,
+        triggerSource: executionMeta.triggerSource || null,
+      });
       return { skipped: false, error: err.message, runId: completedRunId };
     }
   }
 
+  _recordTaskLifecycle({
+    userId,
+    taskId,
+    taskName,
+    agentId = null,
+    eventKind,
+    runId = null,
+    reason = null,
+    error = null,
+    triggerType = null,
+    triggerSource = null,
+  }) {
+    if (!this.timelineService?.recordTaskLifecycle) {
+      return;
+    }
+    this.timelineService.recordTaskLifecycle({
+      userId,
+      agentId,
+      taskId,
+      taskName,
+      eventKind,
+      runId,
+      reason,
+      error,
+      triggerType,
+      triggerSource,
+    });
+  }
+
+  _evaluateTaskLoopBudget(task, taskConfig, userId, options = {}) {
+    const budget = normalizeLoopBudgetConfig(taskConfig);
+    const usage = this.taskRepository.getTaskLoopUsageToday(task.id, userId);
+    const runCount = Number(usage.runCount || 0);
+    const totalTokens = Number(usage.totalTokens || 0);
+    const snapshot = {
+      enabled: budget.enabled,
+      paused: budget.paused,
+      runCount,
+      totalTokens,
+      maxRunsPerDay: budget.maxRunsPerDay,
+      maxTokensPerDay: budget.maxTokensPerDay,
+    };
+
+    if (!budget.enabled) {
+      return { mode: 'normal', reason: null, snapshot };
+    }
+    if (budget.paused) {
+      return { mode: 'paused', reason: 'loop_budget_paused', snapshot };
+    }
+
+    const projectedRunCount = options.manual === true ? runCount : runCount + 1;
+    if (projectedRunCount > budget.maxRunsPerDay || totalTokens >= budget.maxTokensPerDay) {
+      return { mode: 'exhausted', reason: 'loop_budget_exhausted', snapshot };
+    }
+
+    return { mode: 'normal', reason: null, snapshot };
+  }
+
   _normalizeJson(value) {
     return normalizeJsonObject(value);
   }
@@ -716,6 +924,7 @@ class TaskRuntime {
       lastTriggeredAt: row.last_triggered_at || null,
       taskType: row.task_type || 'agent_prompt',
       taskConfig,
+      loopBudget: normalizeLoopBudgetConfig(taskConfig),
       prompt: taskConfig.prompt || '',
       model: taskConfig.model || null,
       agentId,
@@ -841,13 +1050,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 +1089,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 +1115,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 = [];

package/server/services/tasks/schedule_utils.js

@@ -141,11 +141,11 @@ function parseCronExpression(expression) {
 }
 
 function matchesCron(date, schedule) {
-  const minute = date.getUTCMinutes();
-  const hour = date.getUTCHours();
-  const dayOfMonth = date.getUTCDate();
-  const month = date.getUTCMonth() + 1;
-  const dayOfWeek = date.getUTCDay();
+  const minute = date.getMinutes();
+  const hour = date.getHours();
+  const dayOfMonth = date.getDate();
+  const month = date.getMonth() + 1;
+  const dayOfWeek = date.getDay();
 
   if (!schedule.minute.values.has(minute)) return false;
   if (!schedule.hour.values.has(hour)) return false;

package/server/services/tasks/task_repository.js

@@ -144,6 +144,19 @@ class TaskRepository {
     db.prepare('UPDATE scheduled_tasks SET last_run = datetime(\'now\') WHERE id = ? AND user_id = ?').run(taskId, userId);
   }
 
+  getTaskLoopUsageToday(taskId, userId) {
+    return db.prepare(
+      `SELECT
+         COUNT(*) AS runCount,
+         COALESCE(SUM(total_tokens), 0) AS totalTokens
+       FROM agent_runs
+       WHERE user_id = ?
+         AND json_valid(metadata_json)
+         AND CAST(json_extract(metadata_json, '$.taskId') AS TEXT) = CAST(? AS TEXT)
+         AND date(created_at) = date('now')`
+    ).get(userId, String(taskId)) || { runCount: 0, totalTokens: 0 };
+  }
+
   markAgentRunFailed(runId, userId, error) {
     db.prepare(
       `UPDATE agent_runs