@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/internal/core/schedule/scheduler_control_test.go

@@ -0,0 +1,808 @@
+package schedule
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/robfig/cron/v3"
+	"go.uber.org/zap"
+)
+
+type fakeRunRecorder struct {
+	mu          sync.Mutex
+	nextRunID   int64
+	starts      []TaskRunStart
+	events      []TaskRunEventRecord
+	completions []TaskRunCompletion
+}
+
+func (r *fakeRunRecorder) UpsertTask(context.Context, RegisteredTask) error {
+	return nil
+}
+
+func (r *fakeRunRecorder) StartRun(_ context.Context, start TaskRunStart) (int64, error) {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.nextRunID++
+	r.starts = append(r.starts, start)
+	return r.nextRunID, nil
+}
+
+func (r *fakeRunRecorder) RecordRunEvent(_ context.Context, event TaskRunEventRecord) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.events = append(r.events, event)
+	return nil
+}
+
+func (r *fakeRunRecorder) CompleteRun(_ context.Context, completion TaskRunCompletion) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	r.completions = append(r.completions, completion)
+	return nil
+}
+
+type fakeControlStore struct {
+	control       TaskControl
+	registrations []TaskControlRegistration
+}
+
+func (s *fakeControlStore) RegisterTaskControl(_ context.Context, registration TaskControlRegistration) (*TaskControl, error) {
+	s.registrations = append(s.registrations, registration)
+	if s.control.Pattern == "" {
+		s.control.Pattern = registration.Pattern
+	}
+	s.control.TaskName = registration.TaskName
+	return &s.control, nil
+}
+
+func TestSchedulerRegistersDeclaredControlDefaults(t *testing.T) {
+	controls := &fakeControlStore{}
+	scheduler := New(zap.NewNop())
+	scheduler.SetControlStore(controls)
+
+	options := TaskRegistrationOptions{
+		DisplayName:         "Checkout recovery",
+		Description:         "Recovers uncertain checkout provider operations",
+		ConcurrencyPolicy:   ConcurrencyPolicyForbid,
+		ManualRunEnabled:    true,
+		MaxRuntimeSeconds:   28,
+		RetryMaxAttempts:    0,
+		RetryBackoffSeconds: 60,
+	}
+	if err := scheduler.RegisterCronWithOptions("checkout.recover", "0 * * * * *", options, func(context.Context) error {
+		return nil
+	}); err != nil {
+		t.Fatalf("RegisterCronWithOptions() error = %v", err)
+	}
+	if len(controls.registrations) != 1 {
+		t.Fatalf("registrations = %#v, want one", controls.registrations)
+	}
+	registration := controls.registrations[0]
+	if registration.DisplayName != options.DisplayName || registration.Description != options.Description {
+		t.Fatalf("registration identity = %#v, want %#v", registration, options)
+	}
+	if registration.ConcurrencyPolicy != options.ConcurrencyPolicy || !registration.ManualRunEnabled || registration.MaxRuntimeSeconds != 28 || registration.RetryMaxAttempts != 0 || registration.RetryBackoffSeconds != 60 {
+		t.Fatalf("registration policy = %#v, want declared defaults", registration)
+	}
+}
+
+func TestSchedulerRejectsInvalidRegistrationOptions(t *testing.T) {
+	scheduler := New(zap.NewNop())
+	err := scheduler.RegisterCronWithOptions("checkout.invalid", "0 * * * * *", TaskRegistrationOptions{
+		DisplayName:         "Checkout invalid",
+		ConcurrencyPolicy:   ConcurrencyPolicyForbid,
+		ManualRunEnabled:    true,
+		MaxRuntimeSeconds:   28,
+		RetryMaxAttempts:    taskRetryMaxAttemptsLimit + 1,
+		RetryBackoffSeconds: 60,
+	}, func(context.Context) error { return nil })
+	if err == nil {
+		t.Fatal("RegisterCronWithOptions() accepted an invalid retry policy")
+	}
+}
+
+func (s *fakeControlStore) GetTaskControl(context.Context, string) (*TaskControl, error) {
+	return &s.control, nil
+}
+
+func (s *fakeControlStore) ListTaskControls(context.Context) ([]TaskControl, error) {
+	return []TaskControl{s.control}, nil
+}
+
+type fakeDispatchStore struct {
+	mu                sync.Mutex
+	dispatches        []TaskDispatch
+	completed         []TaskRunResult
+	heartbeatTokens   []string
+	completionTokens  []string
+	cancel            bool
+	cancelRequestedAt *time.Time
+}
+
+func (s *fakeDispatchStore) ClaimPendingDispatches(context.Context, string, int, time.Time) ([]TaskDispatch, error) {
+	result := s.dispatches
+	s.dispatches = nil
+	return result, nil
+}
+
+func (s *fakeDispatchStore) HeartbeatDispatch(_ context.Context, _ int64, _ int64, _ string, claimToken string, _ time.Time) (*DispatchLeaseState, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.heartbeatTokens = append(s.heartbeatTokens, claimToken)
+	return &DispatchLeaseState{CancelRequested: s.cancel, CancelRequestedAt: s.cancelRequestedAt, CancelReason: "operator canceled"}, nil
+}
+
+func (s *fakeDispatchStore) CompleteDispatch(_ context.Context, _ int64, _ int64, claimToken string, result TaskRunResult, _ time.Time) error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.completed = append(s.completed, result)
+	s.completionTokens = append(s.completionTokens, claimToken)
+	return nil
+}
+
+func (s *fakeDispatchStore) snapshot() ([]TaskRunResult, []string, []string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	completed := append([]TaskRunResult(nil), s.completed...)
+	heartbeatTokens := append([]string(nil), s.heartbeatTokens...)
+	completionTokens := append([]string(nil), s.completionTokens...)
+	return completed, heartbeatTokens, completionTokens
+}
+
+type fakeJobObserver struct {
+	failed    int
+	succeeded int
+}
+
+func (o *fakeJobObserver) JobSucceeded(string, time.Time) {
+	o.succeeded++
+}
+
+func (o *fakeJobObserver) JobFailed(string) {
+	o.failed++
+}
+
+type runOnceSchedule struct {
+	used atomic.Bool
+}
+
+func (s *runOnceSchedule) Next(time.Time) time.Time {
+	if s.used.Swap(true) {
+		return time.Time{}
+	}
+	return time.Now()
+}
+
+func TestSchedulerSkipsPausedTask(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:     ControlStatusPaused,
+		ManualRunEnabled:  true,
+		ConcurrencyPolicy: ConcurrencyPolicyForbid,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	called := 0
+	if err := scheduler.RegisterCron("test.paused", "0 */5 * * * *", func(context.Context) error {
+		called++
+		return nil
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	result, err := scheduler.ExecuteTask(context.Background(), "test.paused", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil {
+		t.Fatalf("execute task: %v", err)
+	}
+	if !result.Skipped || result.Status != RunStatusSkipped {
+		t.Fatalf("expected skipped result, got %+v", result)
+	}
+	if called != 0 {
+		t.Fatalf("paused handler was called %d times", called)
+	}
+	if len(recorder.completions) != 1 || recorder.completions[0].Status != RunStatusSkipped {
+		t.Fatalf("expected skipped completion, got %+v", recorder.completions)
+	}
+}
+
+func TestSchedulerProcessesManualDispatch(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:     ControlStatusActive,
+		ManualRunEnabled:  true,
+		ConcurrencyPolicy: ConcurrencyPolicyForbid,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	called := 0
+	if err := scheduler.RegisterCron("test.run", "0 */5 * * * *", func(context.Context) error {
+		called++
+		return nil
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	dispatches := &fakeDispatchStore{dispatches: []TaskDispatch{{
+		ID:           7,
+		TaskName:     "test.run",
+		DispatchType: "run_now",
+		Reason:       "manual verification",
+	}}}
+	if err := scheduler.ProcessDispatches(context.Background(), dispatches, "worker", 10); err != nil {
+		t.Fatalf("process dispatches: %v", err)
+	}
+	if called != 1 {
+		t.Fatalf("expected handler called once, got %d", called)
+	}
+	completed, _, _ := dispatches.snapshot()
+	if len(completed) != 1 || completed[0].Status != RunStatusSucceeded {
+		t.Fatalf("expected succeeded dispatch, got %+v", completed)
+	}
+}
+
+func TestSchedulerCancelsManualDispatchBeforeHandler(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	observer := &fakeJobObserver{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:     ControlStatusActive,
+		ManualRunEnabled:  true,
+		ConcurrencyPolicy: ConcurrencyPolicyForbid,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetObserver(observer)
+	scheduler.SetControlStore(controls)
+
+	called := 0
+	if err := scheduler.RegisterCron("test.cancel", "0 */5 * * * *", func(context.Context) error {
+		called++
+		return nil
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	cancelRequestedAt := time.Date(2026, 5, 14, 10, 0, 0, 0, time.UTC)
+	dispatches := &fakeDispatchStore{
+		cancel:            true,
+		cancelRequestedAt: &cancelRequestedAt,
+		dispatches: []TaskDispatch{{
+			ID:           9,
+			TaskName:     "test.cancel",
+			DispatchType: "run_now",
+		}},
+	}
+	if err := scheduler.ProcessDispatches(context.Background(), dispatches, "worker", 10); err != nil {
+		t.Fatalf("process dispatches: %v", err)
+	}
+	if called != 0 {
+		t.Fatalf("canceled handler was called %d times", called)
+	}
+	completed, _, _ := dispatches.snapshot()
+	if len(completed) != 1 || completed[0].Status != RunStatusCanceled || !completed[0].Canceled {
+		t.Fatalf("expected canceled dispatch, got %+v", completed)
+	}
+	if completed[0].Error != "operator canceled" {
+		t.Fatalf("expected cancel reason, got %+v", completed[0])
+	}
+	if completed[0].CancelRequestedAt == nil || !completed[0].CancelRequestedAt.Equal(cancelRequestedAt) {
+		t.Fatalf("expected cancel requested time, got %+v", completed[0].CancelRequestedAt)
+	}
+	if len(recorder.completions) != 1 || recorder.completions[0].CancelRequestedAt == nil || !recorder.completions[0].CancelRequestedAt.Equal(cancelRequestedAt) {
+		t.Fatalf("expected persisted cancel requested time, got %+v", recorder.completions)
+	}
+	if observer.failed != 0 || observer.succeeded != 0 {
+		t.Fatalf("cancel should not change success/failure metrics, got %+v", observer)
+	}
+}
+
+func TestSchedulerPassesCancellationContextToHandler(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:     ControlStatusActive,
+		ManualRunEnabled:  true,
+		ConcurrencyPolicy: ConcurrencyPolicyForbid,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	observedCancellation := false
+	if err := scheduler.RegisterCron("test.context_cancel", "0 */5 * * * *", func(handlerCtx context.Context) error {
+		cancel()
+		<-handlerCtx.Done()
+		observedCancellation = errors.Is(handlerCtx.Err(), context.Canceled)
+		return handlerCtx.Err()
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	result, err := scheduler.ExecuteTask(ctx, "test.context_cancel", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil {
+		t.Fatalf("execute task: %v", err)
+	}
+	if !observedCancellation {
+		t.Fatalf("handler did not observe context cancellation")
+	}
+	if result.Status != RunStatusCanceled || !result.Canceled {
+		t.Fatalf("expected canceled result, got %+v", result)
+	}
+	if len(recorder.completions) != 1 || recorder.completions[0].Status != RunStatusCanceled {
+		t.Fatalf("expected canceled completion, got %+v", recorder.completions)
+	}
+}
+
+func TestSchedulerStopCancelsCronHandlerContext(t *testing.T) {
+	scheduler := New(zap.NewNop())
+	started := make(chan context.Context, 1)
+	finished := make(chan error, 1)
+	handler := func(handlerCtx context.Context) error {
+		started <- handlerCtx
+		<-handlerCtx.Done()
+		finished <- handlerCtx.Err()
+		return handlerCtx.Err()
+	}
+	if err := scheduler.RegisterCron("test.stop_cancel", "@every 1h", handler); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	scheduler.cron.Schedule(&runOnceSchedule{}, cron.FuncJob(scheduler.wrapTask("test.stop_cancel", handler)))
+	scheduler.Start()
+	defer scheduler.Stop()
+
+	var handlerCtx context.Context
+	select {
+	case handlerCtx = <-started:
+	case <-time.After(time.Second):
+		t.Fatalf("cron handler did not start")
+	}
+	if handlerCtx.Done() == nil {
+		t.Fatalf("expected cancellable handler context")
+	}
+	if err := handlerCtx.Err(); err != nil {
+		t.Fatalf("handler context canceled before stop: %v", err)
+	}
+
+	stopped := make(chan struct{})
+	go func() {
+		scheduler.Stop()
+		close(stopped)
+	}()
+	select {
+	case err := <-finished:
+		if !errors.Is(err, context.Canceled) {
+			t.Fatalf("expected context.Canceled, got %v", err)
+		}
+	case <-time.After(time.Second):
+		t.Fatalf("cron handler did not observe stop cancellation")
+	}
+	select {
+	case <-stopped:
+	case <-time.After(time.Second):
+		t.Fatalf("scheduler stop did not finish after handler cancellation")
+	}
+}
+
+func TestSchedulerPassesDispatchClaimToken(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:     ControlStatusActive,
+		ManualRunEnabled:  true,
+		ConcurrencyPolicy: ConcurrencyPolicyForbid,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	if err := scheduler.RegisterCron("test.claim_token", "0 */5 * * * *", func(context.Context) error {
+		return nil
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	dispatches := &fakeDispatchStore{dispatches: []TaskDispatch{{
+		ID:           17,
+		TaskName:     "test.claim_token",
+		DispatchType: "run_now",
+		ClaimToken:   "claim-token-17",
+	}}}
+	if err := scheduler.ProcessDispatches(context.Background(), dispatches, "worker", 10); err != nil {
+		t.Fatalf("process dispatches: %v", err)
+	}
+	completed, heartbeatTokens, completionTokens := dispatches.snapshot()
+	if len(completed) != 1 || completed[0].Status != RunStatusSucceeded {
+		t.Fatalf("expected succeeded dispatch, got %+v", completed)
+	}
+	if len(heartbeatTokens) == 0 {
+		t.Fatalf("expected heartbeat token")
+	}
+	for i := range heartbeatTokens {
+		if heartbeatTokens[i] != "claim-token-17" {
+			t.Fatalf("heartbeat token %d = %q", i, heartbeatTokens[i])
+		}
+	}
+	if len(completionTokens) != 1 || completionTokens[0] != "claim-token-17" {
+		t.Fatalf("completion tokens = %+v", completionTokens)
+	}
+}
+
+func TestSchedulerRecordsRunMetadataSnapshot(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		Pattern:             "0 */10 * * * *",
+		Timezone:            "Asia/Shanghai",
+		ControlStatus:       ControlStatusActive,
+		ManualRunEnabled:    true,
+		ConcurrencyPolicy:   ConcurrencyPolicyForbid,
+		MaxRuntimeSeconds:   120,
+		RetryMaxAttempts:    2,
+		RetryBackoffSeconds: 5,
+		DefinitionRevision:  7,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	if err := scheduler.RegisterCron("test.metadata", "0 */5 * * * *", func(context.Context) error {
+		return nil
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+
+	operatorID := int64(42)
+	result, err := scheduler.ExecuteTask(context.Background(), "test.metadata", TaskRunOptions{
+		Trigger:        RunTriggerManualRun,
+		DispatchID:     99,
+		CorrelationID:  "corr-run-1",
+		OperatorUserID: &operatorID,
+		Reason:         "manual audit",
+		Runtime:        "worker-a",
+		Metadata: map[string]any{
+			"force": true,
+		},
+	})
+	if err != nil {
+		t.Fatalf("execute task: %v", err)
+	}
+	if result.Status != RunStatusSucceeded {
+		t.Fatalf("expected succeeded result, got %+v", result)
+	}
+	if len(recorder.starts) != 1 {
+		t.Fatalf("expected one start record, got %+v", recorder.starts)
+	}
+	startMetadata := recorder.starts[0].Metadata
+	if startMetadata["schema_version"] != taskRunMetadataSchemaVersion {
+		t.Fatalf("unexpected schema version: %+v", startMetadata)
+	}
+	assertMetadataValue(t, metadataSection(t, startMetadata, "task"), "name", "test.metadata")
+	assertMetadataValue(t, metadataSection(t, startMetadata, "trigger"), "correlation_id", "corr-run-1")
+	assertMetadataValue(t, metadataSection(t, startMetadata, "runtime"), "name", "worker-a")
+	assertMetadataValue(t, metadataSection(t, startMetadata, "control"), "status", string(ControlStatusActive))
+	assertMetadataValue(t, metadataSection(t, startMetadata, "control"), "definition_revision", int64(7))
+	assertMetadataValue(t, metadataSection(t, startMetadata, "input"), "force", true)
+	if len(recorder.completions) != 1 {
+		t.Fatalf("expected one completion record, got %+v", recorder.completions)
+	}
+	assertMetadataValue(t, metadataSection(t, recorder.completions[0].Metadata, "trigger"), "dispatch_id", int64(99))
+	if !hasRecordedEvent(recorder.events, RunEventPolicyEvaluated) {
+		t.Fatalf("expected policy event, got %+v", recorder.events)
+	}
+	if !hasRecordedEvent(recorder.events, RunEventAttemptStarted) || !hasRecordedEvent(recorder.events, RunEventAttemptSucceeded) {
+		t.Fatalf("expected attempt events, got %+v", recorder.events)
+	}
+}
+
+// TestSchedulerStopCancelsCallbackContext 验证 Stop() 会 cancel executionCtx，
+// in-flight callback 通过 ctx.Done() 提前退出。
+func TestSchedulerStopCancelsCallbackContext(t *testing.T) {
+	scheduler := New(zap.NewNop())
+
+	started := make(chan struct{}, 1)
+	exited := make(chan error, 1)
+
+	// ctx-aware callback 阻塞等待 ctx.Done()，验证 Stop() 能把 executionCtx 传到 in-flight callback 并立即取消。
+	if err := scheduler.RegisterCron("test.ctx_cancel", "*/1 * * * * *", func(ctx context.Context) error {
+		select {
+		case started <- struct{}{}:
+		default:
+		}
+		<-ctx.Done()
+		exited <- ctx.Err()
+		return ctx.Err()
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+
+	// ManualRun 触发不依赖 cron tick，更稳定地测 ctx 传递路径。
+	go func() {
+		_, _ = scheduler.ExecuteTask(scheduler.executionCtx, "test.ctx_cancel", TaskRunOptions{Trigger: RunTriggerManualRun})
+	}()
+
+	select {
+	case <-started:
+	case <-time.After(2 * time.Second):
+		t.Fatalf("callback did not start within 2s")
+	}
+
+	// Stop() 后 callback 应立即收到 ctx.Done()。
+	scheduler.Stop()
+
+	select {
+	case ctxErr := <-exited:
+		if !errors.Is(ctxErr, context.Canceled) {
+			t.Fatalf("expected context.Canceled, got %v", ctxErr)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatalf("callback did not exit within 2s after Stop()")
+	}
+}
+
+func TestSchedulerRetriesFailedTask(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:       ControlStatusActive,
+		ManualRunEnabled:    true,
+		ConcurrencyPolicy:   ConcurrencyPolicyForbid,
+		RetryMaxAttempts:    1,
+		RetryBackoffSeconds: 1,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	called := 0
+	if err := scheduler.RegisterCron("test.retry", "0 */5 * * * *", func(context.Context) error {
+		called++
+		if called == 1 {
+			return errors.New("transient failure")
+		}
+		return nil
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	result, err := scheduler.ExecuteTask(context.Background(), "test.retry", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil {
+		t.Fatalf("execute task: %v", err)
+	}
+	if result.Status != RunStatusSucceeded {
+		t.Fatalf("expected succeeded result, got %+v", result)
+	}
+	if called != 2 {
+		t.Fatalf("expected handler called twice, got %d", called)
+	}
+	if !hasRecordedEvent(recorder.events, RunEventRetrying) {
+		t.Fatalf("expected retrying event, got %+v", recorder.events)
+	}
+	if countRecordedEvents(recorder.events, RunEventAttemptStarted) != 2 {
+		t.Fatalf("expected two attempt start events, got %+v", recorder.events)
+	}
+	if !hasRecordedEvent(recorder.events, RunEventAttemptFailed) || !hasRecordedEvent(recorder.events, RunEventAttemptSucceeded) {
+		t.Fatalf("expected attempt outcome events, got %+v", recorder.events)
+	}
+}
+
+func TestSchedulerTreatsRunSkippedErrorAsNonRetryable(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:       ControlStatusActive,
+		ManualRunEnabled:    true,
+		ConcurrencyPolicy:   ConcurrencyPolicyForbid,
+		RetryMaxAttempts:    3,
+		RetryBackoffSeconds: 1,
+	}}
+	observer := &fakeJobObserver{}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+	scheduler.SetObserver(observer)
+
+	called := 0
+	if err := scheduler.RegisterCron("test.typed_skip", "0 */5 * * * *", func(context.Context) error {
+		called++
+		return RunSkippedError{Reason: "no due work"}
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	result, err := scheduler.ExecuteTask(context.Background(), "test.typed_skip", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil {
+		t.Fatalf("execute task: %v", err)
+	}
+	if result.Status != RunStatusSkipped || !result.Skipped || result.SkipReason != "no due work" {
+		t.Fatalf("typed skip result = %#v", result)
+	}
+	if called != 1 {
+		t.Fatalf("handler calls = %d, want 1", called)
+	}
+	if hasRecordedEvent(recorder.events, RunEventAttemptFailed) || hasRecordedEvent(recorder.events, RunEventRetrying) {
+		t.Fatalf("typed skip emitted failure/retry events: %#v", recorder.events)
+	}
+	if !hasRecordedEvent(recorder.events, RunEventSkipped) {
+		t.Fatalf("typed skip event missing: %#v", recorder.events)
+	}
+	if observer.failed != 0 || observer.succeeded != 0 {
+		t.Fatalf("typed skip affected success/failure metrics: %#v", observer)
+	}
+	task, ok := scheduler.GetTask("test.typed_skip")
+	if !ok || task.ErrorCount != 0 || task.RunCount != 1 {
+		t.Fatalf("typed skip task summary = %#v, ok=%v", task, ok)
+	}
+}
+
+func TestSchedulerInjectsCurrentRunEventReporter(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:       ControlStatusActive,
+		ManualRunEnabled:    true,
+		ConcurrencyPolicy:   ConcurrencyPolicyForbid,
+		RetryBackoffSeconds: 1,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	if err := scheduler.RegisterCron("test.progress", "0 */5 * * * *", func(ctx context.Context) error {
+		return ReportRunEvent(ctx, TaskRunEvent{
+			EventType: RunEventProgress,
+			Stage:     "scan",
+			Message:   "Scan completed",
+			Payload:   map[string]any{"scanned": 3},
+		})
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	result, err := scheduler.ExecuteTask(context.Background(), "test.progress", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil || result.Status != RunStatusSucceeded {
+		t.Fatalf("execute task result = %#v, error = %v", result, err)
+	}
+	found := false
+	for _, event := range recorder.events {
+		if event.EventType == RunEventProgress {
+			found = true
+			if event.RunID != result.RunID {
+				t.Fatalf("progress run ID = %d, want %d", event.RunID, result.RunID)
+			}
+		}
+	}
+	if !found {
+		t.Fatalf("progress event missing: %#v", recorder.events)
+	}
+}
+
+func TestSchedulerFailsRuntimeExceededTask(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:       ControlStatusActive,
+		ManualRunEnabled:    true,
+		ConcurrencyPolicy:   ConcurrencyPolicyForbid,
+		MaxRuntimeSeconds:   1,
+		RetryBackoffSeconds: 1,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	observedDeadline := false
+	if err := scheduler.RegisterCron("test.runtime_exceeded", "0 */5 * * * *", func(ctx context.Context) error {
+		<-ctx.Done()
+		observedDeadline = errors.Is(ctx.Err(), context.DeadlineExceeded)
+		return RunSkippedError{Reason: "work became unnecessary"}
+	}); err != nil {
+		t.Fatalf("register cron: %v", err)
+	}
+	result, err := scheduler.ExecuteTask(context.Background(), "test.runtime_exceeded", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil {
+		t.Fatalf("execute task: %v", err)
+	}
+	if !observedDeadline {
+		t.Fatalf("handler did not observe runtime deadline")
+	}
+	if result.Status != RunStatusFailed || result.Canceled {
+		t.Fatalf("expected failed timeout result, got %+v", result)
+	}
+	if result.Error != ErrTaskRuntimeExceeded.Error() {
+		t.Fatalf("expected runtime exceeded error, got %+v", result)
+	}
+	if len(recorder.completions) != 1 || recorder.completions[0].Status != RunStatusFailed {
+		t.Fatalf("expected failed completion, got %+v", recorder.completions)
+	}
+	if recorder.completions[0].Error != ErrTaskRuntimeExceeded.Error() {
+		t.Fatalf("expected timeout completion error, got %+v", recorder.completions[0])
+	}
+	if !hasRecordedEvent(recorder.events, RunEventRuntimeExceeded) {
+		t.Fatalf("expected runtime exceeded event, got %+v", recorder.events)
+	}
+	if hasRecordedEvent(recorder.events, RunEventSkipped) {
+		t.Fatalf("runtime timeout must win over typed skip, got %+v", recorder.events)
+	}
+}
+
+func TestSchedulerSanitizesTaskErrorAndPanic(t *testing.T) {
+	recorder := &fakeRunRecorder{}
+	controls := &fakeControlStore{control: TaskControl{
+		ControlStatus:     ControlStatusActive,
+		ManualRunEnabled:  true,
+		ConcurrencyPolicy: ConcurrencyPolicyForbid,
+	}}
+	scheduler := New(zap.NewNop())
+	scheduler.SetRunRecorder(recorder)
+	scheduler.SetControlStore(controls)
+
+	rawPassword := "raw-password-marker"
+	rawToken := "raw-token-marker"
+	if err := scheduler.RegisterCron("test.sanitize_error", "0 */5 * * * *", func(context.Context) error {
+		return fmt.Errorf("provider failed password=%s token=%s", rawPassword, rawToken)
+	}); err != nil {
+		t.Fatalf("register error task: %v", err)
+	}
+	result, err := scheduler.ExecuteTask(context.Background(), "test.sanitize_error", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil {
+		t.Fatalf("execute error task: %v", err)
+	}
+	if result.Status != RunStatusFailed {
+		t.Fatalf("expected failed result, got %+v", result)
+	}
+
+	if err := scheduler.RegisterCron("test.sanitize_panic", "0 */5 * * * *", func(context.Context) error {
+		panic(fmt.Sprintf("panic password=%s token=%s", rawPassword, rawToken))
+	}); err != nil {
+		t.Fatalf("register panic task: %v", err)
+	}
+	result, err = scheduler.ExecuteTask(context.Background(), "test.sanitize_panic", TaskRunOptions{Trigger: RunTriggerManualRun})
+	if err != nil {
+		t.Fatalf("execute panic task: %v", err)
+	}
+	if result.Status != RunStatusFailed {
+		t.Fatalf("expected failed panic result, got %+v", result)
+	}
+	if len(recorder.completions) != 2 {
+		t.Fatalf("expected two completions, got %+v", recorder.completions)
+	}
+	if recorder.completions[1].Error != "task panic: string" {
+		t.Fatalf("expected sanitized panic category, got %+v", recorder.completions[1])
+	}
+	persisted := fmt.Sprintf("%+v %+v", recorder.completions, recorder.events)
+	for _, raw := range []string{rawPassword, rawToken} {
+		if strings.Contains(persisted, raw) {
+			t.Fatalf("persisted sensitive value %q in %s", raw, persisted)
+		}
+	}
+	if !strings.Contains(persisted, "[REDACTED]") {
+		t.Fatalf("expected redacted error payload, got %s", persisted)
+	}
+}
+
+func metadataSection(t *testing.T, metadata map[string]any, key string) map[string]any {
+	t.Helper()
+	value, ok := metadata[key].(map[string]any)
+	if !ok {
+		t.Fatalf("metadata section %q missing: %+v", key, metadata)
+	}
+	return value
+}
+
+func assertMetadataValue(t *testing.T, metadata map[string]any, key string, expected any) {
+	t.Helper()
+	if metadata[key] != expected {
+		t.Fatalf("metadata %q expected %v, got %v in %+v", key, expected, metadata[key], metadata)
+	}
+}
+
+func hasRecordedEvent(events []TaskRunEventRecord, eventType RunEventType) bool {
+	return countRecordedEvents(events, eventType) > 0
+}
+
+func countRecordedEvents(events []TaskRunEventRecord, eventType RunEventType) int {
+	count := 0
+	for _, event := range events {
+		if event.EventType == eventType {
+			count++
+		}
+	}
+	return count
+}