neoagent 3.2.0 → 3.2.1-beta.1

package/docs/agent-run-lifecycle.md

@@ -45,6 +45,12 @@ runs:
 The engine records steps, run events, model usage, timing, and artifacts.
 Repetition guards and loop limits prevent unbounded retries.
 
+Run control is checked at model and tool boundaries. Abort and interruption
+are terminal; pause cancels the active model or command, records a checkpoint,
+and parks the in-process run until the authenticated resume action releases it.
+If a state-changing tool is interrupted after dispatch, its outcome is recorded
+as unknown and must be verified before the model can attempt it again.
+
 ## 4. Complete and deliver
 
 The final response is sanitized and stored. Messaging-triggered runs send an
@@ -55,6 +61,10 @@ The engine emits `run:complete`, persists prompt and usage metrics, refreshes
 conversation summaries and working state, and cancels unfinished subagents.
 Failures and user stops produce separate terminal run states.
 
+Terminal transitions are first-writer-wins. A late model, tool, verifier, or
+delivery callback cannot overwrite an earlier stop or interruption, and active
+run, step, and delegation rows are settled together.
+
 ## 5. Post-run processing
 
 Completed conversations can run structured memory consolidation. The engine

package/flutter_app/lib/main_operations.dart

@@ -5087,7 +5087,284 @@ _TaskTriggerOption _taskTriggerOptionForType(String type) {
   );
 }
 
