feat: remove monitor task system (#89)

Remove the entire MonitorTask subsystem — no concrete use case remains.
This simplifies the reconcile loop and removes the sidecar client
dependency from the reconciler.

Deleted:
- monitor.go + monitor_test.go (ensureMonitorTasks, pollMonitorTasks)
- plan_execution.go (buildSidecarClient, reconcileRuntimeTasks)
- reconcileRunningTasks method from controller.go
- BuildSidecarClientFn field from SeiNodeReconciler
- MonitorTask type and MonitorTasks field from SeiNodeStatus CRD
- SnapshotUploadMonitorTask, ResultExportMonitorTask from planner
- TaskSnapshotUpload, TaskResultExport constants
- Monitor task metrics (sidecarUnreachableTotal, monitorTaskCompletedTotal,
  monitorTaskStatus) and associated emit/cleanup functions
- All monitor-related tests (~200 lines)

Kept:
- ResultExportConfig type and ReplayerSpec.ResultExport field (the config
  stays on the CRD; how we manage its lifecycle is TBD)
- Platform config result-export fields
- observeCurrentImage (still runs for Running nodes, will be moved into
  plans in a follow-up)

The reconcile loop is now: ensureNodeFinalizer → reconcilePeers →
ResolvePlan → ExecutePlan → emit metrics → observeCurrentImage (Running).

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bdchatham

api/v1alpha1/seinode_types.go

@@ -205,29 +205,6 @@ const (
 	PhaseTerminating  SeiNodePhase = "Terminating"
 )
 
-// MonitorTask tracks a long-running sidecar task that the controller
-// actively polls for completion. Unlike fire-and-forget tasks,
-// completing a monitor task triggers a controller response (Event + Condition).
-// The map key in MonitorTasks serves as the task type identifier.
-type MonitorTask struct {
-	// ID is the sidecar-assigned task UUID.
-	ID string `json:"id"`
-
-	// Status tracks lifecycle: Pending → Complete or Failed.
-	Status TaskStatus `json:"status"`
-
-	// SubmittedAt is the time the task was submitted to the sidecar.
-	SubmittedAt metav1.Time `json:"submittedAt"`
-
-	// CompletedAt is the time the task reached a terminal state.
-	// +optional
-	CompletedAt *metav1.Time `json:"completedAt,omitempty"`
-
-	// Error is set when the task fails.
-	// +optional
-	Error string `json:"error,omitempty"`
-}
-
 // SeiNodeStatus defines the observed state of a SeiNode.
 type SeiNodeStatus struct {
 	// Phase is the high-level lifecycle state.
@@ -251,11 +228,6 @@ type SeiNodeStatus struct {
 	// +optional
 	Plan *TaskPlan `json:"plan,omitempty"`
 
-	// MonitorTasks tracks long-running sidecar tasks the controller polls
-	// for completion. Keyed by task type for idempotent submission.
-	// +optional
-	MonitorTasks map[string]MonitorTask `json:"monitorTasks,omitempty"`
-
 	// ResolvedPeers is the current set of peer DNS hostnames discovered
 	// from label-based peer sources. Reconciled continuously so that
 	// future peer-update plans can detect drift.

api/v1alpha1/zz_generated.deepcopy.go

@@ -573,47 +573,6 @@ spec:
                   ingress. Used by the planner to set p2p.external_address in CometBFT
                   config so the node advertises a reachable address for gossip discovery.
                 type: string
-              monitorTasks:
-                additionalProperties:
-                  description: |-
-                    MonitorTask tracks a long-running sidecar task that the controller
-                    actively polls for completion. Unlike fire-and-forget tasks,
-                    completing a monitor task triggers a controller response (Event + Condition).
-                    The map key in MonitorTasks serves as the task type identifier.
-                  properties:
-                    completedAt:
-                      description: CompletedAt is the time the task reached a terminal
-                        state.
-                      format: date-time
-                      type: string
-                    error:
-                      description: Error is set when the task fails.
-                      type: string
-                    id:
-                      description: ID is the sidecar-assigned task UUID.
-                      type: string
-                    status:
-                      description: 'Status tracks lifecycle: Pending → Complete or
-                        Failed.'
-                      enum:
-                      - Pending
-                      - Complete
-                      - Failed
-                      type: string
-                    submittedAt:
-                      description: SubmittedAt is the time the task was submitted
-                        to the sidecar.
-                      format: date-time
-                      type: string
-                  required:
-                  - id
-                  - status
-                  - submittedAt
-                  type: object
-                description: |-
-                  MonitorTasks tracks long-running sidecar tasks the controller polls
-                  for completion. Keyed by task type for idempotent submission.
-                type: object
               phase:
                 description: Phase is the high-level lifecycle state.
                 enum:

config/crd/sei.io_seinodes.yaml

@@ -16,14 +16,12 @@ import (
 	"sigs.k8s.io/controller-runtime/pkg/builder"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 	"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
-	"sigs.k8s.io/controller-runtime/pkg/log"
 	"sigs.k8s.io/controller-runtime/pkg/predicate"
 
 	seiv1alpha1 "github.com/sei-protocol/sei-k8s-controller/api/v1alpha1"
 	"github.com/sei-protocol/sei-k8s-controller/internal/noderesource"
 	"github.com/sei-protocol/sei-k8s-controller/internal/planner"
 	"github.com/sei-protocol/sei-k8s-controller/internal/platform"
-	"github.com/sei-protocol/sei-k8s-controller/internal/task"
 )
 
 const (
@@ -39,11 +37,10 @@ type PlatformConfig = platform.Config
 // SeiNodeReconciler reconciles a SeiNode object.
 type SeiNodeReconciler struct {
 	client.Client
-	Scheme               *runtime.Scheme
-	Recorder             record.EventRecorder
-	Platform             PlatformConfig
-	PlanExecutor         planner.PlanExecutor[*seiv1alpha1.SeiNode]
-	BuildSidecarClientFn func(node *seiv1alpha1.SeiNode) task.SidecarClient
+	Scheme       *runtime.Scheme
+	Recorder     record.EventRecorder
+	Platform     PlatformConfig
+	PlanExecutor planner.PlanExecutor[*seiv1alpha1.SeiNode]
 }
 
 // +kubebuilder:rbac:groups=sei.io,resources=seinodes,verbs=get;list;watch;create;update;patch;delete
@@ -133,31 +130,17 @@ func (r *SeiNodeReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		}
 	}
 
-	// Running phase: after the convergence plan completes, handle
-	// runtime tasks (image observation, monitor task polling).
+	// Running phase: observe image convergence after plan completes.
 	if node.Status.Phase == seiv1alpha1.PhaseRunning {
-		return r.reconcileRunningTasks(ctx, node)
+		if err := r.observeCurrentImage(ctx, node); err != nil {
+			return ctrl.Result{}, fmt.Errorf("observing current image: %w", err)
+		}
+		return ctrl.Result{RequeueAfter: statusPollInterval}, nil
 	}
 
 	return result, nil
 }
 
-// reconcileRunningTasks handles Running-phase work that is outside the plan:
-// image observation and sidecar monitor task polling.
-func (r *SeiNodeReconciler) reconcileRunningTasks(ctx context.Context, node *seiv1alpha1.SeiNode) (ctrl.Result, error) {
-	if err := r.observeCurrentImage(ctx, node); err != nil {
-		return ctrl.Result{}, fmt.Errorf("observing current image: %w", err)
-	}
-
-	sc := r.buildSidecarClient(node)
-	if sc == nil {
-		sidecarUnreachableTotal.WithLabelValues(node.Namespace, node.Name).Inc()
-		log.FromContext(ctx).Info("sidecar not reachable, will retry")
-		return ctrl.Result{RequeueAfter: statusPollInterval}, nil
-	}
-	return r.reconcileRuntimeTasks(ctx, node, sc)
-}
-
 func (r *SeiNodeReconciler) observeCurrentImage(ctx context.Context, node *seiv1alpha1.SeiNode) error {
 	sts := &appsv1.StatefulSet{}
 	if err := r.Get(ctx, types.NamespacedName{Name: node.Name, Namespace: node.Namespace}, sts); err != nil {

internal/controller/node/controller.go

@@ -17,12 +17,6 @@ var allNodePhases = []string{
 	string(seiv1alpha1.PhaseTerminating),
 }
 
-var allTaskStatuses = []string{
-	string(seiv1alpha1.TaskPending),
-	string(seiv1alpha1.TaskComplete),
-	string(seiv1alpha1.TaskFailed),
-}
-
 var (
 	nodePhaseGauge = prometheus.NewGaugeVec(
 		prometheus.GaugeOpts{
@@ -56,30 +50,6 @@ var (
 		},
 		[]string{"namespace", "name"},
 	)
-
-	sidecarUnreachableTotal = prometheus.NewCounterVec(
-		prometheus.CounterOpts{
-			Name: "sei_controller_sidecar_unreachable_total",
-			Help: "Number of times the sidecar was unreachable",
-		},
-		[]string{"namespace", "node"},
-	)
-
-	monitorTaskCompletedTotal = prometheus.NewCounterVec(
-		prometheus.CounterOpts{
-			Name: "sei_controller_monitor_task_completed_total",
-			Help: "Monitor task terminal state transitions (DivergenceDetected, TaskFailed, TaskLost)",
-		},
-		[]string{"namespace", "node", "task_type", "reason"},
-	)
-
-	monitorTaskStatus = prometheus.NewGaugeVec(
-		prometheus.GaugeOpts{
-			Name: "sei_controller_monitor_task_status",
-			Help: "Current status of each monitor task (1=active, 0=inactive)",
-		},
-		[]string{"namespace", "node", "task_type", "status"},
-	)
 )
 
 func init() {
@@ -88,43 +58,16 @@ func init() {
 		nodePhaseTransitions,
 		nodeInitDuration,
 		nodeLastInitDuration,
-		sidecarUnreachableTotal,
-		monitorTaskCompletedTotal,
-		monitorTaskStatus,
 	)
 }
 
 func emitNodePhase(ns, name string, phase seiv1alpha1.SeiNodePhase) {
 	observability.EmitPhaseGauge(nodePhaseGauge, ns, name, string(phase), allNodePhases)
 }
 
-func emitMonitorTaskTerminal(ns, node, taskType, reason string) {
-	monitorTaskCompletedTotal.WithLabelValues(ns, node, taskType, reason).Inc()
-}
-
-func emitMonitorTaskStatus(ns, node, taskType, status string) {
-	for _, s := range allTaskStatuses {
-		val := float64(0)
-		if s == status {
-			val = 1
-		}
-		monitorTaskStatus.WithLabelValues(ns, node, taskType, s).Set(val)
-	}
-}
-
-func cleanupMonitorTaskMetrics(ns, name string, taskTypes []string) {
-	for _, tt := range taskTypes {
-		for _, s := range allTaskStatuses {
-			monitorTaskStatus.DeleteLabelValues(ns, name, tt, s)
-		}
-	}
-}
-
 func cleanupNodeMetrics(namespace, name string) {
 	observability.DeletePhaseGauge(nodePhaseGauge, namespace, name, allNodePhases)
 	nodeLastInitDuration.DeleteLabelValues(namespace, name)
-	sidecarUnreachableTotal.DeleteLabelValues(namespace, name)
 	observability.ReconcileErrorsTotal.DeleteLabelValues(seiNodeControllerName, namespace, name)
-	cleanupMonitorTaskMetrics(namespace, name, []string{planner.TaskResultExport})
 	planner.CleanupPlanMetrics("seinode", namespace, name)
 }