Integrate task scheduler into agent reminder system

[Copilot]

The task scheduler was implemented as a standalone example. It's now integrated into the agent system, replacing the in-memory reminder implementation with persistent storage while maintaining API compatibility.

Changes

Agent Integration

• Scheduler lifecycle managed by agent (New(), Run(), Stop())
• Default storage: data/scheduled_tasks.json, configurable via WithSchedulerStorePath()
• Poll interval reuses agent's periodicRuns setting

Reminder Action Updates

• set_reminder, list_reminders, remove_reminder now use scheduler when available
• Backward compatible: falls back to in-memory storage if scheduler unavailable
• Added support for interval and once schedules (previously cron-only)

Executor Implementation

• agentSchedulerExecutor implements scheduler.AgentExecutor
• Scheduled tasks execute through agent's job queue
• Observable integration for UI updates

Interface Bridge

• Added TaskScheduler interface to AgentSharedState
• schedulerWrapper adapts scheduler to interface
• Actions access via sharedState.Scheduler

Usage

Agent-based (typical):

// Scheduler auto-initialized and managed
agent, _ := agent.New(
    agent.WithSchedulerStorePath("custom/tasks.json"),
)
agent.Run()  // Scheduler starts automatically

Action-based (user-facing):

User: "Remind me to check emails every 5 minutes"
Agent: Uses set_reminder action → creates persistent scheduler task

Removed

• example/scheduler/ standalone implementation

Original prompt

Add Task Scheduler with Cron/Interval/Once Support

🎯 Overview

Add a comprehensive task scheduling system to LocalAGI, enabling agents to execute tasks on cron schedules, intervals, or one-time execution. This addresses the missing functionality compared to similar projects like NanoClaw, while maintaining LocalAGI's interface-based design philosophy.

📦 Requirements

Core Features

• ✅ Task Scheduling: Support for cron expressions, interval-based (milliseconds), and one-time (ISO timestamp) tasks
• ✅ JSON Storage: Simple file-based persistence with thread-safe operations
• ✅ Task Management: Create, update, pause, resume, delete tasks
• ✅ Execution Logging: Track task runs with duration, status, and results
• ✅ Interface-Based Design: Easy to extend with different storage backends (SQLite, PostgreSQL, etc.)

Architecture

Create the following new files in core/scheduler/:

1. interfaces.go - Core Interfaces

package scheduler

import (
	"context"
	"time"
)

// TaskStore defines the interface for task persistence
type TaskStore interface {
	// Create adds a new task
	Create(task *Task) error
	
	// Get retrieves a task by ID
	Get(id string) (*Task, error)
	
	// GetAll retrieves all tasks
	GetAll() ([]*Task, error)
	
	// GetDue retrieves tasks that are due for execution
	GetDue() ([]*Task, error)
	
	// GetByAgent retrieves all tasks for a specific agent
	GetByAgent(agentName string) ([]*Task, error)
	
	// Update updates an existing task
	Update(task *Task) error
	
	// Delete removes a task
	Delete(id string) error
	
	// LogRun records a task execution
	LogRun(run *TaskRun) error
	
	// GetRuns retrieves execution history for a task
	GetRuns(taskID string, limit int) ([]*TaskRun, error)
	
	// Close releases resources
	Close() error
}

// AgentExecutor defines the interface for executing agent tasks
type AgentExecutor interface {
	Execute(ctx context.Context, agentName string, prompt string) (*JobResult, error)
}

// JobResult represents the result of an agent execution
type JobResult struct {
	Response string
	Error    error
}

2. task.go - Task Data Structures

package scheduler

import (
	"fmt"
	"strconv"
	"time"

	"github.com/google/uuid"
	"github.com/robfig/cron/v3"
)

type TaskStatus string

const (
	TaskStatusActive  TaskStatus = "active"
	TaskStatusPaused  TaskStatus = "paused"
	TaskStatusDeleted TaskStatus = "deleted"
)

type ScheduleType string

const (
	ScheduleTypeCron     ScheduleType = "cron"
	ScheduleTypeInterval ScheduleType = "interval"
	ScheduleTypeOnce     ScheduleType = "once"
)