+class _TaskSchedulePreset {
+  const _TaskSchedulePreset({
+    required this.id,
+    required this.label,
+    required this.description,
+    required this.icon,
+  });
+
+  final String id;
+  final String label;
+  final String description;
+  final IconData icon;
+}
+
+const List<_TaskSchedulePreset> _taskSchedulePresets = <_TaskSchedulePreset>[
+  _TaskSchedulePreset(
+    id: 'every_15_minutes',
+    label: 'Every 15 minutes',
+    description: 'Runs four times per hour.',
+    icon: Icons.timer_outlined,
+  ),
+  _TaskSchedulePreset(
+    id: 'every_30_minutes',
+    label: 'Every 30 minutes',
+    description: 'Runs twice per hour.',
+    icon: Icons.timelapse_rounded,
+  ),
+  _TaskSchedulePreset(
+    id: 'hourly',
+    label: 'Hourly',
+    description: 'Runs once per hour.',
+    icon: Icons.schedule_rounded,
+  ),
+  _TaskSchedulePreset(
+    id: 'daily',
+    label: 'Daily',
+    description: 'Runs every day at the selected time.',
+    icon: Icons.today_rounded,
+  ),
+  _TaskSchedulePreset(
+    id: 'weekdays',
+    label: 'Weekdays',
+    description: 'Runs Monday through Friday.',
+    icon: Icons.work_outline_rounded,
+  ),
+  _TaskSchedulePreset(
+    id: 'weekly',
+    label: 'Weekly',
+    description: 'Runs on selected weekdays.',
+    icon: Icons.view_week_rounded,
+  ),
+  _TaskSchedulePreset(
+    id: 'monthly',
+    label: 'Monthly',
+    description: 'Runs once per month on the selected day.',
+    icon: Icons.calendar_month_rounded,
+  ),
+  _TaskSchedulePreset(
+    id: 'custom',
+    label: 'Custom Cron',
+    description: 'Advanced manual schedule for special cases.',
+    icon: Icons.tune_rounded,
+  ),
+];
+
+const List<String> _taskWeekdayLabels = <String>[
+  'Mon',
+  'Tue',
+  'Wed',
+  'Thu',
+  'Fri',
+  'Sat',
+  'Sun',
+];
+
+_TaskSchedulePreset _taskSchedulePresetForId(String id) {
+  return _taskSchedulePresets.firstWhere(
+    (entry) => entry.id == id,
+    orElse: () => _taskSchedulePresets[1],
+  );
+}
+
+class _TaskScheduleDraft {
+  _TaskScheduleDraft({
+    required this.mode,
+    required this.presetId,
+    required this.time,
+    required this.weekdays,
+    required this.monthDay,
+    required this.customCronExpression,
+  });
+
+  factory _TaskScheduleDraft.fromTask(TaskItem? task) {
+    final runAt = task?.triggerConfig['runAt']?.toString().trim() ?? '';
+    if (runAt.isNotEmpty) {
+      return _TaskScheduleDraft(
+        mode: 'one_time',
+        presetId: 'daily',
+        time: const TimeOfDay(hour: 9, minute: 0),
+        weekdays: <int>{1},
+        monthDay: 1,
+        customCronExpression: '',
+      );
+    }
+    final cron =
+        task?.triggerConfig['cronExpression']?.toString().trim() ??
+        '*/30 * * * *';
+    final parsed = _parseCronExpression(cron);
+    if (parsed != null) return parsed;
+    return _TaskScheduleDraft(
+      mode: 'recurring',
+      presetId: 'custom',
+      time: const TimeOfDay(hour: 9, minute: 0),
+      weekdays: <int>{1},
+      monthDay: 1,
+      customCronExpression: cron,
+    );
+  }
+
+  String mode;
+  String presetId;
+  TimeOfDay time;
+  Set<int> weekdays;
+  int monthDay;
+  String customCronExpression;
+
+  bool get usesTime =>
+      presetId == 'daily' ||
+      presetId == 'weekdays' ||
+      presetId == 'weekly' ||
+      presetId == 'monthly';
+
+  String get cronExpression {
+    if (presetId == 'custom') return customCronExpression;
+    final minute = time.minute.toString();
+    final hour = time.hour.toString();
+    return switch (presetId) {
+      'every_15_minutes' => '*/15 * * * *',
+      'every_30_minutes' => '*/30 * * * *',
+      'hourly' => '0 * * * *',
+      'daily' => '$minute $hour * * *',
+      'weekdays' => '$minute $hour * * 1-5',
+      'weekly' => '$minute $hour * * ${_cronWeekdays(weekdays)}',
+      'monthly' => '$minute $hour $monthDay * *',
+      'custom' => customCronExpression,
+      _ => '*/30 * * * *',
+    };
+  }
+
+  String get summary {
+    if (mode == 'one_time') return 'One-time run';
+    if (presetId == 'custom') return 'Custom Cron';
+    final preset = _taskSchedulePresetForId(presetId);
+    if (!usesTime) return preset.label;
+    final timeLabel = _formatTaskScheduleTime(time);
+    if (presetId == 'weekly') {
+      return '${preset.label} ${_formatTaskWeekdays(weekdays)} at $timeLabel';
+    }
+    if (presetId == 'monthly') {
+      return '${preset.label} on day $monthDay at $timeLabel';
+    }
+    return '${preset.label} at $timeLabel';
+  }
+}
+
+_TaskScheduleDraft? _parseCronExpression(String cron) {
+  final fields = cron.trim().split(RegExp(r'\s+'));
+  if (fields.length != 5) return null;
+  final minute = fields[0];
+  final hour = fields[1];
+  final dayOfMonth = fields[2];
+  final month = fields[3];
+  final dayOfWeek = fields[4];
+  if (cron == '*/15 * * * *') {
+    return _recurringScheduleDraft('every_15_minutes');
+  }
+  if (cron == '*/30 * * * *') {
+    return _recurringScheduleDraft('every_30_minutes');
+  }
+  if (cron == '0 * * * *') return _recurringScheduleDraft('hourly');
+  final parsedMinute = int.tryParse(minute);
+  final parsedHour = int.tryParse(hour);
+  if (parsedMinute == null ||
+      parsedMinute < 0 ||
+      parsedMinute > 59 ||
+      parsedHour == null ||
+      parsedHour < 0 ||
+      parsedHour > 23 ||
+      month != '*') {
+    return null;
+  }
+  final time = TimeOfDay(hour: parsedHour, minute: parsedMinute);
+  if (dayOfMonth == '*' && dayOfWeek == '*') {
+    return _recurringScheduleDraft('daily', time: time);
+  }
+  if (dayOfMonth == '*' && dayOfWeek == '1-5') {
+    return _recurringScheduleDraft('weekdays', time: time);
+  }
+  if (dayOfMonth == '*') {
+    final weekdays = _parseCronWeekdays(dayOfWeek);
+    if (weekdays == null || weekdays.isEmpty) return null;
+    return _recurringScheduleDraft('weekly', time: time, weekdays: weekdays);
+  }
+  if (dayOfWeek == '*') {
+    final parsedDay = int.tryParse(dayOfMonth);
+    if (parsedDay == null || parsedDay < 1 || parsedDay > 31) return null;
+    return _recurringScheduleDraft('monthly', time: time, monthDay: parsedDay);
+  }
+  return null;
+}
+
+bool _looksLikeCronExpression(String cron) {
+  return cron.trim().split(RegExp(r'\s+')).length == 5;
+}
+
+_TaskScheduleDraft _recurringScheduleDraft(
+  String presetId, {
+  TimeOfDay time = const TimeOfDay(hour: 9, minute: 0),
+  Set<int> weekdays = const <int>{1},
+  int monthDay = 1,
+}) {
+  return _TaskScheduleDraft(
+    mode: 'recurring',
+    presetId: presetId,
+    time: time,
+    weekdays: Set<int>.from(weekdays),
+    monthDay: monthDay,
+    customCronExpression: '',
+  );
+}
+
+Set<int>? _parseCronWeekdays(String value) {
+  final result = <int>{};
+  for (final part in value.split(',')) {
+    final trimmed = part.trim();
+    if (trimmed.isEmpty) return null;
+    final rangeParts = trimmed.split('-');
+    if (rangeParts.length == 2) {
+      final start = _parseCronWeekday(rangeParts[0]);
+      final end = _parseCronWeekday(rangeParts[1]);
+      if (start == null || end == null || start > end) return null;
+      for (var day = start; day <= end; day += 1) {
+        result.add(day);
+      }
+    } else if (rangeParts.length == 1) {
+      final day = _parseCronWeekday(trimmed);
+      if (day == null) return null;
+      result.add(day);
+    } else {
+      return null;
+    }
+  }
+  return result;
+}
+
+int? _parseCronWeekday(String value) {
+  final parsed = int.tryParse(value.trim());
+  if (parsed == null || parsed < 0 || parsed > 7) return null;
+  return parsed == 0 ? 7 : parsed;
+}
 
