coder · hugodutka · Jun 12, 2026 · Jun 18, 2026
diff --git a/coderd/x/chatd/chatstate/transitions.go b/coderd/x/chatd/chatstate/transitions.go
@@ -1344,6 +1344,7 @@ func (tx *Tx) FinishError(input FinishErrorInput) (FinishErrorResult, error) {
 // CancelRequiresActionInput configures [Tx.CancelRequiresAction].
 type CancelRequiresActionInput struct {
 	Reason string
+	Now    time.Time
 }
 
 // CancelRequiresActionResult is returned by [Tx.CancelRequiresAction].
@@ -1358,6 +1359,21 @@ func (tx *Tx) CancelRequiresAction(input CancelRequiresActionInput) (CancelRequi
 	if err != nil {
 		return CancelRequiresActionResult{}, err
 	}
+	if chat.RequiresActionDeadlineAt.Valid {
+		now := input.Now
+		if now.IsZero() {
+			now, err = tx.store.GetDatabaseNow(tx.ctx)
+			if err != nil {
+				return CancelRequiresActionResult{}, xerrors.Errorf("get database time: %w", err)
+			}
+		}
+		if now.Before(chat.RequiresActionDeadlineAt.Time) {
+			return CancelRequiresActionResult{}, newTransitionError(
+				TransitionCancelRequiresAction, from,
+				"requires-action deadline has not expired",
+			)
+		}
+	}
 	reason := input.Reason
 	if reason == "" {
 		reason = "Tool execution timed out"

diff --git a/coderd/x/chatd/chatstate/transitions_matrix_test.go b/coderd/x/chatd/chatstate/transitions_matrix_test.go
@@ -7,6 +7,7 @@ import (
 	"slices"
 	"sync"
 	"testing"
+	"time"
 
 	"github.com/google/uuid"
 	"github.com/sqlc-dev/pqtype"
@@ -256,11 +257,19 @@ func applyFinishError(t *testing.T, _ *testFixture, tx *chatstate.Tx, _ seededCh
 	return err
 }
 
-func applyCancelRequiresAction(t *testing.T, _ *testFixture, tx *chatstate.Tx, _ seededChat, _ chatstate.ExecutionState, result *transitionCaseResult) error {
+func applyCancelRequiresAction(t *testing.T, _ *testFixture, tx *chatstate.Tx, seeded seededChat, _ chatstate.ExecutionState, result *transitionCaseResult) error {
 	t.Helper()
-	var err error
+	chat, err := tx.Store().GetChatByID(tx.Ctx(), seeded.chatID)
+	if err != nil {
+		return err
+	}
+	now := time.Time{}
+	if chat.RequiresActionDeadlineAt.Valid {
+		now = chat.RequiresActionDeadlineAt.Time.Add(time.Nanosecond)
+	}
 	result.cancelRequiresAction, err = tx.CancelRequiresAction(chatstate.CancelRequiresActionInput{
 		Reason: "cancel from test",
+		Now:    now,
 	})
 	return err
 }

diff --git a/coderd/x/chatd/chatstate/transitions_test.go b/coderd/x/chatd/chatstate/transitions_test.go
@@ -1,8 +1,10 @@
 package chatstate_test
 
 import (
+	"database/sql"
 	"encoding/json"
 	"testing"
+	"time"
 
 	"github.com/google/uuid"
 	"github.com/sqlc-dev/pqtype"
@@ -361,6 +363,75 @@ func TestTransitionInputValidation(t *testing.T) {
 			})
 		}
 	})
+
+	t.Run("CancelRequiresAction_invalid_deadline", func(t *testing.T) {
+		t.Parallel()
+		for _, tc := range cancelRequiresActionDeadlineRejectCases() {
+			t.Run(tc.name, func(t *testing.T) {
+				t.Parallel()
+				runCancelRequiresActionDeadlineRejectCase(t, tc)
+			})
+		}
+	})
+}
+
+type cancelRequiresActionDeadlineRejectCase struct {
+	name     string
+	deadline sql.NullTime
+	now      time.Time
+	want     string
+}
+
+func cancelRequiresActionDeadlineRejectCases() []cancelRequiresActionDeadlineRejectCase {
+	now := time.Now().UTC()
+	return []cancelRequiresActionDeadlineRejectCase{
+		{
+			name:     "not_expired",
+			deadline: sql.NullTime{Time: now.Add(time.Minute), Valid: true},
+			now:      now,
+			want:     "requires-action deadline has not expired",
+		},
+	}
+}
+
+func runCancelRequiresActionDeadlineRejectCase(t *testing.T, tc cancelRequiresActionDeadlineRejectCase) {
+	t.Helper()
+	f := newTestFixture(t)
+	ctx := testutil.Context(t, testutil.WaitShort)
+	seeded := seedState(t, f, chatstate.StateA0)
+	require.Equal(t, chatstate.StateA0, f.classify(ctx, t, seeded.chatID))
+	require.NoError(t, f.DB.InTx(func(store database.Store) error {
+		chat, err := store.GetChatByID(ctx, seeded.chatID)
+		if err != nil {
+			return err
+		}
+		_, err = store.UpdateChatExecutionState(ctx, database.UpdateChatExecutionStateParams{
+			ID:                       chat.ID,
+			Status:                   chat.Status,
+			Archived:                 chat.Archived,
+			WorkerID:                 chat.WorkerID,
+			RunnerID:                 chat.RunnerID,
+			LastError:                chat.LastError,
+			RequiresActionDeadlineAt: tc.deadline,
+		})
+		return err
+	}, nil))
+	base := captureBaseline(ctx, t, f, seeded)
+	m := chatstate.NewChatMachine(f.DB, f.Pub, seeded.chatID)
+
+	err := m.Update(ctx, func(tx *chatstate.Tx, store database.Store) error {
+		_, cancelErr := tx.CancelRequiresAction(chatstate.CancelRequiresActionInput{Now: tc.now})
+		return cancelErr
+	})
+
+	require.Error(t, err)
+	require.ErrorIs(t, err, chatstate.ErrTransitionNotAllowed)
+	var te *chatstate.TransitionError
+	require.ErrorAs(t, err, &te)
+	require.Equal(t, chatstate.TransitionCancelRequiresAction, te.Transition)
+	require.Equal(t, chatstate.StateA0, te.From)
+	require.Contains(t, te.Reason, tc.want)
+	assertNoMutationOrPublish(ctx, t, f, seeded.chatID, base)
 }
 
 // TestSendMessageQueueCapRejectsQueueAppend seeds a chat with the

diff --git a/coderd/x/chatd/generation.go b/coderd/x/chatd/generation.go
@@ -348,7 +348,7 @@ func (s *taskStarter) StartGeneration(ctx context.Context, input chatWorkerTaskS
 	if s.server == nil {
 		return xerrors.New("chatworker: server is required")
 	}
-	machine := chatstate.NewChatMachine(s.opts.Store, s.opts.Pubsub, input.ChatID)
+	machine := chatstate.NewChatMachine(s.store, s.pubsub, input.ChatID)
 	chainModeDisabled := false
 	for {
 		locked, messages, err := loadGenerationState(ctx, machine, input)
@@ -439,7 +439,7 @@ func (s *taskStarter) StartGeneration(ctx context.Context, input chatWorkerTaskS
 				return err
 			}
 			if decision.retry {
-				s.opts.Logger.Warn(ctx, "chat generation retrying",
+				s.opts.logger.Warn(ctx, "chat generation retrying",
 					slog.F("chat_id", input.ChatID),
 					slog.F("worker_id", input.WorkerID),
 					slog.F("action", action),
@@ -556,7 +556,7 @@ func (*taskStarter) recordGenerationRetry(
 }
 
 func (s *taskStarter) waitGenerationRetry(ctx context.Context, delay time.Duration) error {
-	timer := s.opts.Clock.NewTimer(delay, "chatworker", "generation-retry")
+	timer := s.opts.clock.NewTimer(delay, "chatworker", "generation-retry")
 	defer timer.Stop()
 	select {
 	case <-timer.C:
@@ -609,7 +609,7 @@ func retryGenerationPhase[T any](ctx context.Context, starter *taskStarter, phas
 		lastErr = err
 		if attempt < generationPhaseMaxAttempts-1 {
 			delay := generationPhaseBackoff(attempt)
-			starter.opts.Logger.Warn(ctx, "chat generation phase retrying",
+			starter.opts.logger.Warn(ctx, "chat generation phase retrying",
 				slog.F("phase", phase),
 				slog.F("attempt", attempt+1),
 				slog.F("max_attempts", generationPhaseMaxAttempts),
@@ -625,7 +625,7 @@ func retryGenerationPhase[T any](ctx context.Context, starter *taskStarter, phas
 }
 
 func (s *taskStarter) waitGenerationPhaseBackoff(ctx context.Context, delay time.Duration) error {
-	timer := s.opts.Clock.NewTimer(delay, "chatworker", "generation-phase-retry")
+	timer := s.opts.clock.NewTimer(delay, "chatworker", "generation-phase-retry")
 	defer timer.Stop()
 	select {
 	case <-timer.C:
@@ -658,8 +658,8 @@ func (s *taskStarter) generateAssistant(
 		ModelConfig:          prepared.ModelConfig,
 		ProviderOptions:      prepared.ProviderOptions,
 		PublishMessagePart:   publish,
-		Logger:               s.opts.Logger,
-		Clock:                s.opts.Clock,
+		Logger:               s.opts.logger,
+		Clock:                s.opts.clock,
 		Metrics:              s.server.metrics,
 	})
 	if err != nil {
@@ -673,7 +673,7 @@ func (s *taskStarter) generateAssistant(
 		modelCallConfig:    prepared.ModelConfig,
 		step:               stepDataFromPersisted(outcome.Step),
 		toolNameToConfigID: prepared.ToolNameToConfigID,
-		logger:             s.opts.Logger,
+		logger:             s.opts.logger,
 		contentVersion:     chatprompt.CurrentContentVersion,
 	})
 	if err != nil {
@@ -715,9 +715,9 @@ func (s *taskStarter) executeLocalTools(
 		ModelProvider:      provider,
 		ModelName:          modelName,
 		PublishMessagePart: publish,
-		Logger:             s.opts.Logger,
+		Logger:             s.opts.logger,
 		Metrics:            s.server.metrics,
-		Clock:              s.opts.Clock,
+		Clock:              s.opts.clock,
 	})
 	if err != nil {
 		return err
@@ -727,7 +727,7 @@ func (s *taskStarter) executeLocalTools(
 		modelCallConfig:    prepared.ModelConfig,
 		step:               stepDataFromPersisted(outcome.Step),
 		toolNameToConfigID: prepared.ToolNameToConfigID,
-		logger:             s.opts.Logger,
+		logger:             s.opts.logger,
 		contentVersion:     chatprompt.CurrentContentVersion,
 	})
 	if err != nil {
@@ -812,7 +812,7 @@ func (s *taskStarter) persistWorkspaceContext(
 	if s.server == nil {
 		return errTaskExpectedExit
 	}
-	messages, err := s.opts.Store.GetChatMessagesByChatID(ctx, database.GetChatMessagesByChatIDParams{
+	messages, err := s.store.GetChatMessagesByChatID(ctx, database.GetChatMessagesByChatIDParams{
 		ChatID:  input.ChatID,
 		AfterID: 0,
 	})
@@ -882,14 +882,14 @@ func (s *taskStarter) beginGenerationAttempt(
 		HistoryVersion:    committed.HistoryVersion,
 		GenerationAttempt: attempt,
 	}
-	if err := s.opts.MessagePartBuffer.CreateEpisode(key); err != nil && ctx.Err() == nil {
+	if err := s.messagePartBuffer.CreateEpisode(key); err != nil && ctx.Err() == nil {
 		return 0, messagepartbuffer.Key{}, nil, nil, taskRetryableError{err: xerrors.Errorf("create message part episode: %w", err)}
 	}
 	publish := func(role codersdk.ChatMessageRole, part codersdk.ChatMessagePart) {
-		_ = s.opts.MessagePartBuffer.AddPart(key, role, part)
+		_ = s.messagePartBuffer.AddPart(key, role, part)
 	}
 	closeEpisode := func() {
-		_ = s.opts.MessagePartBuffer.CloseEpisode(key)
+		_ = s.messagePartBuffer.CloseEpisode(key)
 	}
 	return attempt, key, publish, closeEpisode, nil
 }
@@ -935,7 +935,7 @@ func (s *taskStarter) commitGenerationStep(
 	if err != nil {
 		return normalizeTaskTransitionError(err, "commit generation step")
 	}
-	s.routeStateHint(ctx, stateUpdateFromChat(committed))
+	s.sideEffects.RouteStateHint(ctx, stateUpdateFromChat(committed))
 	return s.afterGenerationOutcome(ctx, generationOutcome{
 		Chat:             committed,
 		Kind:             runnerActionKind(kind),
@@ -1040,7 +1040,7 @@ func (s *taskStarter) finishGenerationTurn(
 	}); err != nil {
 		return err
 	}
-	s.routeStateHint(ctx, stateUpdateFromChat(committed))
+	s.sideEffects.RouteStateHint(ctx, stateUpdateFromChat(committed))
 	return nil
 }
 
@@ -1056,7 +1056,7 @@ func (s *taskStarter) finishGenerationError(
 	// Log the unsanitized cause before persisting so administrators can
 	// diagnose the failure even when the classified user-facing message
 	// omits the underlying reason, and even if the persist below fails.
-	s.opts.Logger.Warn(ctx, "chat generation failed",
+	s.opts.logger.Warn(ctx, "chat generation failed",
 		slog.F("chat_id", input.ChatID),
 		slog.F("worker_id", input.WorkerID),
 		slog.F("generation_attempt", input.GenerationAttempt),

diff --git a/coderd/x/chatd/generation_retry_internal_test.go b/coderd/x/chatd/generation_retry_internal_test.go
@@ -59,7 +59,7 @@ func TestRetryGenerationPhase(t *testing.T) {
 		defer timerTrap.Close()
 		sink := testutil.NewFakeSink(t)
 		starter := newGenerationPhaseTestStarter(t, clock)
-		starter.opts.Logger = sink.Logger()
+		starter.opts.logger = sink.Logger()
 		ctx := testutil.Context(t, testutil.WaitLong)
 		calls := 0
 		done := make(chan phaseRetryResult[string], 1)
@@ -172,10 +172,10 @@ type phaseRetryResult[T any] struct {
 func newGenerationPhaseTestStarter(t *testing.T, clock quartz.Clock) *taskStarter {
 	t.Helper()
 	require.NotNil(t, clock)
-	return &taskStarter{opts: chatWorkerOptions{
-		Clock:                   clock,
-		Logger:                  testutil.NewFakeSink(t).Logger(),
-		TaskRetryInitialBackoff: time.Millisecond,
-		TaskRetryMaxBackoff:     time.Millisecond,
+	return &taskStarter{opts: taskStarterOptions{
+		clock:                   clock,
+		logger:                  testutil.NewFakeSink(t).Logger(),
+		taskRetryInitialBackoff: time.Millisecond,
+		taskRetryMaxBackoff:     time.Millisecond,
 	}}
 }
diff --git a/coderd/x/chatd/mock_task_side_effects_internal_test.go b/coderd/x/chatd/mock_task_side_effects_internal_test.go
diff --git a/coderd/x/chatd/mockgen_internal_test.go b/coderd/x/chatd/mockgen_internal_test.go
@@ -0,0 +1,3 @@
+package chatd
+
+//go:generate go tool mockgen -source=tasks.go -destination ./mock_task_side_effects_internal_test.go -package chatd -mock_names taskSideEffects=MockTaskSideEffects taskSideEffects
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,3 @@
		package chatd

		//go:generate go tool mockgen -source=tasks.go -destination ./mock_task_side_effects_internal_test.go -package chatd -mock_names taskSideEffects=MockTaskSideEffects taskSideEffects