Method ClearTaskBlock

internal/task/block_service.go:266–313

ClearTaskBlock clears one open task block through the service-owned transition.

(
	ctx context.Context,
	taskID string,
	blockID string,
	note string,
	actor ActorContext,
)

// ClearTaskBlock clears one open task block through the service-owned transition.
func (m *Service) ClearTaskBlock(
	ctx context.Context,
	taskID string,
	blockID string,
	note string,
	actor ActorContext,
) (TaskBlock, error) {
	if err := requireWriteAuthority(actor); err != nil {
		return TaskBlock{}, err
	}
	normalizedTaskID := strings.TrimSpace(taskID)
	normalizedBlockID := strings.TrimSpace(blockID)
	if normalizedTaskID == "" {
		return TaskBlock{}, fmt.Errorf("%w: task_block.task_id is required", ErrValidation)
	}
	if normalizedBlockID == "" {
		return TaskBlock{}, fmt.Errorf("%w: task_block.id is required", ErrValidation)
	}
	normalizedNote := strings.TrimSpace(note)
	if err := rejectTaskSecretText("task_block.clear_note", normalizedNote); err != nil {
		return TaskBlock{}, err
	}
	if err := m.requireAgentSessionTaskLease(ctx, normalizedTaskID, actor); err != nil {
		return TaskBlock{}, err
	}

	cleared, err := m.store.ClearTaskBlock(ctx, ClearTaskBlockMutation{
		TaskID:    normalizedTaskID,
		BlockID:   normalizedBlockID,
		ClearedBy: actor.Actor,
		ClearedAt: m.now().UTC(),
		ClearNote: normalizedNote,
	})
	if err != nil {
		return TaskBlock{}, err
	}
	reconciled, err := m.reconcileTaskCascade(ctx, cleared.TaskID)
	if err != nil {
		return TaskBlock{}, err
	}
	m.recordTaskBlockCleared(ctx, cleared, reconciled, actor)
	m.dispatchTaskUnblocked(ctx, cleared, reconciled, actor)
	m.autoEnqueueReadyTaskDetached(ctx, cleared.TaskID, autoEnqueueTrigger{
		Kind: autoEnqueueTriggerBlockClear,
		Ref:  cleared.ID,
	}, actor)
	return cleared, nil
}

// RecoverTask clears task-level needs_attention escalation through the service-owned transition.
func (m *Service) RecoverTask(ctx context.Context, id string, note string, actor ActorContext) (*Task, error) {