package engine import ( "context" "errors" "expvar" "testing" ) // fakeDecisionStore lets tests pre-populate decisions and watch writes. type fakeDecisionStore struct { byKey map[string][]DecisionInfo cleared map[string]int64 recordErr error clearedErr error listErr error } func newFakeDecisionStore() *fakeDecisionStore { return &fakeDecisionStore{byKey: map[string][]DecisionInfo{}, cleared: map[string]int64{}} } func dkey(taskID, stepID string) string { return taskID + "|" + stepID } func (f *fakeDecisionStore) ListStepDecisions(_ context.Context, taskID, stepID string) ([]DecisionInfo, error) { if f.listErr != nil { return nil, f.listErr } return f.byKey[dkey(taskID, stepID)], nil } func (f *fakeDecisionStore) RecordStepDecision(_ context.Context, d DecisionInfo) error { if f.recordErr != nil { return f.recordErr } k := dkey(d.TaskID, d.StepID) f.byKey[k] = append(f.byKey[k], d) return nil } func (f *fakeDecisionStore) ClearStepDecisions(_ context.Context, taskID, stepID string) (int64, error) { if f.clearedErr != nil { return 0, f.clearedErr } k := dkey(taskID, stepID) n := int64(len(f.byKey[k])) delete(f.byKey, k) f.cleared[k] += n return n, nil } // stepStoreForQuorum is a TransitionStore where the step holds a single // transition action gated by a quorum guard. type stepStoreForQuorum struct { state MachineState step StepSpec next StepSpec applied map[string]bool } func (s *stepStoreForQuorum) LoadState(_ context.Context, _, _ string) (MachineState, error) { return s.state, nil } func (s *stepStoreForQuorum) LoadStep(_ context.Context, _, _ string) (StepSpec, error) { return s.step, nil } func (s *stepStoreForQuorum) LoadNextStep(_ context.Context, _ string, _ int) (StepSpec, error) { return s.next, nil } func (s *stepStoreForQuorum) LoadPreviousStep(_ context.Context, _ string, _ int) (StepSpec, error) { return StepSpec{}, nil } func (s *stepStoreForQuorum) ApplyTransition(_ context.Context, _, _, _, _ string, _ Trigger) error { return nil } func (s *stepStoreForQuorum) ApplyTransitionIfAtStep( _ context.Context, _, _, expectedStepID, toStepID string, _ Trigger, ) (bool, error) { if s.state.CurrentStepID != expectedStepID { return false, nil } s.state.CurrentStepID = toStepID return true, nil } func (s *stepStoreForQuorum) PersistData(_ context.Context, _ string, _ map[string]any) error { return nil } func (s *stepStoreForQuorum) IsOperationApplied(_ context.Context, op string) (bool, error) { return s.applied[op], nil } func (s *stepStoreForQuorum) MarkOperationApplied(_ context.Context, op string) error { s.applied[op] = true return nil } func quorumStore(guard *TransitionGuard) *stepStoreForQuorum { return &stepStoreForQuorum{ state: MachineState{TaskID: "task-1", SessionID: "sess-1", WorkflowID: "wf", CurrentStepID: "review"}, step: StepSpec{ ID: "review", WorkflowID: "wf", Position: 1, Events: map[Trigger][]Action{ TriggerOnTurnComplete: { {Kind: ActionMoveToNext, Guard: guard}, }, }, }, next: StepSpec{ID: "approval", Position: 2}, applied: map[string]bool{}, } } // scopedParticipants distinguishes per-task rows from step-template rows, // unlike the shared fakeParticipants (which returns the same static list // for both). Required for tests that exercise AC-50's gather/canonicalize/ // collapse distinctions. type scopedParticipants struct { perTask []ParticipantInfo template []ParticipantInfo err error } func (s scopedParticipants) ListTaskParticipants(_ context.Context, taskID string) ([]ParticipantInfo, error) { if s.err != nil { return nil, s.err } out := make([]ParticipantInfo, 0, len(s.perTask)) for _, p := range s.perTask { if p.TaskID == taskID { out = append(out, p) } } return out, nil } func (s scopedParticipants) ListStepParticipants(_ context.Context, stepID, taskID string) ([]ParticipantInfo, error) { if s.err != nil { return nil, s.err } if taskID != "" { return nil, nil } out := make([]ParticipantInfo, 0, len(s.template)) for _, p := range s.template { if p.StepID == stepID { out = append(out, p) } } return out, nil } func quorumEngine(decisions DecisionStore, participants ParticipantStore) *Engine { return New(quorumStore(nil), MapRegistry{}, WithDecisionStore(decisions), WithParticipantStore(participants)) } // --- evaluateApproveStyle (AC-21/39/40/41/43a/53) --- func TestEvaluateApproveStyle_AllApprove(t *testing.T) { seats := []ParticipantInfo{{ID: "p1"}, {ID: "p2"}} cases := []struct { name string decisions []DecisionInfo want bool }{ {"all approved", []DecisionInfo{{ParticipantID: "p1", Decision: DecisionApproved}, {ParticipantID: "p2", Decision: DecisionApproved}}, true}, {"partial approved", []DecisionInfo{{ParticipantID: "p1", Decision: DecisionApproved}}, false}, {"none yet", nil, false}, {"approve+reject", []DecisionInfo{{ParticipantID: "p1", Decision: DecisionApproved}, {ParticipantID: "p2", Decision: DecisionRejected}}, false}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { got := evaluateApproveStyle(QuorumAllApprove, seats, tc.decisions) if got.Satisfied != tc.want { t.Fatalf("all_approve satisfied = %v, want %v (reason=%s)", got.Satisfied, tc.want, got.Reason) } if !got.Satisfied && got.Reason != ReasonThresholdNotMet { t.Fatalf("expected reason %s, got %s", ReasonThresholdNotMet, got.Reason) } }) } } func TestEvaluateApproveStyle_AllDecide(t *testing.T) { seats := []ParticipantInfo{{ID: "p1"}, {ID: "p2"}} d1 := []DecisionInfo{{ParticipantID: "p1", Decision: "approved"}, {ParticipantID: "p2", Decision: "rejected"}} if !evaluateApproveStyle(QuorumAllDecide, seats, d1).Satisfied { t.Fatalf("all_decide should be true when both decided") } d2 := []DecisionInfo{{ParticipantID: "p1", Decision: "approved"}} if evaluateApproveStyle(QuorumAllDecide, seats, d2).Satisfied { t.Fatalf("all_decide should be false when only one decided") } } func TestEvaluateApproveStyle_MajorityApprove(t *testing.T) { seats := []ParticipantInfo{{ID: "p1"}, {ID: "p2"}, {ID: "p3"}} // 2/3 approve => majority d := []DecisionInfo{{ParticipantID: "p1", Decision: DecisionApproved}, {ParticipantID: "p2", Decision: DecisionApproved}} if !evaluateApproveStyle(QuorumMajorityApprove, seats, d).Satisfied { t.Fatalf("majority_approve true expected for 2/3 approves") } // 1/3 approve, 1 reject => not majority d2 := []DecisionInfo{{ParticipantID: "p1", Decision: DecisionApproved}, {ParticipantID: "p2", Decision: DecisionRejected}} if evaluateApproveStyle(QuorumMajorityApprove, seats, d2).Satisfied { t.Fatalf("majority_approve false expected when not strictly more than half") } } func TestEvaluateApproveStyle_NApprove(t *testing.T) { seats := []ParticipantInfo{{ID: "p1"}, {ID: "p2"}, {ID: "p3"}} d := []DecisionInfo{{ParticipantID: "p1", Decision: DecisionApproved}, {ParticipantID: "p2", Decision: DecisionApproved}} if !evaluateApproveStyle("n_approve:2", seats, d).Satisfied { t.Fatalf("n_approve:2 expected true") } if evaluateApproveStyle("n_approve:3", seats, d).Satisfied { t.Fatalf("n_approve:3 expected false") } if got := evaluateApproveStyle("n_approve:notanint", seats, d); got.Satisfied || got.Reason != ReasonThresholdUnrecognized { t.Fatalf("malformed n_approve threshold should be threshold_unrecognized, got %+v", got) } if got := evaluateApproveStyle("n_approve:0", seats, d); got.Satisfied || got.Reason != ReasonThresholdUnrecognized { t.Fatalf("n_approve:0 should be threshold_unrecognized, got %+v", got) } } func TestEvaluateApproveStyle_NApprove_ExceedsSlate_Unsatisfiable(t *testing.T) { seats := []ParticipantInfo{{ID: "p1"}, {ID: "p2"}} got := evaluateApproveStyle("n_approve:5", seats, nil) if got.Satisfied || got.Reason != ReasonThresholdUnsatisfiable { t.Fatalf("n_approve:5 over a 2-seat slate should be threshold_unsatisfiable, got %+v", got) } if got.RequiredCount != 5 { t.Fatalf("expected RequiredCount=5, got %d", got.RequiredCount) } } func TestEvaluateApproveStyle_UnrecognizedThreshold(t *testing.T) { got := evaluateApproveStyle("quorum_of_the_moon", []ParticipantInfo{{ID: "p1"}}, nil) if got.Satisfied || got.Reason != ReasonThresholdUnrecognized { t.Fatalf("expected threshold_unrecognized, got %+v", got) } } func TestEvaluateApproveStyle_UnmappedDecisionDropped(t *testing.T) { // p1 is not (or no longer) a seat; its decision does not count. seats := []ParticipantInfo{{ID: "p2"}} decisions := []DecisionInfo{ {ParticipantID: "p1", Decision: DecisionApproved}, {ParticipantID: "p2", Decision: DecisionApproved}, } if !evaluateApproveStyle(QuorumAllApprove, seats, decisions).Satisfied { t.Fatalf("all_approve should be true when the unmapped decision is ignored") } } func TestEvaluateApproveStyle_LatestDecisionPerSeat(t *testing.T) { seats := []ParticipantInfo{{ID: "p1"}} // p1 approved then rejected — AC-26 ordering means the later row wins. decisions := []DecisionInfo{ {ParticipantID: "p1", Decision: DecisionApproved}, {ParticipantID: "p1", Decision: DecisionRejected}, } if evaluateApproveStyle(QuorumAllApprove, seats, decisions).Satisfied { t.Fatalf("expected latest reject to override earlier approve") } } func TestEvaluateApproveStyle_MapsByRoleAndAgentWhenParticipantIDUnset(t *testing.T) { // AC-51: an agent decider maps to its seat by (role, decider_id) when the // decision carries no seat id. seats := []ParticipantInfo{{ID: "p1", Role: "reviewer", AgentProfileID: "rev-A"}} decisions := []DecisionInfo{ {DeciderType: DeciderTypeAgent, DeciderID: "rev-A", Role: "reviewer", Decision: DecisionApproved}, } if !evaluateApproveStyle(QuorumAllApprove, seats, decisions).Satisfied { t.Fatalf("expected decider-identity mapping to satisfy all_approve") } } // --- evaluateAnyReject (AC-43/43a/43b/43c/58/59) --- func TestEvaluateAnyReject_VetoOnRejection(t *testing.T) { decisions := []DecisionInfo{ {DeciderType: DeciderTypeAgent, DeciderID: "rev-A", Role: "reviewer", Decision: DecisionApproved}, {DeciderType: DeciderTypeAgent, DeciderID: "rev-B", Role: "reviewer", Decision: DecisionRejected}, } satisfied, received := evaluateAnyReject(decisions, "reviewer") if !satisfied || received != 1 { t.Fatalf("expected veto satisfied with 1 rejecter, got satisfied=%v received=%d", satisfied, received) } } func TestEvaluateAnyReject_NoRejection(t *testing.T) { decisions := []DecisionInfo{ {DeciderType: DeciderTypeAgent, DeciderID: "rev-A", Role: "reviewer", Decision: DecisionApproved}, } if satisfied, _ := evaluateAnyReject(decisions, "reviewer"); satisfied { t.Fatalf("any_reject should be false when no rejection") } } func TestEvaluateAnyReject_LatestDecisionOverrides(t *testing.T) { // Same decider rejects then later approves — AC-26 ordering means the // later row (approve) is the decider's current stance, so no veto. decisions := []DecisionInfo{ {DeciderType: DeciderTypeAgent, DeciderID: "rev-A", Role: "reviewer", Decision: DecisionRejected}, {DeciderType: DeciderTypeAgent, DeciderID: "rev-A", Role: "reviewer", Decision: DecisionApproved}, } if satisfied, _ := evaluateAnyReject(decisions, "reviewer"); satisfied { t.Fatalf("expected latest approve to clear the earlier veto") } } func TestEvaluateAnyReject_RoleScopedForAgent(t *testing.T) { // AC-42: an agent decider's rejection under a different role does not // veto this guard's role. decisions := []DecisionInfo{ {DeciderType: DeciderTypeAgent, DeciderID: "rev-A", Role: "qa", Decision: DecisionRejected}, } if satisfied, _ := evaluateAnyReject(decisions, "reviewer"); satisfied { t.Fatalf("agent rejection under a different role must not veto") } } func TestEvaluateAnyReject_RoleAgnosticForUser(t *testing.T) { // AC-58: a human decider's rejection vetoes regardless of stored role. decisions := []DecisionInfo{ {DeciderType: DeciderTypeUser, DeciderID: "user-1", Role: "qa", Decision: DecisionRejected}, } if satisfied, _ := evaluateAnyReject(decisions, "reviewer"); !satisfied { t.Fatalf("user rejection should veto regardless of role") } } func TestEvaluateAnyReject_ChangesRequestedCountsAsRejection(t *testing.T) { decisions := []DecisionInfo{ {DeciderType: DeciderTypeUser, DeciderID: "user-1", Role: "reviewer", Decision: DecisionChangesRequested}, } if satisfied, _ := evaluateAnyReject(decisions, "reviewer"); !satisfied { t.Fatalf("changes_requested should be treated as a rejection veto") } } func TestEvaluateAnyReject_EmptyDecisions(t *testing.T) { if satisfied, received := evaluateAnyReject(nil, "reviewer"); satisfied || received != 0 { t.Fatalf("expected no veto with no decisions, got satisfied=%v received=%d", satisfied, received) } } // --- requiredSeats / canonicalize / collapse (AC-20/44/49/50) --- func TestRequiredSeats_FiltersByRoleAndDecisionRequired(t *testing.T) { parts := scopedParticipants{template: []ParticipantInfo{ {ID: "p1", StepID: "review", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, {ID: "p2", StepID: "review", Role: "reviewer", AgentProfileID: "rev-B", DecisionRequired: false}, {ID: "p3", StepID: "review", Role: "qa", AgentProfileID: "qa-A", DecisionRequired: true}, }} eng := quorumEngine(newFakeDecisionStore(), parts) seats, err := eng.requiredSeats(context.Background(), "review", "task-1", "reviewer") if err != nil { t.Fatalf("requiredSeats: %v", err) } if len(seats) != 1 || seats[0].ID != "p1" { t.Fatalf("expected only p1 to survive role+decision_required filtering, got %+v", seats) } } func TestRequiredSeats_PerTaskWinsOverTemplateOnCollapse(t *testing.T) { // A template seat for rev-A at the evaluating step, and a per-task // override for rev-A recorded at a different step (AC-49: per-task // participation is not step-scoped). Collapse must produce exactly one // seat, carrying the per-task row. parts := scopedParticipants{ template: []ParticipantInfo{ {ID: "tmpl-1", StepID: "review", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, }, perTask: []ParticipantInfo{ {ID: "task-row-1", TaskID: "task-1", StepID: "approval", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, }, } eng := quorumEngine(newFakeDecisionStore(), parts) seats, err := eng.requiredSeats(context.Background(), "review", "task-1", "reviewer") if err != nil { t.Fatalf("requiredSeats: %v", err) } if len(seats) != 1 { t.Fatalf("expected exactly one collapsed seat, got %d: %+v", len(seats), seats) } if seats[0].ID != "task-row-1" { t.Fatalf("expected the per-task row to win collapse, got %+v", seats[0]) } } func TestRequiredSeats_CanonicalizePrefersEvaluatingStep(t *testing.T) { // Two per-task rows for the same (task, role, agent) at different steps // — canonicalize must keep the one at the evaluating step. parts := scopedParticipants{perTask: []ParticipantInfo{ {ID: "row-other", TaskID: "task-1", StepID: "other", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, {ID: "row-review", TaskID: "task-1", StepID: "review", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, }} eng := quorumEngine(newFakeDecisionStore(), parts) seats, err := eng.requiredSeats(context.Background(), "review", "task-1", "reviewer") if err != nil { t.Fatalf("requiredSeats: %v", err) } if len(seats) != 1 || seats[0].ID != "row-review" { t.Fatalf("expected canonicalize to prefer the evaluating-step row, got %+v", seats) } } func TestRequiredSeats_CanonicalizeFallsBackToLowestID(t *testing.T) { // Neither duplicate row is at the evaluating step — fall back to the // lowest id in ASCII order. parts := scopedParticipants{perTask: []ParticipantInfo{ {ID: "row-z", TaskID: "task-1", StepID: "other-b", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, {ID: "row-a", TaskID: "task-1", StepID: "other-a", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, }} eng := quorumEngine(newFakeDecisionStore(), parts) seats, err := eng.requiredSeats(context.Background(), "review", "task-1", "reviewer") if err != nil { t.Fatalf("requiredSeats: %v", err) } if len(seats) != 1 || seats[0].ID != "row-a" { t.Fatalf("expected canonicalize to fall back to lowest id, got %+v", seats) } } func TestRequiredSeats_EmptyAgentProfileNeverGrouped(t *testing.T) { parts := scopedParticipants{template: []ParticipantInfo{ {ID: "p1", StepID: "review", Role: "reviewer", AgentProfileID: "", DecisionRequired: true}, {ID: "p2", StepID: "review", Role: "reviewer", AgentProfileID: "", DecisionRequired: true}, }} eng := quorumEngine(newFakeDecisionStore(), parts) seats, err := eng.requiredSeats(context.Background(), "review", "task-1", "reviewer") if err != nil { t.Fatalf("requiredSeats: %v", err) } if len(seats) != 2 { t.Fatalf("expected empty-agent_profile_id rows to remain distinct seats, got %d: %+v", len(seats), seats) } } func TestRequiredSeats_EmptySlate(t *testing.T) { parts := scopedParticipants{} eng := quorumEngine(newFakeDecisionStore(), parts) seats, err := eng.requiredSeats(context.Background(), "review", "task-1", "reviewer") if err != nil { t.Fatalf("requiredSeats: %v", err) } if len(seats) != 0 { t.Fatalf("expected empty slate, got %+v", seats) } } // --- computeGuardOutcome / evaluateTransitionGuard precedence (AC-23/52) --- func TestEvaluateTransitionGuard_NilGuardPermits(t *testing.T) { eng := quorumEngine(newFakeDecisionStore(), scopedParticipants{}) got := eng.evaluateTransitionGuard(context.Background(), MachineState{}, Action{Kind: ActionMoveToNext}) if !got.Satisfied { t.Fatalf("nil guard should always permit the transition") } } func TestEvaluateTransitionGuard_UnrecognizedGuardVariant(t *testing.T) { eng := quorumEngine(newFakeDecisionStore(), scopedParticipants{}) got := eng.evaluateTransitionGuard(context.Background(), MachineState{}, Action{ Kind: ActionMoveToNext, Guard: &TransitionGuard{}, }) if got.Satisfied || got.Reason != ReasonGuardVariantUnrecognized { t.Fatalf("expected guard_variant_unrecognized, got %+v", got) } } func TestComputeGuardOutcome_DecisionStoreUnwired(t *testing.T) { eng := New(quorumStore(nil), MapRegistry{}, WithParticipantStore(scopedParticipants{})) got := eng.computeGuardOutcome(context.Background(), MachineState{}, &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}) if got.Satisfied || got.Reason != ReasonDecisionStoreUnwired { t.Fatalf("expected decision_store_unwired, got %+v", got) } } func TestComputeGuardOutcome_ParticipantStoreUnwired(t *testing.T) { eng := New(quorumStore(nil), MapRegistry{}, WithDecisionStore(newFakeDecisionStore())) got := eng.computeGuardOutcome(context.Background(), MachineState{}, &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}) if got.Satisfied || got.Reason != ReasonParticipantStoreUnwired { t.Fatalf("expected participant_store_unwired, got %+v", got) } } func TestComputeGuardOutcome_SlateEmpty(t *testing.T) { eng := quorumEngine(newFakeDecisionStore(), scopedParticipants{}) state := MachineState{TaskID: "task-1", CurrentStepID: "review"} got := eng.computeGuardOutcome(context.Background(), state, &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}) if got.Satisfied || got.Reason != ReasonSlateEmpty { t.Fatalf("expected slate_empty, got %+v", got) } } func readQuorumSlateEmptyCounter(role string) int64 { m := expvar.Get("workflow_quorum_slate_empty_total") if m == nil { return 0 } kv := m.(*expvar.Map).Get(role) if kv == nil { return 0 } iv, ok := kv.(*expvar.Int) if !ok { return 0 } return iv.Value() } // TestComputeGuardOutcome_MalformedRoleSanitizesSlateEmptyCounterLabel covers // AC-OFFICE-REVIEW-SEATS-004.6/.11 on the slate_empty path: guard.Role is // operator-editable step config, and a value outside the fixed // ParticipantRole set must fold to the SeatRoleLabelInvalid sentinel on the // counter rather than growing its label cardinality with an arbitrary // string. func TestComputeGuardOutcome_MalformedRoleSanitizesSlateEmptyCounterLabel(t *testing.T) { const malformedRole = "not-a-real-role" eng := quorumEngine(newFakeDecisionStore(), scopedParticipants{}) state := MachineState{TaskID: "task-1", CurrentStepID: "review"} before := readQuorumSlateEmptyCounter(SeatRoleLabelInvalid) got := eng.computeGuardOutcome(context.Background(), state, &WaitForQuorumGuard{Role: malformedRole, Threshold: QuorumAllApprove}) if got.Satisfied || got.Reason != ReasonSlateEmpty { t.Fatalf("expected slate_empty, got %+v", got) } after := readQuorumSlateEmptyCounter(SeatRoleLabelInvalid) if after-before != 1 { t.Fatalf("%s counter delta = %d, want 1", SeatRoleLabelInvalid, after-before) } if got := readQuorumSlateEmptyCounter(malformedRole); got != 0 { t.Fatalf("expected no counter entry under the raw operator string %q, got %d", malformedRole, got) } } func TestComputeGuardOutcome_EvaluationError(t *testing.T) { parts := scopedParticipants{err: errors.New("boom")} eng := quorumEngine(newFakeDecisionStore(), parts) state := MachineState{TaskID: "task-1", CurrentStepID: "review"} got := eng.computeGuardOutcome(context.Background(), state, &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}) if got.Satisfied || got.Reason != ReasonEvaluationError || got.Err == nil { t.Fatalf("expected evaluation_error with a wrapped error, got %+v", got) } } func TestComputeGuardOutcome_AnyReject_NoSlateNeeded(t *testing.T) { // AC-59: any_reject must not short-circuit on an empty seat slate. decisions := newFakeDecisionStore() if err := decisions.RecordStepDecision(context.Background(), DecisionInfo{ TaskID: "task-1", StepID: "review", DeciderType: DeciderTypeUser, DeciderID: "user-1", Role: "reviewer", Decision: DecisionRejected, }); err != nil { t.Fatalf("record: %v", err) } eng := quorumEngine(decisions, scopedParticipants{}) // no seats configured at all state := MachineState{TaskID: "task-1", CurrentStepID: "review"} got := eng.computeGuardOutcome(context.Background(), state, &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAnyReject}) if !got.Satisfied { t.Fatalf("expected any_reject veto to fire despite an empty slate, got %+v", got) } } func TestComputeGuardOutcome_ThresholdUnrecognizedTakesPrecedenceOverThresholdNotMet(t *testing.T) { parts := scopedParticipants{template: []ParticipantInfo{ {ID: "p1", StepID: "review", Role: "reviewer", AgentProfileID: "rev-A", DecisionRequired: true}, }} eng := quorumEngine(newFakeDecisionStore(), parts) state := MachineState{TaskID: "task-1", CurrentStepID: "review"} got := eng.computeGuardOutcome(context.Background(), state, &WaitForQuorumGuard{Role: "reviewer", Threshold: "not_a_real_threshold"}) if got.Satisfied || got.Reason != ReasonThresholdUnrecognized { t.Fatalf("expected threshold_unrecognized, got %+v", got) } } // --- Engine-level integration (unchanged from the pre-rewrite suite) --- func TestEngine_WaitForQuorum_BlocksUntilSatisfied(t *testing.T) { store := quorumStore(&TransitionGuard{ WaitForQuorum: &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}, }) decisions := newFakeDecisionStore() parts := fakeParticipants{list: []ParticipantInfo{ {ID: "p1", Role: "reviewer", DecisionRequired: true, AgentProfileID: "rev-A"}, {ID: "p2", Role: "reviewer", DecisionRequired: true, AgentProfileID: "rev-B"}, }} eng := New(store, MapRegistry{}, WithDecisionStore(decisions), WithParticipantStore(parts)) res, err := eng.HandleTrigger(context.Background(), HandleInput{ TaskID: "task-1", SessionID: "sess-1", Trigger: TriggerOnTurnComplete, }) if err != nil { t.Fatalf("unexpected error: %v", err) } if res.Transitioned { t.Fatalf("expected guard to block transition with no decisions") } // Record one approval - still not enough for all_approve. if err := decisions.RecordStepDecision(context.Background(), DecisionInfo{ TaskID: "task-1", StepID: "review", ParticipantID: "p1", Decision: DecisionApproved, }); err != nil { t.Fatalf("record: %v", err) } res, err = eng.HandleTrigger(context.Background(), HandleInput{ TaskID: "task-1", SessionID: "sess-1", Trigger: TriggerOnTurnComplete, }) if err != nil { t.Fatalf("unexpected error: %v", err) } if res.Transitioned { t.Fatalf("expected guard to block transition with partial decisions") } // Record second approval - quorum reached. if err := decisions.RecordStepDecision(context.Background(), DecisionInfo{ TaskID: "task-1", StepID: "review", ParticipantID: "p2", Decision: DecisionApproved, }); err != nil { t.Fatalf("record: %v", err) } res, err = eng.HandleTrigger(context.Background(), HandleInput{ TaskID: "task-1", SessionID: "sess-1", Trigger: TriggerOnTurnComplete, }) if err != nil { t.Fatalf("unexpected error: %v", err) } if !res.Transitioned { t.Fatalf("expected transition once quorum satisfied") } if res.ToStepID != "approval" { t.Fatalf("expected target = approval, got %q", res.ToStepID) } } func TestEngine_WaitForQuorum_NoRequiredParticipants_FailsClosed(t *testing.T) { store := quorumStore(&TransitionGuard{ WaitForQuorum: &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}, }) decisions := newFakeDecisionStore() // All participants present but DecisionRequired=false. parts := fakeParticipants{list: []ParticipantInfo{ {ID: "p1", Role: "reviewer", DecisionRequired: false, AgentProfileID: "rev-A"}, }} eng := New(store, MapRegistry{}, WithDecisionStore(decisions), WithParticipantStore(parts)) res, err := eng.HandleTrigger(context.Background(), HandleInput{ TaskID: "task-1", SessionID: "sess-1", Trigger: TriggerOnTurnComplete, }) if err != nil { t.Fatalf("unexpected error: %v", err) } if res.Transitioned { t.Fatalf("expected guard to fail closed when no required participants exist") } } func TestEngine_WaitForQuorum_NoStoresWired_FailsClosed(t *testing.T) { store := quorumStore(&TransitionGuard{ WaitForQuorum: &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}, }) eng := New(store, MapRegistry{}) // no DecisionStore / ParticipantStore res, err := eng.HandleTrigger(context.Background(), HandleInput{ TaskID: "task-1", SessionID: "sess-1", Trigger: TriggerOnTurnComplete, }) if err != nil { t.Fatalf("unexpected error: %v", err) } if res.Transitioned { t.Fatalf("expected guard to fail closed when stores not wired") } } func TestClearDecisionsCallback_DeletesRows(t *testing.T) { decisions := newFakeDecisionStore() _ = decisions.RecordStepDecision(context.Background(), DecisionInfo{TaskID: "t", StepID: "s", ParticipantID: "p", Decision: "approved"}) cb := ClearDecisionsCallback{Decisions: decisions} _, err := cb.Execute(context.Background(), ActionInput{ State: MachineState{TaskID: "t"}, Step: StepSpec{ID: "s"}, Action: Action{Kind: ActionClearDecisions, ClearDecisions: &ClearDecisionsAction{}}, }) if err != nil { t.Fatalf("clear: %v", err) } if got, _ := decisions.ListStepDecisions(context.Background(), "t", "s"); len(got) != 0 { t.Fatalf("expected decisions cleared, got %d", len(got)) } if decisions.cleared[dkey("t", "s")] != 1 { t.Fatalf("expected cleared count for (t,s) to be 1, got %d", decisions.cleared[dkey("t", "s")]) } } func TestClearDecisionsCallback_NoStore_Errors(t *testing.T) { cb := ClearDecisionsCallback{} _, err := cb.Execute(context.Background(), ActionInput{ Action: Action{Kind: ActionClearDecisions, ClearDecisions: &ClearDecisionsAction{}}, }) if err == nil || !errors.Is(err, ErrActionNotYetWired) { t.Fatalf("expected ErrActionNotYetWired, got %v", err) } } func TestEngine_RecordParticipantDecision_PersistsAndReevaluates(t *testing.T) { store := quorumStore(&TransitionGuard{ WaitForQuorum: &WaitForQuorumGuard{Role: "reviewer", Threshold: QuorumAllApprove}, }) decisions := newFakeDecisionStore() parts := fakeParticipants{list: []ParticipantInfo{ {ID: "p1", Role: "reviewer", DecisionRequired: true, AgentProfileID: "rev-A"}, }} eng := New(store, MapRegistry{}, WithDecisionStore(decisions), WithParticipantStore(parts)) result, err := eng.RecordParticipantDecision(context.Background(), "sess-1", DecisionInfo{ TaskID: "task-1", StepID: "review", ParticipantID: "p1", Decision: DecisionApproved, Note: "lgtm", }) if err != nil { t.Fatalf("RecordParticipantDecision: %v", err) } if result.DecisionID == "" { t.Fatalf("expected a generated decision id") } if result.DecidedAt.IsZero() { t.Fatalf("expected DecidedAt to be stamped") } if !result.Transitioned || result.TransitionAbandoned { t.Fatalf("expected the sole reviewer's approval to satisfy all_approve and transition: %#v", result) } if result.FromStepID != "review" || result.ToStepID != "approval" { t.Fatalf("unexpected transition endpoints: %#v", result) } if len(result.Guards) != 1 || !result.Guards[0].Satisfied || result.Guards[0].TargetStepID != "approval" { t.Fatalf("expected the validated guard snapshot on transition, got %#v", result.Guards) } if store.state.CurrentStepID != "approval" { t.Fatalf("expected store to have moved to 'approval', got %q", store.state.CurrentStepID) } got, _ := decisions.ListStepDecisions(context.Background(), "task-1", "review") if len(got) != 1 { t.Fatalf("expected 1 recorded decision, got %d", len(got)) } if got[0].Decision != DecisionApproved || got[0].Note != "lgtm" { t.Fatalf("unexpected decision shape: %#v", got[0]) } if got[0].ID != result.DecisionID || !got[0].DecidedAt.Equal(result.DecidedAt) { t.Fatalf("persisted decision does not carry the id/DecidedAt returned to the caller: %#v", got[0]) } } func TestEngine_RecordParticipantDecision_RequiresStore(t *testing.T) { store := quorumStore(nil) eng := New(store, MapRegistry{}) // no DecisionStore wired _, err := eng.RecordParticipantDecision(context.Background(), "sess-1", DecisionInfo{ TaskID: "task-1", StepID: "review", ParticipantID: "p1", Decision: DecisionApproved, }) if err == nil { t.Fatalf("expected error when DecisionStore missing") } } func TestEngine_RecordParticipantDecision_RequiresIDs(t *testing.T) { decisions := newFakeDecisionStore() eng := New(quorumStore(nil), MapRegistry{}, WithDecisionStore(decisions)) cases := []struct { name string task, step, participant string decision string expectErr bool }{ {"missing task", "", "step", "p", "approved", true}, {"missing step", "task", "", "p", "approved", true}, {"missing participant", "task", "step", "", "approved", true}, {"missing decision", "task", "step", "p", "", true}, {"valid (no session => skip reeval)", "task", "step", "p", "approved", false}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { result, err := eng.RecordParticipantDecision(context.Background(), "", DecisionInfo{ TaskID: tc.task, StepID: tc.step, ParticipantID: tc.participant, Decision: tc.decision, }) if (err != nil) != tc.expectErr { t.Fatalf("err=%v, expectErr=%v", err, tc.expectErr) } if err == nil && !result.ReevaluationSkipped { t.Fatalf("expected ReevaluationSkipped with a blank sessionID: %#v", result) } if err == nil && result.SkipReason != ReasonSessionUnresolvable { t.Fatalf("expected SkipReason=%s, got %q", ReasonSessionUnresolvable, result.SkipReason) } }) } } func TestConfigTransitionGuard_ParsesWaitForQuorum(t *testing.T) { cfg := map[string]any{ "if": map[string]any{ "wait_for_quorum": map[string]any{ "role": "reviewer", "threshold": "all_approve", }, }, } g := ConfigTransitionGuard(cfg) if g == nil || g.WaitForQuorum == nil { t.Fatalf("expected wait_for_quorum guard") } if g.WaitForQuorum.Role != "reviewer" || g.WaitForQuorum.Threshold != "all_approve" { t.Fatalf("unexpected guard: %+v", g.WaitForQuorum) } } func TestConfigTransitionGuard_ParsesLegacyTopLevelWaitForQuorum(t *testing.T) { cfg := map[string]any{ "wait_for_quorum": map[string]any{ "role": "reviewer", "threshold": "all_approve", }, } g := ConfigTransitionGuard(cfg) if g == nil || g.WaitForQuorum == nil { t.Fatalf("expected guard, got %#v", g) } if g.WaitForQuorum.Role != "reviewer" || g.WaitForQuorum.Threshold != "all_approve" { t.Fatalf("unexpected guard: %#v", g.WaitForQuorum) } if got := ConfigTransitionGuard(nil); got != nil { t.Fatalf("expected nil for nil config") } if got := ConfigTransitionGuard(map[string]any{}); got != nil { t.Fatalf("expected nil when key absent") } // Missing fields => no guard. if got := ConfigTransitionGuard(map[string]any{"wait_for_quorum": map[string]any{"role": ""}}); got != nil { t.Fatalf("expected nil for malformed guard") } }