// Task represents a scheduled task
type Task struct {
	ID            string                 `json:"id"`
	AgentName     string                 `json:"agent_name"`
	Prompt        string                 `json:"prompt"`
	ScheduleType  ScheduleType           `json:"schedule_type"`
	ScheduleValue string                 `json:"schedule_value"`
	Status        TaskStatus             `json:"status"`
	NextRun       time.Time              `json:"next_run"`
	LastRun       *time.Time             `json:"last_run,omitempty"`
	CreatedAt     time.Time              `json:"created_at"`
	UpdatedAt     time.Time              `json:"updated_at"`
	ContextMode   string                 `json:"context_mode"`
	Metadata      map[string]interface{} `json:"metadata,omitempty"`
}

// TaskRun represents a single execution of a task
type TaskRun struct {
	ID         string    `json:"id"`
	TaskID     string    `json:"task_id"`
	RunAt      time.Time `json:"run_at"`
	DurationMs int64     `json:"duration_ms"`
	Status     string    `json:"status"` // "success", "error", "timeout"
	Result     string    `json:"result,omitempty"`
	Error      string    `json:"error,omitempty"`
}

// NewTask creates a new task with the given parameters
func NewTask(agentName, prompt string, scheduleType ScheduleType, scheduleValue string) (*Task, error) {
	task := &Task{
		ID:            uuid.New().String(),
		AgentName:     agentName,
		Prompt:        prompt,
		ScheduleType:  scheduleType,
		ScheduleValue: scheduleValue,
		Status:        TaskStatusActive,
		CreatedAt:     time.Now(),
		UpdatedAt:     time.Now(),
		ContextMode:   "agent",
		Metadata:      make(map[string]interface{}),
	}

	if err := task.CalculateNextRun(); err != nil {
		return nil, err
	}

	return task, nil
}

