feat: NodeUpdate plans for image rollout orchestration (#94)

* feat: NodeUpdate plans for image rollout orchestration

When a Running node's spec.image differs from status.currentImage, the
planner detects the drift and builds a NodeUpdate plan to roll out the
update.

NodeUpdate plan tasks:
  1. apply-statefulset — pushes the new image to the StatefulSet via SSA
  2. apply-service — keeps the headless Service in sync
  3. observe-image — polls StatefulSet rollout until complete, stamps
     status.currentImage in-memory
  4. mark-ready — re-initializes the sidecar on the new pod

Planner condition management:
  - ResolvePlan sets NodeUpdateInProgress=True when building the plan
  - On plan completion: clears with Reason=UpdateComplete
  - On plan failure: clears with Reason=UpdateFailed, then immediately
    retries (builds a new plan since drift persists)
  - handleTerminalPlan clears completed/failed plans before building
    the next one

Drift-gated plans:
  - No drift (spec.image == status.currentImage) → no plan, steady state
  - Image drift → NodeUpdate plan

Reconciler simplification:
  - Removed observeCurrentImage method — replaced by observe-image task
  - Running-phase post-plan block removed — fully plan-driven
  - Deleted 7 observeCurrentImage unit tests (coverage moved to task tests)

New tests:
  - observe-image task: rollout complete, rolling update, stale generation,
    StatefulSet not found
  - NodeUpdate planner: drift detection, plan composition, condition
    lifecycle (start, complete, fail/retry), terminal plan handling

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

* fix: critical — NodeUpdate plans not nilled by executor, condition lifecycle

Fixes from adversarial review by Tide specialists:

CRITICAL: clearCompletedConvergencePlan was nilling NodeUpdate plans,
preventing handleTerminalPlan from ever observing the completed plan
and clearing NodeUpdateInProgress. Now renamed to clearCompletedPlanIfSafe
and checks isNodeUpdatePlan — NodeUpdate plans stay Complete for one
reconcile so the planner can observe them and clear conditions.

IMPORTANT: Document observe-image's Status() mutation of currentImage as
a sanctioned exception to the "tasks own resources" rule, explaining why
the mutation must happen at observation time.

MINOR: Fix stale "convergence plans" reference in isNodeUpdatePlan comment.
Update test to verify NodeUpdate plans stay Complete (not nilled).

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

* refactor: planner owns all plan lifecycle — executor no longer nils plans

Remove clearCompletedPlanIfSafe (formerly clearCompletedConvergencePlan)
from the executor entirely. The executor now only marks plans Complete or
Failed — it never nils them. The planner's handleTerminalPlan handles
ALL plan cleanup: clearing conditions and nilling terminal plans.

This is a cleaner separation: the executor drives tasks to completion,
the planner decides what to do with the result. No type-specific checks
(isNodeUpdatePlan) in the executor. No plan lifecycle management outside
the planner.

Also removes the now-unused currentPhase helper from the executor.

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

* refactor: move observe-image logic from Status() to Execute()

Address PR feedback: Execute() now polls the StatefulSet and stamps
currentImage when the rollout completes. Status() just returns the
cached result via DefaultStatus(). This keeps Execute as the action
method and Status as the query method.

When the rollout is not yet complete, Execute returns nil (no error).
The executor will re-invoke on the next reconcile since the task
remains Pending.

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

* refactor: conditions set directly at point of decision, no inference

Move condition setting from post-processing inference to direct mutation
at the point of decision:

- buildNodeUpdatePlan sets NodeUpdateInProgress=True directly on the
  node when it builds the plan — no separate applyPlanStartConditions
  step that scans tasks to infer the plan type
- handleTerminalPlan sets NodeUpdateInProgress=False via the shared
  setNodeUpdateCondition helper — no clearNodeUpdateCondition that
  checked whether the condition was already set

Deleted: isNodeUpdatePlan, applyPlanStartConditions, clearNodeUpdateCondition.
These inferred plan type from task contents and had special-case logic for
condition state. The new approach is simpler: the code that creates the
scenario sets the condition. The code that observes the outcome clears it.

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

* fix: only clear NodeUpdateInProgress if it was set

handleTerminalPlan was setting NodeUpdateInProgress=False for ALL
terminal plans, including init plans that never had the condition set.
This would add a spurious False condition after init completion.

Now checks hasNodeUpdateCondition before clearing — only clears the
condition if it was previously set to True by buildNodeUpdatePlan.

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

* refactor: reference TaskTypeMarkReady from task package consistently

Move the mark-ready sidecar task type constant to the task package
(re-exported from sidecar) so buildNodeUpdatePlan references all task
types via task.TaskType* consistently.

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

---------

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

Author: bdchatham

CLAUDE.md

@@ -57,7 +57,7 @@ make docker-push IMG=<image>  # Push container image
 - **SeiNode** creates StatefulSets (replicas=1), headless Services, and PVCs via server-side apply (fieldOwner: `seinode-controller`).
 - **Plan-driven reconciliation** — Both controllers use ordered task plans (stored in `.status.plan`) to drive lifecycle. Plans are built by `internal/planner/` (`ResolvePlan` for nodes, `ForGroup` for deployments), executed by `planner.Executor`, with individual tasks in `internal/task/`. The reconcile loop is: `ResolvePlan → persist plan → ExecutePlan`. See `internal/planner/doc.go` for the full plan lifecycle.
 - **Init plans** transition nodes from Pending → Running. They include infrastructure tasks (`ensure-data-pvc`, `apply-statefulset`, `apply-service`) followed by sidecar tasks (`configure-genesis`, `config-apply`, etc.).
-- **Convergence plans** keep Running nodes in sync. They contain only `apply-statefulset` + `apply-service` and are nilled from status after completion.
+- **NodeUpdate plans** roll out image changes on Running nodes. Built when `spec.image != status.currentImage`. Tasks: `apply-statefulset`, `apply-service`, `observe-image` (polls StatefulSet rollout, stamps `currentImage`), `mark-ready` (sidecar re-init). The planner sets `NodeUpdateInProgress` condition on creation and clears it on completion/failure. When no drift is detected, no plan is built — the node sits in steady state.
 - **Atomic plan creation** — New plans are persisted before any tasks execute. The reconciler flushes the plan, then requeues. Execution starts on the next reconcile. This guarantees external observers see the plan before side effects occur.
 - **Condition ownership** — The planner owns all condition management on the owning resource. It sets conditions when creating plans (e.g., `NodeUpdateInProgress=True`) and when observing terminal plans (e.g., `NodeUpdateInProgress=False`). The executor does not set conditions — it only mutates plan/task state and phase transitions.
 - **Single-patch model** — All status mutations (plan state, conditions, phase, currentImage) accumulate in-memory during a reconcile and are flushed in a single `Status().Patch()` at the end. Tasks mutate owned resources (StatefulSets, Services, PVCs); the executor mutates plan state in-memory; the reconciler flushes once.

api/v1alpha1/seinode_types.go

@@ -205,6 +205,12 @@ const (
 	PhaseTerminating  SeiNodePhase = "Terminating"
 )
 
+// SeiNode condition types.
+const (
+	// ConditionNodeUpdateInProgress indicates an image update is being rolled out.
+	ConditionNodeUpdateInProgress = "NodeUpdateInProgress"
+)
+
 // SeiNodeStatus defines the observed state of a SeiNode.
 type SeiNodeStatus struct {
 	// Phase is the high-level lifecycle state.

internal/controller/node/controller.go

@@ -120,15 +120,6 @@ func (r *SeiNodeReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 		statusDirty = true
 	}
 
-	// Running phase: observe image convergence in-memory.
-	if node.Status.Phase == seiv1alpha1.PhaseRunning {
-		if dirty, err := r.observeCurrentImage(ctx, node); err != nil {
-			return ctrl.Result{}, fmt.Errorf("observing current image: %w", err)
-		} else if dirty {
-			statusDirty = true
-		}
-	}
-
 	if statusDirty {
 		if err := r.Status().Patch(ctx, node, statusBase); err != nil {
 			if execErr != nil {
@@ -166,31 +157,6 @@ func (r *SeiNodeReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ct
 	return result, nil
 }
 
-// observeCurrentImage checks whether the StatefulSet rollout has completed
-// and stamps status.currentImage in-memory. Returns true if the image changed.
-func (r *SeiNodeReconciler) observeCurrentImage(ctx context.Context, node *seiv1alpha1.SeiNode) (bool, error) {
-	sts := &appsv1.StatefulSet{}
-	if err := r.Get(ctx, types.NamespacedName{Name: node.Name, Namespace: node.Namespace}, sts); err != nil {
-		if apierrors.IsNotFound(err) {
-			return false, nil
-		}
-		return false, err
-	}
-
-	if sts.Status.ObservedGeneration < sts.Generation {
-		return false, nil
-	}
-	if sts.Spec.Replicas == nil || sts.Status.UpdatedReplicas < *sts.Spec.Replicas {
-		return false, nil
-	}
-
-	if node.Status.CurrentImage != node.Spec.Image {
-		node.Status.CurrentImage = node.Spec.Image
-		return true, nil
-	}
-	return false, nil
-}
-
 // SetupWithManager sets up the controller with the Manager.
 func (r *SeiNodeReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	return ctrl.NewControllerManagedBy(mgr).

internal/controller/node/plan_execution_test.go

@@ -677,16 +677,18 @@ func TestExecutePlan_AllComplete_TransitionsToTargetPhase(t *testing.T) {
 	g.Expect(node.Status.Plan.Phase).To(Equal(seiv1alpha1.TaskPlanComplete))
 }
 
-func TestExecutePlan_ConvergencePlan_NilsOnCompletion(t *testing.T) {
+func TestExecutePlan_CompletedPlan_StaysForPlannerCleanup(t *testing.T) {
 	g := NewWithT(t)
 	mock := &mockSidecarClient{}
 	node := snapshotNode()
 	node.Status.Phase = seiv1alpha1.PhaseRunning
 	node.Status.Plan = nil
-	// Build a convergence plan for a Running node.
+	// Build a NodeUpdate plan for a Running node with drift.
 	if err := planner.ResolvePlan(node); err != nil {
 		t.Fatal(err)
 	}
+	g.Expect(node.Status.Plan).NotTo(BeNil())
+
 	// Pre-complete all tasks.
 	for i := range node.Status.Plan.Tasks {
 		node.Status.Plan.Tasks[i].Status = seiv1alpha1.TaskComplete
@@ -696,8 +698,11 @@ func TestExecutePlan_ConvergencePlan_NilsOnCompletion(t *testing.T) {
 	_, err := r.PlanExecutor.ExecutePlan(context.Background(), node, node.Status.Plan)
 	g.Expect(err).NotTo(HaveOccurred())
 
-	g.Expect(node.Status.Plan).To(BeNil(), "convergence plan should be nilled after completion")
-	g.Expect(node.Status.Phase).To(Equal(seiv1alpha1.PhaseRunning), "phase should stay Running")
+	// Completed plans stay in status — the planner handles cleanup
+	// (nilling the plan, clearing conditions) on the next reconcile.
+	g.Expect(node.Status.Plan).NotTo(BeNil(), "completed plan should stay for planner to observe")
+	g.Expect(node.Status.Plan.Phase).To(Equal(seiv1alpha1.TaskPlanComplete))
+	g.Expect(node.Status.Phase).To(Equal(seiv1alpha1.PhaseRunning))
 }
 
 func TestExecutePlan_TaskFailure_SetsPlanFailedCondition(t *testing.T) {

internal/controller/node/reconciler_test.go

@@ -224,275 +224,6 @@ func TestNodeReconcile_RunningPhase_UpdatesStatefulSetImage(t *testing.T) {
 	g.Expect(seid.Image).To(Equal(testImageV2))
 }
 
-func TestObserveCurrentImage_UpdatesWhenConverged(t *testing.T) {
-	g := NewWithT(t)
-	ctx := context.Background()
-
-	node := newGenesisNode("mynet-0", "default")
-	node.Finalizers = []string{nodeFinalizerName}
-	node.Status.Phase = seiv1alpha1.PhaseRunning
-	node.Spec.Image = testImageV2
-
-	sts := &appsv1.StatefulSet{
-		ObjectMeta: metav1.ObjectMeta{Name: "mynet-0", Namespace: "default"},
-		Spec: appsv1.StatefulSetSpec{
-			Replicas:    ptrInt32(1),
-			ServiceName: "mynet-0",
-			Selector:    &metav1.LabelSelector{MatchLabels: map[string]string{"sei.io/node": "mynet-0"}},
-			Template: corev1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"sei.io/node": "mynet-0"}},
-				Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "seid", Image: testImageV2}}},
-			},
-		},
-	}
-
-	s := newNodeTestScheme(t)
-	c := fake.NewClientBuilder().
-		WithScheme(s).
-		WithObjects(node, sts).
-		WithStatusSubresource(&seiv1alpha1.SeiNode{}, &appsv1.StatefulSet{}).
-		Build()
-
-	sts.Status.UpdatedReplicas = 1
-	sts.Status.ObservedGeneration = sts.Generation
-	g.Expect(c.Status().Update(ctx, sts)).To(Succeed())
-
-	r := &SeiNodeReconciler{Client: c, Scheme: s}
-	_, err := r.observeCurrentImage(ctx, node)
-	g.Expect(err).NotTo(HaveOccurred())
-
-	g.Expect(node.Status.CurrentImage).To(Equal(testImageV2))
-}
-
-func TestObserveCurrentImage_SkipsWhenStaleGeneration(t *testing.T) {
-	g := NewWithT(t)
-	ctx := context.Background()
-
-	node := newGenesisNode("mynet-0", "default")
-	node.Finalizers = []string{nodeFinalizerName}
-	node.Status.Phase = seiv1alpha1.PhaseRunning
-	node.Spec.Image = testImageV2
-
-	sts := &appsv1.StatefulSet{
-		ObjectMeta: metav1.ObjectMeta{Name: "mynet-0", Namespace: "default", Generation: 2},
-		Spec: appsv1.StatefulSetSpec{
-			Replicas:    ptrInt32(1),
-			ServiceName: "mynet-0",
-			Selector:    &metav1.LabelSelector{MatchLabels: map[string]string{"sei.io/node": "mynet-0"}},
-			Template: corev1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"sei.io/node": "mynet-0"}},
-				Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "seid", Image: testImageV2}}},
-			},
-		},
-	}
-
-	s := newNodeTestScheme(t)
-	c := fake.NewClientBuilder().
-		WithScheme(s).
-		WithObjects(node, sts).
-		WithStatusSubresource(&seiv1alpha1.SeiNode{}, &appsv1.StatefulSet{}).
-		Build()
-
-	sts.Status.UpdatedReplicas = 1
-	sts.Status.ObservedGeneration = 1
-	g.Expect(c.Status().Update(ctx, sts)).To(Succeed())
-
-	r := &SeiNodeReconciler{Client: c, Scheme: s}
-	_, err := r.observeCurrentImage(ctx, node)
-	g.Expect(err).NotTo(HaveOccurred())
-
-	g.Expect(node.Status.CurrentImage).To(BeEmpty())
-}
-
-func TestObserveCurrentImage_SkipsWhenRolling(t *testing.T) {
-	g := NewWithT(t)
-	ctx := context.Background()
-
-	node := newGenesisNode("mynet-0", "default")
-	node.Finalizers = []string{nodeFinalizerName}
-	node.Status.Phase = seiv1alpha1.PhaseRunning
-	node.Spec.Image = testImageV2
-
-	sts := &appsv1.StatefulSet{
-		ObjectMeta: metav1.ObjectMeta{Name: "mynet-0", Namespace: "default"},
-		Spec: appsv1.StatefulSetSpec{
-			Replicas:    ptrInt32(1),
-			ServiceName: "mynet-0",
-			Selector:    &metav1.LabelSelector{MatchLabels: map[string]string{"sei.io/node": "mynet-0"}},
-			Template: corev1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"sei.io/node": "mynet-0"}},
-				Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "seid", Image: testImageV2}}},
-			},
-		},
-	}
-
-	s := newNodeTestScheme(t)
-	c := fake.NewClientBuilder().
-		WithScheme(s).
-		WithObjects(node, sts).
-		WithStatusSubresource(&seiv1alpha1.SeiNode{}, &appsv1.StatefulSet{}).
-		Build()
-
-	sts.Status.CurrentRevision = "rev-1"
-	sts.Status.UpdateRevision = testRevision
-	g.Expect(c.Status().Update(ctx, sts)).To(Succeed())
-
-	r := &SeiNodeReconciler{Client: c, Scheme: s}
-	_, err := r.observeCurrentImage(ctx, node)
-	g.Expect(err).NotTo(HaveOccurred())
-
-	g.Expect(node.Status.CurrentImage).To(BeEmpty())
-}
-
-func TestObserveCurrentImage_SkipsWhenReadyReplicasZero(t *testing.T) {
-	g := NewWithT(t)
-	ctx := context.Background()
-
-	node := newGenesisNode("mynet-0", "default")
-	node.Finalizers = []string{nodeFinalizerName}
-	node.Status.Phase = seiv1alpha1.PhaseRunning
-	node.Spec.Image = testImageV2
-
-	sts := &appsv1.StatefulSet{
-		ObjectMeta: metav1.ObjectMeta{Name: "mynet-0", Namespace: "default"},
-		Spec: appsv1.StatefulSetSpec{
-			Replicas:    ptrInt32(1),
-			ServiceName: "mynet-0",
-			Selector:    &metav1.LabelSelector{MatchLabels: map[string]string{"sei.io/node": "mynet-0"}},
-			Template: corev1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"sei.io/node": "mynet-0"}},
-				Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "seid", Image: testImageV2}}},
-			},
-		},
-	}
-
-	s := newNodeTestScheme(t)
-	c := fake.NewClientBuilder().
-		WithScheme(s).
-		WithObjects(node, sts).
-		WithStatusSubresource(&seiv1alpha1.SeiNode{}, &appsv1.StatefulSet{}).
-		Build()
-
-	sts.Status.CurrentRevision = testRevision
-	sts.Status.UpdateRevision = testRevision
-	sts.Status.ReadyReplicas = 0
-	g.Expect(c.Status().Update(ctx, sts)).To(Succeed())
-
-	r := &SeiNodeReconciler{Client: c, Scheme: s}
-	_, err := r.observeCurrentImage(ctx, node)
-	g.Expect(err).NotTo(HaveOccurred())
-
-	g.Expect(node.Status.CurrentImage).To(BeEmpty())
-}
-
-func TestObserveCurrentImage_SkipsWhenEmptyRevision(t *testing.T) {
-	g := NewWithT(t)
-	ctx := context.Background()
-
-	node := newGenesisNode("mynet-0", "default")
-	node.Finalizers = []string{nodeFinalizerName}
-	node.Status.Phase = seiv1alpha1.PhaseRunning
-	node.Spec.Image = testImageV2
-
-	sts := &appsv1.StatefulSet{
-		ObjectMeta: metav1.ObjectMeta{Name: "mynet-0", Namespace: "default"},
-		Spec: appsv1.StatefulSetSpec{
-			Replicas:    ptrInt32(1),
-			ServiceName: "mynet-0",
-			Selector:    &metav1.LabelSelector{MatchLabels: map[string]string{"sei.io/node": "mynet-0"}},
-			Template: corev1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"sei.io/node": "mynet-0"}},
-				Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "seid", Image: testImageV2}}},
-			},
-		},
-	}
-
-	s := newNodeTestScheme(t)
-	c := fake.NewClientBuilder().
-		WithScheme(s).
-		WithObjects(node, sts).
-		WithStatusSubresource(&seiv1alpha1.SeiNode{}, &appsv1.StatefulSet{}).
-		Build()
-
-	sts.Status.CurrentRevision = ""
-	sts.Status.UpdateRevision = testRevision
-	sts.Status.ReadyReplicas = 1
-	g.Expect(c.Status().Update(ctx, sts)).To(Succeed())
-
-	r := &SeiNodeReconciler{Client: c, Scheme: s}
-	_, err := r.observeCurrentImage(ctx, node)
-	g.Expect(err).NotTo(HaveOccurred())
-
-	g.Expect(node.Status.CurrentImage).To(BeEmpty())
-}
-
-func TestObserveCurrentImage_NoopWhenAlreadyCurrent(t *testing.T) {
-	g := NewWithT(t)
-	ctx := context.Background()
-
-	node := newGenesisNode("mynet-0", "default")
-	node.Finalizers = []string{nodeFinalizerName}
-	node.Status.Phase = seiv1alpha1.PhaseRunning
-	node.Spec.Image = testImageV2
-	node.Status.CurrentImage = testImageV2
-
-	sts := &appsv1.StatefulSet{
-		ObjectMeta: metav1.ObjectMeta{Name: "mynet-0", Namespace: "default"},
-		Spec: appsv1.StatefulSetSpec{
-			Replicas:    ptrInt32(1),
-			ServiceName: "mynet-0",
-			Selector:    &metav1.LabelSelector{MatchLabels: map[string]string{"sei.io/node": "mynet-0"}},
-			Template: corev1.PodTemplateSpec{
-				ObjectMeta: metav1.ObjectMeta{Labels: map[string]string{"sei.io/node": "mynet-0"}},
-				Spec:       corev1.PodSpec{Containers: []corev1.Container{{Name: "seid", Image: testImageV2}}},
-			},
-		},
-	}
-
-	s := newNodeTestScheme(t)
-	c := fake.NewClientBuilder().
-		WithScheme(s).
-		WithObjects(node, sts).
-		WithStatusSubresource(&seiv1alpha1.SeiNode{}, &appsv1.StatefulSet{}).
-		Build()
-
-	sts.Status.CurrentRevision = testRevision
-	sts.Status.UpdateRevision = testRevision
-	sts.Status.ReadyReplicas = 1
-	g.Expect(c.Status().Update(ctx, sts)).To(Succeed())
-
-	r := &SeiNodeReconciler{Client: c, Scheme: s}
-	_, err := r.observeCurrentImage(ctx, node)
-	g.Expect(err).NotTo(HaveOccurred())
-
-	g.Expect(node.Status.CurrentImage).To(Equal(testImageV2))
-}
-
-func TestObserveCurrentImage_StatefulSetNotFound(t *testing.T) {
-	g := NewWithT(t)
-	ctx := context.Background()
-
-	node := newGenesisNode("mynet-0", "default")
-	node.Finalizers = []string{nodeFinalizerName}
-	node.Status.Phase = seiv1alpha1.PhaseRunning
-	node.Spec.Image = testImageV2
-
-	s := newNodeTestScheme(t)
-	c := fake.NewClientBuilder().
-		WithScheme(s).
-		WithObjects(node).
-		WithStatusSubresource(&seiv1alpha1.SeiNode{}).
-		Build()
-
-	r := &SeiNodeReconciler{Client: c, Scheme: s}
-	_, err := r.observeCurrentImage(ctx, node)
-	g.Expect(err).NotTo(HaveOccurred())
-
-	g.Expect(node.Status.CurrentImage).To(BeEmpty())
-}
-
-func ptrInt32(v int32) *int32 { return &v }
-
 func TestNodeDeletion_SnapshotNode_WithoutRetain_DeletesPVC(t *testing.T) {
 	g := NewWithT(t)
 	ctx := context.Background()