yux0 · Oct 19, 2026 · Oct 27, 2026
@@ -60,6 +60,19 @@ func (h *PayloadTTLSideEffectTaskHandler) Validate(
 	return validateTask(chasmContext, store, attributes.TaskAttributes, task.PayloadKey)
 }
 
+func (h *PayloadTTLSideEffectTaskHandler) ValidateStandby(
+	ctx context.Context,
+	ref chasm.ComponentRef,
+	attributes chasm.TaskInvocation,
+	task *testspb.TestPayloadTTLSideEffectTask,
+) (bool, error) {
+
+	return chasm.ReadComponent(ctx, ref,
+		func(store *PayloadStore, chasmContext chasm.Context, task *testspb.TestPayloadTTLSideEffectTask) (bool, error) {
+			return validateTask(chasmContext, store, attributes.TaskAttributes, task.PayloadKey)
+		}, task)
+}
+
 func validateTask(
 	chasmContext chasm.Context,
 	store *PayloadStore,

@@ -0,0 +1,93 @@
+package tests_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	"go.temporal.io/api/serviceerror"
+	"go.temporal.io/server/chasm"
+	"go.temporal.io/server/chasm/chasmtest"
+	"go.temporal.io/server/chasm/lib/tests"
+	"go.temporal.io/server/chasm/lib/tests/gen/testspb/v1"
+	"go.temporal.io/server/common/clock"
+	"go.temporal.io/server/common/log"
+	"go.temporal.io/server/common/payload"
+	"go.temporal.io/server/common/testing/protorequire"
+)
+
+var _ chasm.StandbyTaskValidator[*testspb.TestPayloadTTLSideEffectTask] = (*tests.PayloadTTLSideEffectTaskHandler)(nil)
+
+func TestPayloadTTLSideEffectTaskValidateStandby(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		name          string
+		ttl           time.Duration
+		removePayload bool
+		missingStore  bool
+		valid         bool
+	}{
+		{name: "expiration matches task - retry", ttl: time.Hour, valid: true},
+		{name: "expiration before task - retry", ttl: 30 * time.Minute, valid: true},
+		{name: "expiration after task - discard", ttl: 2 * time.Hour},
+		{name: "payload removed - discard", ttl: time.Hour, removePayload: true},
+		{name: "payload has no TTL - discard"},
+		{name: "store missing - propagate read error", missingStore: true},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			registry := chasm.NewRegistry(log.NewNoopLogger())
+			require.NoError(t, registry.Register(&chasm.CoreLibrary{}))
+			require.NoError(t, registry.Register(tests.Library))
+			now := time.Date(2026, 1, 1, 0, 0, 0, 0, time.UTC)
+			engine := chasmtest.NewEngine(t, registry, chasmtest.WithTimeSource(clock.NewEventTimeSource().Update(now)))
+			ctx := chasm.NewEngineContext(t.Context(), engine)
+			key := chasm.ExecutionKey{NamespaceID: "test-namespace", BusinessID: "payload-store"}
+			if !tc.missingStore {
+				result, err := chasm.StartExecution(ctx, key,
+					func(ctx chasm.MutableContext, _ any) (*tests.PayloadStore, error) {
+						store, err := tests.NewPayloadStore(ctx)
+						if err != nil {
+							return nil, err
+						}
+						_, err = store.AddPayload(ctx, tests.AddPayloadRequest{
+							PayloadKey: "payload", Payload: payload.EncodeString("value"), TTL: tc.ttl,
+						})
+						return store, err
+					}, nil)
+				require.NoError(t, err)
+				key = result.ExecutionKey
+			}
+			ref := chasm.NewComponentRef[*tests.PayloadStore](key)
+			if tc.removePayload {
+				_, _, err := chasm.UpdateComponent(ctx, ref, (*tests.PayloadStore).RemovePayload, "payload")
+				require.NoError(t, err)
+			}
+
+			var before tests.DescribePayloadStoreResponse
+			if !tc.missingStore {
+				var err error
+				before, err = chasm.ReadComponent(ctx, ref, (*tests.PayloadStore).Describe, tests.DescribePayloadStoreRequest{})
+				require.NoError(t, err)
+			}
+
+			handler := &tests.PayloadTTLSideEffectTaskHandler{}
+			valid, err := handler.ValidateStandby(ctx, ref, chasm.TaskInvocation{
+				TaskAttributes: chasm.TaskAttributes{ScheduledTime: now.Add(time.Hour)}, Attempt: 3,
+			}, &testspb.TestPayloadTTLSideEffectTask{PayloadKey: "payload"})
+			require.Equal(t, tc.valid, valid)
+			if tc.missingStore {
+				var notFound *serviceerror.NotFound
+				require.ErrorAs(t, err, &notFound)
+				return
+			}
+			require.NoError(t, err)
+
+			after, err := chasm.ReadComponent(ctx, ref, (*tests.PayloadStore).Describe, tests.DescribePayloadStoreRequest{})
+			require.NoError(t, err)
+			protorequire.ProtoEqual(t, before.State, after.State)
+		})
+	}
+}
@@ -23,6 +23,7 @@ type (
 		goType                   reflect.Type
 		componentGoType          reflect.Type // It is not clear how this one is used.
 		validateFn               validateFn
+		validateStandbyFn        func(context.Context, ComponentRef, TaskInvocation, any) (bool, error)
 		pureTaskExecuteFn        pureTaskExecuteFn
 		sideEffectTaskExecuteFn  sideEffectTaskExecuteFn
 		sideEffectTaskDiscardFn  sideEffectTaskDiscardFn
@@ -45,13 +46,13 @@ type (
 )
 
 // NewRegistrableSideEffectTask creates a new registrable side-effect task. NOTE: C is not Component but any.
-// The handler's Discard method is called on standby clusters when a task has been pending past the discard delay.
+// The handler's Discard method is called when standby validation returns false.
 func NewRegistrableSideEffectTask[C any, T any](
 	taskType string,
 	handler SideEffectTaskHandler[C, T],
 	opts ...RegistrableTaskOption,
 ) *RegistrableTask {
-	return newRegistrableTask(
+	rt := newRegistrableTask(
 		taskType,
 		reflect.TypeFor[T](),
 		reflect.TypeFor[C](),
@@ -84,6 +85,17 @@ func NewRegistrableSideEffectTask[C any, T any](
 		},
 		opts...,
 	)
+	rt.validateStandbyFn = func(ctx context.Context, ref ComponentRef, invocation TaskInvocation, task any) (bool, error) {
+		return ReadComponent(ctx, ref, func(component C, ctx Context, _ struct{}) (bool, error) {
+			return handler.Validate(ctx, component, invocation, task.(T))
+		}, struct{}{})
+	}
+	if validator, ok := handler.(StandbyTaskValidator[T]); ok {
+		rt.validateStandbyFn = func(ctx context.Context, ref ComponentRef, invocation TaskInvocation, task any) (bool, error) {
+			return validator.ValidateStandby(ctx, ref, invocation, task.(T))
+		}
+	}
+	return rt
 }
 
 func NewRegistrablePureTask[C any, T any](

@@ -9,7 +9,7 @@ import (
 )
 
 // ErrTaskDiscarded is the error returned by the default [SideEffectTaskHandlerBase] Discard implementation,
-// indicating that a side-effect task on a standby cluster has been pending past the discard delay.
+// indicating that standby validation rejected a task without a custom discard handler.
 var ErrTaskDiscarded = errors.New("standby task pending for too long")
 
 type (
@@ -25,7 +25,7 @@ type (
 		Destination string
 	}
 
-	// TaskInvocation is passed to a task's Validate callback. It carries the task's [TaskAttributes]
+	// TaskInvocation is passed to a task's Validate and ValidateStandby callbacks. It carries the task's [TaskAttributes]
 	// together with framework-supplied state for the current processing attempt.
 	TaskInvocation struct {
 		TaskAttributes
@@ -44,7 +44,7 @@ type (
 		TaskValidator[C, T]
 		Execute(context.Context, ComponentRef, TaskAttributes, T) error
 		// Discard implements custom discard behavior on standby clusters. When a side-effect task has been
-		// pending on standby past the discard delay, the framework calls Discard instead of silently dropping
+		// rejected by standby validation, the framework calls Discard instead of silently dropping
 		// the task. For example, the activity dispatch handler implements this to spill tasks to matching.
 		// The ctx carries engine access, but implementations must avoid mutating component state on standby
 		// clusters.
@@ -60,6 +60,16 @@ type (
 		pureTaskHandler()
 	}
 
+	// StandbyTaskValidator optionally overrides standby validation for a side-effect task.
+	// The callback runs without holding the execution lock and may perform I/O. Component
+	// state must be accessed through ReadComponent; it must not be mutated on standby.
+	// Handlers without this interface fall back to Validate through a locked component read.
+	StandbyTaskValidator[T any] interface {
+		// ValidateStandby returns true to retry the task, false to invoke Discard, or an error
+		// to fail the processing attempt. It receives an engine-enabled context.
+		ValidateStandby(context.Context, ComponentRef, TaskInvocation, T) (bool, error)
+	}
+
 	// TaskValidator is implemented by both [SideEffectTaskHandler] and [PureTaskHandler] to gate
 	// whether a task should proceed with execution.
 	TaskValidator[C any, T any] interface {
@@ -78,6 +88,8 @@ type (
 		// The framework automatically calls Validate at key points, such as after closing transactions, to check all
 		// generated tasks before they execute.
 		//
+		// Side-effect handlers may implement [StandbyTaskValidator] to override validation on standby.
+		//
 		// Returns:
 		// - (true, nil) if the task is valid and should be executed
 		// - (false, nil) if the task should be silently dropped (it's no longer relevant)

@@ -3869,7 +3869,7 @@ func (n *Node) ExecutePureTask(
 }
 
 // ValidateSideEffectTask checks whether a side effect task should still be
-// executed. Intended for use by standby handlers.
+// executed using the default validator.
 //
 // It returns two booleans:
 //   - isTaskInTree: true if the task's logical counterpart still exists in the
@@ -3887,7 +3887,44 @@ func (n *Node) ValidateSideEffectTask(
 	ctx context.Context,
 	chasmTask *tasks.ChasmTask,
 ) (isTaskInTree bool, isValidByComponent bool, retErr error) {
+	return n.validateSideEffectTask(ctx, chasmTask, true)
+}
+
+// IsSideEffectTaskInTree checks task identity and component access under the execution lock.
+// It does not invoke the task handler's validator or cache deserialized task data.
+func (n *Node) IsSideEffectTaskInTree(ctx context.Context, task *tasks.ChasmTask) (bool, error) {
+	inTree, accessible, err := n.validateSideEffectTask(ctx, task, false)
+	return inTree && accessible, err
+}
 
+// ValidateStandbySideEffectTask invokes standby validation without holding the execution
+// lock. The callback receives a reference instead of live component state. The context
+// must have a CHASM engine set, and the caller must have checked task identity under lock.
+func (n *Node) ValidateStandbySideEffectTask(
+	ctx context.Context,
+	executionKey ExecutionKey,
+	task *tasks.ChasmTask,
+	validate func(NodeBackend, Context, Component) error,
+) (bool, error) {
+	rt, err := n.lookupSideEffectTask(ctx, "ValidateStandbySideEffectTask", task)
+	if err != nil {
+		return false, err
+	}
+	var valid bool
+	err = n.invokeSideEffectTaskFn(ctx, rt, executionKey, task, validate, nil,
+		func(ctx context.Context, ref ComponentRef, attrs TaskAttributes, data any) error {
+			var err error
+			valid, err = rt.validateStandbyFn(ctx, ref, TaskInvocation{TaskAttributes: attrs, Attempt: task.Attempt}, data)
+			return err
+		})
+	return valid, err
+}
+
+func (n *Node) validateSideEffectTask(
+	ctx context.Context,
+	chasmTask *tasks.ChasmTask,
+	validateComponent bool,
+) (isTaskInTree bool, isValidByComponent bool, retErr error) {
 	taskInfo := chasmTask.Info
 	taskTypeID := taskInfo.TypeId
 	registrableTask, ok := n.registry.TaskByID(taskTypeID)
@@ -3946,6 +3983,15 @@ func (n *Node) ValidateSideEffectTask(
 
 	// Component must be hydrated before the task's validator is called.
 	validateCtx := NewContext(NewContextWithOperationIntent(ctx, OperationIntentProgress), n)
+	if !validateComponent {
+		if err := node.validateAccess(validateCtx, true); err != nil {
+			if errors.Is(err, errAccessCheckFailed) {
+				return true, false, nil
+			}
+			return false, false, err
+		}
+		return true, true, nil
+	}
 	if err := node.prepareComponentValue(validateCtx); err != nil {
 		return false, false, err
 	}
@@ -4008,11 +4054,11 @@ func (n *Node) ExecuteSideEffectTask(
 	if err != nil {
 		return err
 	}
-	return n.invokeSideEffectTaskFn(ctx, rt, executionKey, chasmTask, validate, rt.sideEffectTaskExecuteFn)
+	return n.invokeSideEffectTaskFn(ctx, rt, executionKey, chasmTask, validate, rt.validateFn, rt.sideEffectTaskExecuteFn)
 }
 
 // ExecuteSideEffectDiscardTask executes the discard handler for the given ChasmTask. This is called on standby
-// clusters when a side effect task has been pending past the discard delay, allowing custom discard behavior
+// clusters when standby validation rejects a side effect task, allowing custom discard behavior
 // (e.g., spilling activity tasks to matching).
 func (n *Node) ExecuteSideEffectDiscardTask(
 	ctx context.Context,
@@ -4024,7 +4070,7 @@ func (n *Node) ExecuteSideEffectDiscardTask(
 	if err != nil {
 		return err
 	}
-	return n.invokeSideEffectTaskFn(ctx, rt, executionKey, chasmTask, validate, rt.sideEffectTaskDiscardFn)
+	return n.invokeSideEffectTaskFn(ctx, rt, executionKey, chasmTask, validate, rt.validateFn, rt.sideEffectTaskDiscardFn)
 }
 
 func (n *Node) lookupSideEffectTask(
@@ -4059,6 +4105,7 @@ func (n *Node) invokeSideEffectTaskFn(
 	executionKey ExecutionKey,
 	chasmTask *tasks.ChasmTask,
 	validate func(NodeBackend, Context, Component) error,
+	validator validateFn,
 	taskFn func(context.Context, ComponentRef, TaskAttributes, any) error,
 ) (retErr error) {
 	taskInfo := chasmTask.Info
@@ -4097,7 +4144,7 @@ func (n *Node) invokeSideEffectTaskFn(
 		componentInitialVT:    refComponentInitialVT(taskInfo.Path, taskInfo.ComponentInitialVersionedTransition),
 
 		// Validate the Ref only once it is accessed by the task's handler.
-		validationFn: makeValidationFn(registrableTask, validate, chasmTask.Attempt, taskAttributes, taskValue),
+		validationFn: makeValidationFn(validator, validate, chasmTask.Attempt, taskAttributes, taskValue),
 	}
 
 	ctx = NewContextWithOperationIntent(ctx, OperationIntentProgress)
@@ -4136,7 +4183,7 @@ func (n *Node) ComponentByPath(
 // given validation callback to be called before the RegistrableTask's registered
 // validator callback. Intended for use to validate mutable state at access time.
 func makeValidationFn(
-	registrableTask *RegistrableTask,
+	validator validateFn,
 	validate func(NodeBackend, Context, Component) error,
 	attempt int,
 	taskAttributes TaskAttributes,
@@ -4152,8 +4199,13 @@ func makeValidationFn(
 		// Side effect's task validator is invoked inside the task handler,
 		// so the panic wrapper ExecuteSideEffectTask() will cover this case.
 
+		// Standby callbacks read component state without using the active task validator.
+		if validator == nil {
+			return nil
+		}
+
 		// Call the TaskValidator.
-		valid, err := registrableTask.validateFn(
+		valid, err := validator(
 			ctx,
 			component,
 			TaskInvocation{TaskAttributes: taskAttributes, Attempt: attempt},