+String _cronWeekdays(Set<int> weekdays) {
+  final sorted = weekdays.where((day) => day >= 1 && day <= 7).toList()..sort();
+  if (sorted.isEmpty) return '1';
+  return sorted.join(',');
+}
+
+String _formatTaskScheduleTime(TimeOfDay time) {
+  final hour = time.hour.toString().padLeft(2, '0');
+  final minute = time.minute.toString().padLeft(2, '0');
+  return '$hour:$minute';
+}
+
+String _formatTaskWeekdays(Set<int> weekdays) {
+  final sorted = weekdays.where((day) => day >= 1 && day <= 7).toList()..sort();
+  if (sorted.isEmpty) return 'Monday';
+  return sorted.map((day) => _taskWeekdayLabels[day - 1]).join(', ');
+}
 Future<String?> _pickTaskTriggerType(
   BuildContext context,
   String selectedType,
@@ -6255,8 +6532,9 @@ class _TasksPanelState extends State<TasksPanel> {
   }) async {
     final nameController = TextEditingController(text: task?.name ?? '');
     final triggerType = ValueNotifier<String>(task?.triggerType ?? 'schedule');
-    final cronController = TextEditingController(
-      text: task?.triggerConfig['cronExpression']?.toString() ?? '*/30 * * * *',
+    final scheduleDraft = _TaskScheduleDraft.fromTask(task);
+    final customCronController = TextEditingController(
+      text: scheduleDraft.customCronExpression,
     );
     final runAtController = TextEditingController(
       text: task?.triggerConfig['runAt']?.toString() ?? '',
@@ -6463,21 +6741,246 @@ class _TasksPanelState extends State<TasksPanel> {
                           if (selectedTriggerType == 'schedule') {
                             return Column(
                               children: <Widget>[
-                                TextField(
-                                  controller: cronController,
-                                  decoration: const InputDecoration(
-                                    labelText: 'Cron Expression',
-                                    helperText:
-                                        'Use cron for recurring tasks. Leave Run At empty for recurring schedules.',
-                                  ),
+                                SegmentedButton<String>(
+                                  segments: const <ButtonSegment<String>>[
+                                    ButtonSegment<String>(
+                                      value: 'recurring',
+                                      icon: Icon(Icons.repeat_rounded),
+                                      label: Text('Recurring'),
+                                    ),
+                                    ButtonSegment<String>(
+                                      value: 'one_time',
+                                      icon: Icon(Icons.event_rounded),
+                                      label: Text('Once'),
+                                    ),
+                                  ],
+                                  selected: <String>{scheduleDraft.mode},
+                                  onSelectionChanged: (selection) {
+                                    setLocalState(() {
+                                      scheduleDraft.mode = selection.first;
+                                      if (scheduleDraft.mode == 'recurring') {
+                                        runAtController.clear();
+                                      }
+                                    });
+                                  },
                                 ),
                                 const SizedBox(height: 12),
-                                TextField(
-                                  controller: runAtController,
-                                  decoration: const InputDecoration(
-                                    labelText: 'Run At (optional ISO datetime)',
+                                if (scheduleDraft.mode == 'one_time')
+                                  TextField(
+                                    controller: runAtController,
+                                    decoration: const InputDecoration(
+                                      labelText: 'Run At',
+                                      helperText:
+                                          'Use a date and time, for example 2026-07-03T09:00:00.',
+                                    ),
+                                  )
+                                else ...<Widget>[
+                                  DropdownButtonFormField<String>(
+                                    initialValue: scheduleDraft.presetId,
+                                    isExpanded: true,
+                                    decoration: const InputDecoration(
+                                      labelText: 'Repeat',
+                                    ),
+                                    items: <DropdownMenuItem<String>>[
+                                      ..._taskSchedulePresets.map(
+                                        (preset) => DropdownMenuItem<String>(
+                                          value: preset.id,
+                                          child: Text(preset.label),
+                                        ),
+                                      ),
+                                    ],
+                                    onChanged: (value) {
+                                      if (value == null) return;
+                                      setLocalState(() {
+                                        final currentCron =
+                                            scheduleDraft.cronExpression;
+                                        scheduleDraft.presetId = value;
+                                        if (value == 'custom' &&
+                                            customCronController.text
+                                                .trim()
+                                                .isEmpty) {
+                                          customCronController.text =
+                                              currentCron;
+                                          scheduleDraft.customCronExpression =
+                                              currentCron;
+                                        }
+                                      });
+                                    },
                                   ),
-                                ),
+                                  const SizedBox(height: 12),
+                                  if (scheduleDraft.presetId ==
+                                      'custom') ...<Widget>[
+                                    TextField(
+                                      controller: customCronController,
+                                      onChanged: (value) =>
+                                          scheduleDraft.customCronExpression =
+                                              value,
+                                      decoration: const InputDecoration(
+                                        labelText: 'Cron expression',
+                                        helperText:
+                                            'Advanced: minute hour day month weekday.',
+                                      ),
+                                    ),
+                                    const SizedBox(height: 12),
+                                  ],
+                                  if (scheduleDraft.usesTime) ...<Widget>[
+                                    InkWell(
+                                      borderRadius: BorderRadius.circular(14),
+                                      onTap: () async {
+                                        final picked = await showTimePicker(
+                                          context: context,
+                                          initialTime: scheduleDraft.time,
+                                          builder: (context, child) {
+                                            return MediaQuery(
+                                              data: MediaQuery.of(context)
+                                                  .copyWith(
+                                                    alwaysUse24HourFormat: true,
+                                                  ),
+                                              child: child!,
+                                            );
+                                          },
+                                        );
+                                        if (picked == null) return;
+                                        setLocalState(() {
+                                          scheduleDraft.time = picked;
+                                        });
+                                      },
+                                      child: InputDecorator(
+                                        decoration: const InputDecoration(
+                                          labelText: 'Time',
+                                        ),
+                                        child: Row(
+                                          children: <Widget>[
+                                            const Icon(
+                                              Icons.access_time_rounded,
+                                            ),
+                                            const SizedBox(width: 12),
+                                            Expanded(
+                                              child: Text(
+                                                _formatTaskScheduleTime(
+                                                  scheduleDraft.time,
+                                                ),
+                                                style: const TextStyle(
+                                                  fontWeight: FontWeight.w700,
+                                                ),
+                                              ),
+                                            ),
+                                            Icon(
+                                              Icons.unfold_more_rounded,
+                                              color: _textSecondary,
+                                            ),
+                                          ],
+                                        ),
+                                      ),
+                                    ),
+                                    const SizedBox(height: 12),
+                                  ],
+                                  if (scheduleDraft.presetId ==
+                                      'weekly') ...<Widget>[
+                                    Align(
+                                      alignment: Alignment.centerLeft,
+                                      child: Wrap(
+                                        spacing: 8,
+                                        runSpacing: 8,
+                                        children: List<Widget>.generate(7, (
+                                          index,
+                                        ) {
+                                          final day = index + 1;
+                                          return ChoiceChip(
+                                            label: Text(
+                                              _taskWeekdayLabels[index],
+                                            ),
+                                            selected: scheduleDraft.weekdays
+                                                .contains(day),
+                                            onSelected: (selected) {
+                                              setLocalState(() {
+                                                if (selected) {
+                                                  scheduleDraft.weekdays.add(
+                                                    day,
+                                                  );
+                                                } else if (scheduleDraft
+                                                        .weekdays
+                                                        .length >
+                                                    1) {
+                                                  scheduleDraft.weekdays.remove(
+                                                    day,
+                                                  );
+                                                }
+                                              });
+                                            },
+                                          );
+                                        }),
+                                      ),
+                                    ),
+                                    const SizedBox(height: 12),
+                                  ],
+                                  if (scheduleDraft.presetId ==
+                                      'monthly') ...<Widget>[
+                                    DropdownButtonFormField<int>(
+                                      initialValue: scheduleDraft.monthDay,
+                                      decoration: const InputDecoration(
+                                        labelText: 'Day of month',
+                                      ),
+                                      items:
+                                          List<DropdownMenuItem<int>>.generate(
+                                            31,
+                                            (index) => DropdownMenuItem<int>(
+                                              value: index + 1,
+                                              child: Text('Day ${index + 1}'),
+                                            ),
+                                          ),
+                                      onChanged: (value) {
+                                        if (value == null) return;
+                                        setLocalState(() {
+                                          scheduleDraft.monthDay = value;
+                                        });
+                                      },
+                                    ),
+                                    const SizedBox(height: 12),
+                                  ],
+                                  InputDecorator(
+                                    decoration: const InputDecoration(
+                                      labelText: 'Schedule',
+                                    ),
+                                    child: Builder(
+                                      builder: (context) {
+                                        final preset = _taskSchedulePresetForId(
+                                          scheduleDraft.presetId,
+                                        );
+                                        return Row(
+                                          children: <Widget>[
+                                            Icon(preset.icon, color: _accent),
+                                            const SizedBox(width: 12),
+                                            Expanded(
+                                              child: Column(
+                                                crossAxisAlignment:
+                                                    CrossAxisAlignment.start,
+                                                mainAxisSize: MainAxisSize.min,
+                                                children: <Widget>[
+                                                  Text(
+                                                    scheduleDraft.summary,
+                                                    style: const TextStyle(
+                                                      fontWeight:
+                                                          FontWeight.w700,
+                                                    ),
+                                                  ),
+                                                  const SizedBox(height: 3),
+                                                  Text(
+                                                    preset.description,
+                                                    style: TextStyle(
+                                                      color: _textSecondary,
+                                                      fontSize: 12,
+                                                    ),
+                                                  ),
+                                                ],
+                                              ),
+                                            ),
+                                          ],
+                                        );
+                                      },
+                                    ),
+                                  ),
+                                ],
                               ],
                             );
                           }
@@ -6835,13 +7338,44 @@ class _TasksPanelState extends State<TasksPanel> {
                       // Manual trigger uses no trigger-specific config.
                     } else if (selectedTriggerType == 'schedule') {
                       final runAt = runAtController.text.trim();
-                      triggerConfig['mode'] = runAt.isEmpty
-                          ? 'recurring'
-                          : 'one_time';
-                      if (runAt.isEmpty) {
-                        triggerConfig['cronExpression'] = cronController.text
+                      triggerConfig['mode'] = scheduleDraft.mode;
+                      if (scheduleDraft.mode == 'recurring') {
+                        scheduleDraft.customCronExpression =
+                            customCronController.text.trim();
+                        final cronExpression = scheduleDraft.cronExpression
                             .trim();
+                        if (cronExpression.isEmpty) {
+                          ScaffoldMessenger.of(context).showSnackBar(
+                            const SnackBar(
+                              content: Text('Please choose a schedule.'),
+                              backgroundColor: Colors.red,
+                            ),
+                          );
+                          return;
+                        }
+                        if (scheduleDraft.presetId == 'custom' &&
+                            !_looksLikeCronExpression(cronExpression)) {
+                          ScaffoldMessenger.of(context).showSnackBar(
+                            const SnackBar(
+                              content: Text('Custom Cron must have 5 fields.'),
+                              backgroundColor: Colors.red,
+                            ),
+                          );
+                          return;
+                        }
+                        triggerConfig['cronExpression'] = cronExpression;
                       } else {
+                        if (runAt.isEmpty) {
+                          ScaffoldMessenger.of(context).showSnackBar(
+                            const SnackBar(
+                              content: Text(
+                                'Please enter when the task should run.',
+                              ),
+                              backgroundColor: Colors.red,
+                            ),
+                          );
+                          return;
+                        }
                         triggerConfig['runAt'] = runAt;
                       }
                     } else {

package/lib/schema_migrations.js

@@ -633,6 +633,34 @@ function migrateBilling(db) {
   `);
 }
 
+function migrateAgentRunLifecycle(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_run_controls (
+      run_id       TEXT PRIMARY KEY,
+      user_id      INTEGER NOT NULL,
+      action       TEXT NOT NULL CHECK(action IN ('pause', 'stop', 'interrupt')),
+      reason       TEXT DEFAULT '',
+      requested_at TEXT DEFAULT (datetime('now')),
+      consumed_at  TEXT,
+      FOREIGN KEY (run_id) REFERENCES agent_runs(id) ON DELETE CASCADE,
+      FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS agent_run_checkpoints (
+      run_id          TEXT PRIMARY KEY,
+      version         INTEGER NOT NULL DEFAULT 1,
+      phase           TEXT NOT NULL,
+      state_json      TEXT NOT NULL DEFAULT '{}',
+      created_at      TEXT DEFAULT (datetime('now')),
+      updated_at      TEXT DEFAULT (datetime('now')),
+      FOREIGN KEY (run_id) REFERENCES agent_runs(id) ON DELETE CASCADE
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_run_controls_pending
+      ON agent_run_controls(user_id, consumed_at, requested_at);
+  `);
+}
+
 function runSchemaMigrations(db) {
   removeRetiredCaptureData(db);
   migrateMemoryEmbeddingIndex(db);
@@ -647,6 +675,7 @@ function runSchemaMigrations(db) {
   migrateApprovalPersistence(db);
   migrateToolPoliciesAllowAlways(db);
   migrateBilling(db);
+  migrateAgentRunLifecycle(db);
 }
 
 module.exports = {
@@ -664,5 +693,6 @@ module.exports = {
   migrateApprovalPersistence,
   migrateToolPoliciesAllowAlways,
   migrateBilling,
+  migrateAgentRunLifecycle,
   runSchemaMigrations,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "3.2.0",
+  "version": "3.2.1-beta.1",
   "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",