neoagent 2.2.0 → 2.2.1-beta.0

package/server/routes/widgets.js

@@ -0,0 +1,101 @@
+const express = require('express');
+const router = express.Router();
+const { requireAuth } = require('../middleware/auth');
+const { sanitizeError } = require('../utils/security');
+const { getAgentIdFromRequest, resolveAgentId } = require('../services/agents/manager');
+
+router.use(requireAuth);
+
+function widgetService(req) {
+  return req.app?.locals?.widgetService;
+}
+
+router.get('/snapshots', (req, res) => {
+  try {
+    const service = widgetService(req);
+    if (!service) {
+      return res.status(500).json({ error: 'Widget service unavailable.' });
+    }
+    const agentId = req.query?.all === 'true'
+      ? null
+      : resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
+    res.json(service.listLatestSnapshots(req.session.userId, { agentId }));
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.get('/', (req, res) => {
+  try {
+    const service = widgetService(req);
+    if (!service) {
+      return res.status(500).json({ error: 'Widget service unavailable.' });
+    }
+    const agentId = req.query?.all === 'true'
+      ? null
+      : resolveAgentId(req.session.userId, getAgentIdFromRequest(req));
+    res.json(service.listWidgets(req.session.userId, { agentId }));
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.post('/', (req, res) => {
+  try {
+    const service = widgetService(req);
+    if (!service) {
+      return res.status(500).json({ error: 'Widget service unavailable.' });
+    }
+    const widget = service.createWidget(req.session.userId, req.body || {});
+    res.status(201).json(widget);
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.put('/:id', (req, res) => {
+  try {
+    const service = widgetService(req);
+    if (!service) {
+      return res.status(500).json({ error: 'Widget service unavailable.' });
+    }
+    const widget = service.updateWidget(req.session.userId, req.params.id, req.body || {});
+    res.json(widget);
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.delete('/:id', (req, res) => {
+  try {
+    const service = widgetService(req);
+    if (!service) {
+      return res.status(500).json({ error: 'Widget service unavailable.' });
+    }
+    res.json(service.deleteWidget(req.session.userId, req.params.id));
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+router.post('/:id/refresh', (req, res) => {
+  try {
+    const service = widgetService(req);
+    const scheduler = req.app?.locals?.scheduler;
+    if (!service || !scheduler) {
+      return res.status(500).json({ error: 'Widget refresh unavailable.' });
+    }
+    const widget = service.getWidget(req.session.userId, req.params.id);
+    if (!widget) {
+      return res.status(404).json({ error: 'Widget not found.' });
+    }
+    if (!widget.scheduledTaskId) {
+      return res.status(400).json({ error: 'Widget is missing its refresh task.' });
+    }
+    res.json(scheduler.runTaskNow(widget.scheduledTaskId, req.session.userId));
+  } catch (err) {
+    res.status(400).json({ error: sanitizeError(err) });
+  }
+});
+
+module.exports = router;

package/server/services/ai/engine.js

@@ -474,6 +474,10 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
     'update_scheduled_task',
     'delete_scheduled_task',
     'schedule_run',
+    'create_ai_widget',
+    'update_ai_widget',
+    'delete_ai_widget',
+    'save_widget_snapshot',
     'mcp_add_server',
     'mcp_remove_server',
     'spawn_subagent',
@@ -498,7 +502,7 @@ function classifyToolExecution(toolName, toolArgs = {}, result, errorMessage = '
                   ? 'command'
                   : name.includes('skill')
                     ? 'skills'
-                    : name.includes('scheduled_task') || name === 'schedule_run'
+                    : name.includes('scheduled_task') || name === 'schedule_run' || name.includes('widget')
                       ? 'scheduler'
                       : name === 'send_message' || name === 'make_call'
                         ? 'messaging'
@@ -1966,6 +1970,7 @@ class AgentEngine {
               source: options.source || null,
               chatId: options.chatId || null,
               taskId: options.taskId || null,
+              widgetId: options.widgetId || null,
               deliveryState: options.deliveryState || null,
               allowMultipleProactiveMessages: options.allowMultipleProactiveMessages === true,
               allowExternalSideEffects: options.allowExternalSideEffects === true,
@@ -2801,7 +2806,7 @@ class AgentEngine {
     if (toolName === 'send_message') return 'messaging';
     if (toolName === 'make_call') return 'messaging';
     if (toolName.startsWith('mcp_') || toolName.includes('mcp')) return 'mcp';
-    if (toolName.includes('scheduled_task') || toolName === 'schedule_run') return 'scheduler';
+    if (toolName.includes('scheduled_task') || toolName === 'schedule_run' || toolName.includes('widget')) return 'scheduler';
     if (toolName.includes('subagent')) return 'subagent';
     if (toolName === 'think') return 'thinking';
     return 'tool';

package/server/services/ai/toolResult.js

@@ -221,9 +221,34 @@ function compactToolResult(toolName, toolArgs = {}, toolResult, options = {}) {
     case 'schedule_run':
     case 'delete_scheduled_task':
     case 'update_scheduled_task':
+    case 'create_ai_widget':
+    case 'update_ai_widget':
+    case 'delete_ai_widget':
+    case 'save_widget_snapshot':
       envelope = buildSimpleStatusEnvelope(toolName, toolResult, softLimit);
       break;
 
+    case 'list_ai_widgets':
+      envelope = trimObject({
+        tool: toolName,
+        status: toolResult?.success === false || toolResult?.error ? 'error' : 'ok',
+        message: clampText(toolResult?.message || toolResult?.error || '', Math.floor(softLimit * 0.3)),
+        count: typeof toolResult?.count === 'number'
+          ? toolResult.count
+          : (Array.isArray(toolResult?.widgets) ? toolResult.widgets.length : undefined),
+        widgets: Array.isArray(toolResult?.widgets)
+          ? toolResult.widgets.slice(0, 6).map((widget) => trimObject({
+            id: widget?.id,
+            name: widget?.name,
+            template: widget?.template,
+            layoutVariant: widget?.layoutVariant,
+            refreshCron: widget?.refreshCron,
+            enabled: widget?.enabled,
+          }))
+          : undefined,
+      });
+      break;
+
     case 'spawn_subagent':
       envelope = trimObject({
         tool: toolName,

package/server/services/ai/tools.js

@@ -936,6 +936,60 @@ function getAvailableTools(app, options = {}) {
                 required: ['task_id']
             }
         },
+        {
+            name: 'create_ai_widget',
+            description: 'Create an AI widget with a fixed template, approved layout variant, refresh cadence, and definition prompt. Cadence must be at least 1 hour.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', description: 'Short widget name.' },
+                    template: { type: 'string', enum: ['stat', 'summary', 'list'], description: 'Widget template family.' },
+                    layout_variant: { type: 'string', description: 'Approved layout variant for the chosen template.' },
+                    refresh_cron: { type: 'string', description: '5-field cron cadence. Never set faster than hourly.' },
+                    prompt: { type: 'string', description: 'Self-contained definition of what the widget should track and how it should summarize it.' },
+                    description: { type: 'string', description: 'Optional short operator-facing description.' },
+                    system_hint: { type: 'string', description: 'Optional extra guidance for future refresh runs.' },
+                    enabled: { type: 'boolean', description: 'Whether the widget should start enabled immediately.' },
+                    run_initial_refresh: { type: 'boolean', description: 'When true, immediately run the first refresh after creation. Defaults to true.' }
+                },
+                required: ['name', 'template', 'layout_variant', 'refresh_cron', 'prompt']
+            }
+        },
+        {
+            name: 'list_ai_widgets',
+            description: 'List AI widgets for the current agent.',
+            parameters: { type: 'object', properties: {} }
+        },
+        {
+            name: 'update_ai_widget',
+            description: 'Update an existing AI widget. Use this when the user explicitly wants to change the widget definition, layout variant, cadence, or enabled state.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    widget_id: { type: 'string', description: 'Widget ID from list_ai_widgets.' },
+                    name: { type: 'string', description: 'Updated widget name.' },
+                    template: { type: 'string', enum: ['stat', 'summary', 'list'], description: 'Updated widget template.' },
+                    layout_variant: { type: 'string', description: 'Approved layout variant for the chosen template.' },
+                    refresh_cron: { type: 'string', description: 'Updated 5-field cron cadence. Never faster than hourly.' },
+                    prompt: { type: 'string', description: 'Updated widget definition prompt.' },
+                    description: { type: 'string', description: 'Optional updated operator-facing description.' },
+                    system_hint: { type: 'string', description: 'Optional updated extra guidance for refresh runs.' },
+                    enabled: { type: 'boolean', description: 'Enable or disable the widget.' }
+                },
+                required: ['widget_id']
+            }
+        },
+        {
+            name: 'delete_ai_widget',
+            description: 'Delete an AI widget by its ID.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    widget_id: { type: 'string', description: 'Widget ID from list_ai_widgets.' }
+                },
+                required: ['widget_id']
+            }
+        },
         {
             name: 'mcp_add_server',
             description: 'Register and optionally start a new MCP (Model Context Protocol) server connection. Use this when the user asks to connect a new MCP server or when you discover a useful one. The server will appear in the MCP Servers page and its tools will be available to you immediately if auto_start is true.',
@@ -1097,6 +1151,23 @@ function getAvailableTools(app, options = {}) {
         tools.push(...integrationTools);
     }
 
+    if (options.triggerSource === 'scheduler' && options.widgetId) {
+        tools.push({
+            name: 'save_widget_snapshot',
+            description: 'Save the refreshed structured snapshot for the widget that is currently being updated. Call this exactly once per widget refresh run.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    snapshot: {
+                        type: 'object',
+                        description: 'Structured widget snapshot payload containing title, optional subtitle/body/metric/trend/rows/chips/iconToken/accentToken/updatedAt/deepLink.'
+                    }
+                },
+                required: ['snapshot']
+            }
+        });
+    }
+
     let visibleTools = tools;
     if (options.userId != null) {
         try {
@@ -1137,6 +1208,7 @@ async function executeTool(toolName, args, context, engine) {
         app,
         triggerSource,
         taskId,
+        widgetId,
         deliveryState = null,
         allowMultipleProactiveMessages = false
     } = context;
@@ -1176,6 +1248,7 @@ async function executeTool(toolName, args, context, engine) {
     const sk = () => app?.locals?.skillRunner || engine.skillRunner;
     const sched = () => app?.locals?.scheduler || engine.scheduler;
     const rec = () => app?.locals?.recordingManager || null;
+    const widgets = () => app?.locals?.widgetService || null;
 
     const integrationManager = integrations();
     if (integrationManager) {
@@ -2224,6 +2297,115 @@ async function executeTool(toolName, args, context, engine) {
             }
         }
 
+        case 'create_ai_widget': {
+            const widgetService = widgets();
+            if (!widgetService) return { error: 'Widget service not available' };
+            try {
+                const widget = widgetService.createWidget(userId, {
+                    name: args.name,
+                    template: args.template,
+                    layoutVariant: args.layout_variant,
+                    refreshCron: args.refresh_cron,
+                    prompt: args.prompt,
+                    description: args.description,
+                    definition: {
+                        prompt: args.prompt,
+                        description: args.description,
+                        systemHint: args.system_hint,
+                    },
+                    enabled: args.enabled !== false,
+                    agentId,
+                });
+                let initialRefresh = null;
+                if (args.run_initial_refresh !== false) {
+                    try {
+                        initialRefresh = await widgetService.refreshWidget(userId, widget.id, {
+                            taskId: widget.scheduledTaskId || null,
+                        });
+                    } catch (refreshErr) {
+                        initialRefresh = { error: refreshErr.message };
+                    }
+                }
+                return {
+                    success: true,
+                    widget,
+                    initialRefresh,
+                    message: `AI widget "${widget.name}" created.`,
+                };
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'list_ai_widgets': {
+            const widgetService = widgets();
+            if (!widgetService) return { error: 'Widget service not available' };
+            const items = widgetService.listWidgets(userId, { agentId });
+            return { widgets: items, count: items.length };
+        }
+
+        case 'update_ai_widget': {
+            const widgetService = widgets();
+            if (!widgetService) return { error: 'Widget service not available' };
+            try {
+                const existing = widgetService.getWidget(userId, args.widget_id);
+                if (!existing || existing.agentId !== agentId) {
+                    return { error: 'Widget not found for this agent.' };
+                }
+                const widget = widgetService.updateWidget(userId, args.widget_id, {
+                    name: args.name,
+                    template: args.template,
+                    layoutVariant: args.layout_variant,
+                    refreshCron: args.refresh_cron,
+                    prompt: args.prompt,
+                    description: args.description,
+                    definition: args.prompt !== undefined || args.description !== undefined || args.system_hint !== undefined
+                        ? {
+                            ...(existing.definition || {}),
+                            ...(args.prompt !== undefined ? { prompt: args.prompt } : {}),
+                            ...(args.description !== undefined ? { description: args.description } : {}),
+                            ...(args.system_hint !== undefined ? { systemHint: args.system_hint } : {}),
+                        }
+                        : undefined,
+                    enabled: args.enabled,
+                    agentId,
+                });
+                return { success: true, widget };
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'delete_ai_widget': {
+            const widgetService = widgets();
+            if (!widgetService) return { error: 'Widget service not available' };
+            try {
+                const existing = widgetService.getWidget(userId, args.widget_id);
+                if (!existing || existing.agentId !== agentId) {
+                    return { error: 'Widget not found for this agent.' };
+                }
+                const deleted = widgetService.deleteWidget(userId, args.widget_id);
+                return { success: true, ...deleted };
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
+        case 'save_widget_snapshot': {
+            const widgetService = widgets();
+            if (!widgetService) return { error: 'Widget service not available' };
+            if (!widgetId) return { error: 'save_widget_snapshot is only available during widget refresh runs.' };
+            try {
+                const snapshot = widgetService.saveSnapshot(userId, widgetId, args.snapshot, {
+                    sourceRunId: runId,
+                    status: 'ready',
+                });
+                return { success: true, snapshot };
+            } catch (err) {
+                return { error: err.message };
+            }
+        }
+
         case 'mcp_add_server': {
             const mcpClient = mcp();
             if (!mcpClient) return { error: 'MCP manager not available' };

package/server/services/manager.js

@@ -11,6 +11,7 @@ const { SkillRunner } = require('./ai/toolRunner');
 const { CommandRouter } = require('./commands/router');
 const { MessagingManager } = require('./messaging/manager');
 const { Scheduler } = require('./scheduler/cron');
+const { WidgetService } = require('./widgets/service');
 const { setupWebSocket } = require('./websocket');
 const { registerMessagingAutomation } = require('./messaging/automation');
 const { RecordingManager } = require('./recordings/manager');
@@ -417,6 +418,16 @@ function createRecordingManager(app, io) {
   return recordingManager;
 }
 
+function createWidgetService(app) {
+  const widgetService = registerLocal(
+    app,
+    'widgetService',
+    new WidgetService({ app }),
+  );
+  logServiceReady('Widget service ready');
+  return widgetService;
+}
+
 function restoreMessagingConnections(messagingManager) {
   void runBackgroundTask('[Messaging] Restore error:', () =>
     messagingManager.restoreConnections(),
@@ -501,6 +512,7 @@ async function startServices(app, io) {
 
     const messagingManager = createMessagingManager(app, io, agentEngine);
     const recordingManager = createRecordingManager(app, io);
+    createWidgetService(app);
 
     restoreMessagingConnections(messagingManager);
     restoreMcpClients(mcpClient);
@@ -608,6 +620,25 @@ async function stopServices(app) {
     );
   }
 
+  if (app.locals.widgetService) {
+    const widgetService = app.locals.widgetService;
+    const cleanupMethod = ['shutdown', 'close', 'stop', 'dispose'].find(
+      (method) => typeof widgetService[method] === 'function',
+    );
+    if (cleanupMethod) {
+      tasks.push(
+        Promise.resolve()
+          .then(() => widgetService[cleanupMethod]())
+          .then(() => {
+            logServiceReady(`Widget service ${cleanupMethod} completed`);
+          })
+          .catch((err) => {
+            console.error('[Widget] Shutdown error:', getErrorMessage(err));
+          }),
+      );
+    }
+  }
+
   if (app.locals.browserExtensionRegistry) {
     try {
       app.locals.browserExtensionRegistry.closeAll();

package/server/services/scheduler/cron.js

@@ -2,6 +2,7 @@ const cron = require('node-cron');
 const crypto = require('crypto');
 const db = require('../../db/database');
 const { isMainAgent, resolveAgentId } = require('../agents/manager');
+const { findNextRun } = require('./cron_utils');
 
 const MAX_SCHEDULER_AUTONOMOUS_RETRIES = 1;
 const MAX_RECURRING_TASK_START_DELAY_MS = 90 * 1000;
@@ -60,11 +61,27 @@ class Scheduler {
     console.log('[Scheduler] One-time poller active (every 1 min)');
   }
 
-  createTask(userId, { name, cronExpression, prompt, enabled = true, callTo = null, callGreeting = null, model = null, runAt = null, oneTime = false, agentId = null }) {
+  createTask(userId, {
+    name,
+    cronExpression,
+    prompt,
+    enabled = true,
+    callTo = null,
+    callGreeting = null,
+    model = null,
+    runAt = null,
+    oneTime = false,
+    agentId = null,
+    taskType = 'agent_prompt',
+    taskConfig = null,
+  }) {
     const scopedAgentId = resolveAgentId(userId, agentId);
     const notifyTarget = this._getDefaultNotifyTarget(userId, scopedAgentId);
 
     if (oneTime) {
+      if (taskType !== 'agent_prompt') {
+        throw new Error('One-time runs support only agent_prompt tasks.');
+      }
       if (!runAt) throw new Error('runAt is required for one-time tasks');
       const runAtDate = new Date(runAt);
       if (isNaN(runAtDate.getTime())) throw new Error(`Invalid runAt value: ${runAt}`);
@@ -88,17 +105,25 @@ class Scheduler {
       throw new Error(`Invalid cron expression: ${cronExpression}`);
     }
 
-    const config = { prompt };
-    if (callTo) { config.callTo = callTo; config.callGreeting = callGreeting || ''; }
-    if (typeof model === 'string' && model.trim()) config.model = model.trim();
-    if (notifyTarget.platform && notifyTarget.to) {
-      config.notifyPlatform = notifyTarget.platform;
-      config.notifyTo = notifyTarget.to;
+    let config;
+    if (taskType === 'widget_refresh') {
+      config = this._normalizeTaskConfig(taskConfig || {});
+      if (!config.widgetId) {
+        throw new Error('widget_refresh tasks require widgetId.');
+      }
+    } else {
+      config = { prompt };
+      if (callTo) { config.callTo = callTo; config.callGreeting = callGreeting || ''; }
+      if (typeof model === 'string' && model.trim()) config.model = model.trim();
+      if (notifyTarget.platform && notifyTarget.to) {
+        config.notifyPlatform = notifyTarget.platform;
+        config.notifyTo = notifyTarget.to;
+      }
     }
 
     const result = db.prepare(
       'INSERT INTO scheduled_tasks (user_id, agent_id, name, cron_expression, task_type, task_config, enabled) VALUES (?, ?, ?, ?, ?, ?, ?)'
-    ).run(userId, scopedAgentId, name, cronExpression, 'agent_prompt', JSON.stringify(config), enabled ? 1 : 0);
+    ).run(userId, scopedAgentId, name, cronExpression, taskType, JSON.stringify(config), enabled ? 1 : 0);
 
     const taskId = result.lastInsertRowid;
 
@@ -106,12 +131,15 @@ class Scheduler {
       this._scheduleTask(taskId, userId, cronExpression, config, scopedAgentId);
     }
 
-    return { id: taskId, name, cronExpression, enabled, callTo: config.callTo || null, model: config.model || null, agentId: scopedAgentId };
+    return { id: taskId, name, cronExpression, enabled, callTo: config.callTo || null, model: config.model || null, agentId: scopedAgentId, taskType, widgetId: config.widgetId || null };
   }
 
-  updateTask(taskId, userId, updates) {
+  updateTask(taskId, userId, updates, options = {}) {
     const task = db.prepare('SELECT * FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(taskId, userId);
     if (!task) throw new Error('Task not found');
+    if (task.task_type === 'widget_refresh' && options.allowManaged !== true) {
+      throw new Error('Widget refresh tasks must be updated via widgets.');
+    }
 
     const name = updates.name || task.name;
     const cronExpr = updates.cronExpression || task.cron_expression;
@@ -122,25 +150,34 @@ class Scheduler {
 
     // Merge config — start from existing, apply any changes
     let config = this._normalizeTaskConfig(task.task_config);
-    if (updates.prompt !== undefined) config.prompt = updates.prompt;
-    if (updates.callTo !== undefined) config.callTo = updates.callTo || null;
-    if (updates.callGreeting !== undefined) config.callGreeting = updates.callGreeting || null;
-    if (updates.model !== undefined) {
-      if (typeof updates.model === 'string' && updates.model.trim()) {
-        config.model = updates.model.trim();
-      } else {
-        delete config.model;
+    if (task.task_type === 'widget_refresh') {
+      if (updates.taskConfig !== undefined) {
+        config = this._normalizeTaskConfig(updates.taskConfig);
       }
-    }
-    if (!config.notifyPlatform || !config.notifyTo) {
-      const notifyTarget = this._getDefaultNotifyTarget(userId, agentId);
-      if (notifyTarget.platform && notifyTarget.to) {
-        config.notifyPlatform = notifyTarget.platform;
-        config.notifyTo = notifyTarget.to;
+      if (!config.widgetId) {
+        throw new Error('widget_refresh tasks require widgetId.');
+      }
+    } else {
+      if (updates.prompt !== undefined) config.prompt = updates.prompt;
+      if (updates.callTo !== undefined) config.callTo = updates.callTo || null;
+      if (updates.callGreeting !== undefined) config.callGreeting = updates.callGreeting || null;
+      if (updates.model !== undefined) {
+        if (typeof updates.model === 'string' && updates.model.trim()) {
+          config.model = updates.model.trim();
+        } else {
+          delete config.model;
+        }
+      }
+      if (!config.notifyPlatform || !config.notifyTo) {
+        const notifyTarget = this._getDefaultNotifyTarget(userId, agentId);
+        if (notifyTarget.platform && notifyTarget.to) {
+          config.notifyPlatform = notifyTarget.platform;
+          config.notifyTo = notifyTarget.to;
+        }
       }
+      // Clean up nulls
+      if (!config.callTo) { delete config.callTo; delete config.callGreeting; }
     }
-    // Clean up nulls
-    if (!config.callTo) { delete config.callTo; delete config.callGreeting; }
 
     if (updates.cronExpression && !cron.validate(updates.cronExpression)) {
       throw new Error(`Invalid cron expression: ${updates.cronExpression}`);
@@ -160,12 +197,15 @@ class Scheduler {
       this._scheduleTask(taskId, userId, cronExpr, config, agentId);
     }
 
-    return { id: taskId, name, cronExpression: cronExpr, enabled, callTo: config.callTo || null, model: config.model || null, agentId };
+    return { id: taskId, name, cronExpression: cronExpr, enabled, callTo: config.callTo || null, model: config.model || null, agentId, taskType: task.task_type || 'agent_prompt', widgetId: config.widgetId || null };
   }
 
-  deleteTask(taskId, userId) {
+  deleteTask(taskId, userId, options = {}) {
     const task = db.prepare('SELECT * FROM scheduled_tasks WHERE id = ? AND user_id = ?').get(taskId, userId);
     if (!task) throw new Error('Task not found');
+    if (task.task_type === 'widget_refresh' && options.allowManaged !== true) {
+      throw new Error('Widget refresh tasks must be deleted via widgets.');
+    }
 
     const existing = this.jobs.get(taskId);
     if (existing) {
@@ -203,6 +243,8 @@ class Scheduler {
         enabled: !!t.enabled,
         lastRun: t.last_run,
         nextRun: t.one_time ? t.run_at : this._getNextRun(t.cron_expression),
+        taskType: t.task_type || 'agent_prompt',
+        widgetId: config.widgetId || null,
         config,
         prompt: config.prompt || '',
         model: config.model || null,
@@ -308,6 +350,20 @@ class Scheduler {
     this.io.to(`user:${userId}`).emit('scheduler:task_running', { taskId, timestamp: new Date().toISOString() });
 
     try {
+      if (task.task_type === 'widget_refresh') {
+        const widgetService = this.app?.locals?.widgetService;
+        if (!widgetService || !config.widgetId) {
+          throw new Error('Widget refresh task is missing widget context.');
+        }
+        const result = await widgetService.refreshWidget(userId, config.widgetId, {
+          taskId,
+          manual: executionMeta.manual === true,
+          scheduledAt: executionMeta.scheduledAt || null,
+        });
+        this.io.to(`user:${userId}`).emit('scheduler:task_complete', { taskId, result });
+        return result;
+      }
+
       if (this.agentEngine && config.prompt !== undefined) {
         let notifyHint = '';
 
@@ -458,10 +514,7 @@ class Scheduler {
 
   _getNextRun(cronExpression) {
     try {
-      const interval = cron.schedule(cronExpression, () => { });
-      interval.stop();
-      // node-cron doesn't expose nextRun; we just return null
-      return null;
+      return findNextRun(cronExpression)?.toISOString() || null;
     } catch {
       return null;
     }