// CalculateNextRun calculates the next run time based on schedule type
func (t *Task) CalculateNextRun() error {
	now := time.Now()

	switch t.ScheduleType {
	case ScheduleTypeCron:
		parser := cron.NewParser(cron.Second | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow)
		schedule, err := parser.Parse(t.ScheduleValue)
		if err != nil {
			return fmt.Errorf("invalid cron expression: %w", err)
		}
		t.NextRun = schedule.Next(now)

	case ScheduleTypeInterval:
		intervalMs, err := strconv.ParseInt(t.ScheduleValue, 10, 64)
		if err != nil {
			return fmt.Errorf("invalid interval: %w", err)
		}
		if t.LastRun != nil {
			t.Nex...

</details>



<!-- START COPILOT CODING AGENT SUFFIX -->

*This pull request was created from Copilot chat.*
>

<!-- START COPILOT CODING AGENT TIPS -->
---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our [2 minute survey](https://gh.io/copilot-coding-agent-survey).

[Copilot]

Pull request overview

Integrates a new persistent task scheduler into the agent reminder system, replacing the previous in-memory reminder execution with a scheduler-backed implementation and adding JSON-based task storage.

Changes:

• Added core/scheduler package (task model, JSON store, scheduler loop, tests, docs).
• Wired scheduler lifecycle into agent creation/run/stop and exposed it via AgentSharedState.
• Updated reminder actions (set_reminder, list_reminders, remove_reminder) to operate on scheduled tasks.

Reviewed changes

Copilot reviewed 15 out of 17 changed files in this pull request and generated 13 comments.

Show a summary per file

File	Description
go.mod / go.sum	Updates Go module dependencies used by scheduler integration.
core/types/state.go	Adds TaskScheduler to shared state and stores agent name for task attribution.
core/state/pool.go	Passes per-agent scheduler store path via agent options when starting agents from a pool.
core/scheduler/interfaces.go	Defines scheduler storage and execution interfaces.
core/scheduler/task.go	Implements task and schedule calculation logic (cron/interval/once).
core/scheduler/json_store.go	Adds JSON file persistence for tasks and run history.
core/scheduler/scheduler.go	Adds polling scheduler that executes due tasks and logs runs.
core/scheduler/*_test.go	Adds Ginkgo test coverage for scheduler/store behavior.
core/scheduler/README.md	Documents scheduler usage and integration.
core/agent/options.go	Adds WithSchedulerStorePath option.
core/agent/agent.go	Initializes/starts/stops scheduler and injects it into shared state.
core/agent/scheduler_executor.go	Executes scheduled tasks through agent job queue and observer.
core/agent/scheduler_wrapper.go	Adapts scheduler to TaskScheduler interface.
core/action/reminder.go	Reworks reminder actions to create/list/delete scheduler tasks.
.gitignore	Ignores scheduler example build artifacts.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The scheduler store is initialized with a default path data/scheduled_tasks.json, but nothing ensures that data/ exists before calling scheduler.NewJSONStore. Unless the directory is always present in deployments, agent creation can fail on first run. Consider creating the directory before initializing the store (or have NewJSONStore handle it).

[Copilot]

list_reminders iterates over all tasks returned by GetAllTasks() without filtering out tasks marked TaskStatusDeleted (one-time tasks are set to deleted after running). This will cause already-fired one-time reminders to keep appearing in the list (and affect indexing for remove_reminder). Filter to active/paused tasks (or have the store/scheduler exclude deleted tasks for “list reminders”).

[Copilot]

CreateTask silently returns nil when the passed value isn’t a *scheduler.Task. This can hide programming errors and cause reminders to be dropped without any feedback. Return a descriptive error instead (or avoid interface{} here by making the shared interface use concrete scheduler types).

[Copilot]

For one-time tasks you set task.Status = TaskStatusDeleted but keep the task in the store. Downstream (e.g., reminder listing) will still show these unless it explicitly filters them, and indexes can shift unexpectedly. Either delete one-time tasks from the store after successful execution, or make GetAll/reminder listing exclude deleted tasks (while preserving run history separately if needed).

Suggested change

	// For one-time tasks, mark as deleted
	if task.ScheduleType == ScheduleTypeOnce {
	task.Status = TaskStatusDeleted
	} else {
	// Calculate next run
	if err := task.CalculateNextRun(); err != nil {
	xlog.Error("Failed to calculate next run", "task_id", task.ID, "error", err)
	task.Status = TaskStatusPaused
	}
	}
	// For one-time tasks, remove them from the store after execution
	if task.ScheduleType == ScheduleTypeOnce {
	if delErr := s.store.Delete(task.ID); delErr != nil {
	// If deletion fails, fall back to marking the task as deleted
	xlog.Error("Failed to delete one-time task, falling back to soft delete", "task_id", task.ID, "error", delErr)
	task.Status = TaskStatusDeleted
	if err := s.store.Update(task); err != nil {
	xlog.Error("Failed to update task after soft delete fallback", "task_id", task.ID, "error", err)
	}
	}
	return
	}
	// For recurring tasks, calculate the next run and update
	// Calculate next run
	if err := task.CalculateNextRun(); err != nil {
	xlog.Error("Failed to calculate next run", "task_id", task.ID, "error", err)
	task.Status = TaskStatusPaused
	}

[Copilot]

NewJSONStore tries to create the store file via save(), but save() will fail if the parent directory doesn’t exist (e.g., default data/scheduled_tasks.json). This can prevent agents from starting on a fresh install. Ensure NewJSONStore creates the parent directory (e.g., os.MkdirAll(filepath.Dir(filePath), ...)) before the first save.

[Copilot]

The context cancellation logic here is ineffective: the select uses a default branch and then blocks inside WaitResult(), so ctx.Done() won’t be observed once waiting begins. Also, the job isn’t created with types.WithContext(ctx), so canceling the scheduler task won’t propagate into the agent job. Consider attaching ctx to the job and waiting in a goroutine (or via a completion channel) so you can select between job completion and ctx.Done(), canceling the job if the context is canceled.

[Copilot]

Agent.Stop() holds the agent mutex while calling a.taskScheduler.Stop(). If a scheduled task is in-flight, Stop() waits for it to finish; but finishing requires the agent workers to process the queued job, and consumeJob takes the same agent mutex. This can deadlock shutdown. Release the agent lock before stopping the scheduler (or stop the scheduler asynchronously), and consider making scheduler stop non-blocking w.r.t. agent locks.

[Copilot]

Start() is not idempotent: calling it multiple times will spawn multiple polling goroutines and increment the waitgroup without any guard. Since agent.Run() calls Start() unconditionally (and AgentPool.Start() can call Run() on an already-started agent), this can lead to duplicated executions and shutdown issues. Add a running flag/sync.Once, or return an error/no-op on subsequent Start() calls.

[Copilot]

Interval schedules accept any parsed integer, including 0 or negative values. That can produce immediate/retroactive NextRun values and cause tight execution loops. Validate that the interval is a positive duration and return an error otherwise.

[Copilot]

The Markdown code fences are broken here: the code block that starts at line 110 is never closed before starting a new go block at line 117, which will render incorrectly. Close the first fence with and then start a new fenced block.