This commit is contained in:
@@ -0,0 +1,35 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"git.cin.su/m/Assistant/contracts/epistemics"
|
||||
"git.cin.su/m/Assistant/platform/ids"
|
||||
)
|
||||
|
||||
var ErrInvalidOutcomeAssessment = errors.New("invalid world outcome assessment")
|
||||
|
||||
// AssessWorldOutcome keeps Commit's execution fact separate from Epistemics'
|
||||
// observation. No observation means UNKNOWN; a transport receipt alone never
|
||||
// becomes success.
|
||||
func AssessWorldOutcome(principalID, attemptRef, expectedEffect string, receiptRefs []string, observationRefs []epistemics.ObservationID, claimRefs []epistemics.ClaimID, evidenceRefs []epistemics.EvidenceRef, observedState epistemics.WorldOutcomeState, confidence, assessedAt int64) (epistemics.WorldOutcomeAssessment, error) {
|
||||
if principalID == "" || attemptRef == "" || expectedEffect == "" || assessedAt < 1 || confidence < 0 || confidence > 1000 {
|
||||
return epistemics.WorldOutcomeAssessment{}, ErrInvalidOutcomeAssessment
|
||||
}
|
||||
state := epistemics.OutcomeUnknownState
|
||||
if len(observationRefs) == 0 {
|
||||
state = epistemics.OutcomeUnknownState
|
||||
} else if observedState == epistemics.OutcomeVerifiedSuccess || observedState == epistemics.OutcomeVerifiedPartial || observedState == epistemics.OutcomeVerifiedFailure || observedState == epistemics.OutcomeConflicted {
|
||||
state = observedState
|
||||
} else {
|
||||
state = epistemics.OutcomeVerifiedPartial
|
||||
}
|
||||
id, err := ids.New()
|
||||
if err != nil {
|
||||
return epistemics.WorldOutcomeAssessment{}, err
|
||||
}
|
||||
value := epistemics.WorldOutcomeAssessment{ID: string(id), PrincipalID: principalID, ActionAttemptRef: attemptRef, ExecutionReceiptRefs: append([]string(nil), receiptRefs...), ExpectedEffectRef: expectedEffect, ObservationRefs: append([]epistemics.ObservationID(nil), observationRefs...), ClaimRefs: append([]epistemics.ClaimID(nil), claimRefs...), State: state, ConfidenceMillis: confidence, EvidenceRefs: append([]epistemics.EvidenceRef(nil), evidenceRefs...), AssessedAt: assessedAt}
|
||||
if !value.Valid() {
|
||||
return epistemics.WorldOutcomeAssessment{}, ErrInvalidOutcomeAssessment
|
||||
}
|
||||
return value, nil
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
package domain_test
|
||||
|
||||
import (
|
||||
"git.cin.su/m/Assistant/contracts/epistemics"
|
||||
"git.cin.su/m/Assistant/modules/epistemics/domain"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestExecutionReceiptWithoutObservationRemainsUnknown(t *testing.T) {
|
||||
value, err := domain.AssessWorldOutcome("principal", "attempt", "effect", []string{"receipt"}, nil, nil, nil, epistemics.OutcomeVerifiedSuccess, 1000, 1)
|
||||
if err != nil || value.State != epistemics.OutcomeUnknownState {
|
||||
t.Fatalf("value=%+v err=%v", value, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestObservedOutcomeCanBeVerifiedSeparately(t *testing.T) {
|
||||
value, err := domain.AssessWorldOutcome("principal", "attempt", "effect", []string{"receipt"}, []epistemics.ObservationID{"observation"}, []epistemics.ClaimID{"claim"}, []epistemics.EvidenceRef{"evidence"}, epistemics.OutcomeVerifiedSuccess, 900, 1)
|
||||
if err != nil || value.State != epistemics.OutcomeVerifiedSuccess || len(value.EvidenceRefs) != 1 {
|
||||
t.Fatalf("value=%+v err=%v", value, err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
)
|
||||
|
||||
var ErrGovernedEvolution = errors.New("governed evolution gate failed")
|
||||
|
||||
func RunGovernedEvolution(needRef string, ops work.GovernedEvolutionOps) (work.GovernedEvolutionResult, error) {
|
||||
result := work.GovernedEvolutionResult{NeedRef: needRef, Stages: []work.EvolutionRunStage{work.EvolutionNeedRecorded}}
|
||||
if needRef == "" || ops.CreateCandidate == nil || ops.Evaluate == nil || ops.SandboxBuild == nil || ops.Benchmark == nil || ops.Promote == nil || ops.Rollback == nil || ops.LearningLedgerOutcome == nil {
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
candidate, err := ops.CreateCandidate()
|
||||
if err != nil {
|
||||
return result, err
|
||||
}
|
||||
if candidate.ID == "" || candidate.ProposalRef == "" {
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
result.CandidateRef = candidate.ID
|
||||
result.Stages = append(result.Stages, work.EvolutionCandidateBuilt)
|
||||
evaluation, err := ops.Evaluate(candidate)
|
||||
if err != nil || !evaluation.ValidFor(candidate) {
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
result.EvaluationRef = evaluation.CandidateRef
|
||||
result.Stages = append(result.Stages, work.EvolutionIndependentlyEvaluated)
|
||||
sandboxEvidence, err := ops.SandboxBuild(candidate)
|
||||
if err != nil || sandboxEvidence == "" {
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
candidate.SandboxEvidenceRefs = append(candidate.SandboxEvidenceRefs, sandboxEvidence)
|
||||
result.EvidenceRefs = append(result.EvidenceRefs, sandboxEvidence)
|
||||
result.Stages = append(result.Stages, work.EvolutionSandboxed)
|
||||
benchmarkEvidence, passed, err := ops.Benchmark(candidate)
|
||||
if err != nil || !passed || benchmarkEvidence == "" {
|
||||
result = rollbackEvolution(result, candidate, ops)
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
candidate.BenchmarkEvidenceRefs = append(candidate.BenchmarkEvidenceRefs, benchmarkEvidence)
|
||||
result.EvidenceRefs = append(result.EvidenceRefs, benchmarkEvidence)
|
||||
result.Stages = append(result.Stages, work.EvolutionBenchmarked)
|
||||
if ops.Canary != nil {
|
||||
canaryEvidence, passed, canaryErr := ops.Canary(candidate)
|
||||
if canaryErr != nil || !passed || canaryEvidence == "" {
|
||||
result = rollbackEvolution(result, candidate, ops)
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
result.EvidenceRefs = append(result.EvidenceRefs, canaryEvidence)
|
||||
result.Stages = append(result.Stages, work.EvolutionCanaried)
|
||||
}
|
||||
promotionRef, err := ops.Promote(candidate, evaluation)
|
||||
if err != nil || promotionRef == "" {
|
||||
result = rollbackEvolution(result, candidate, ops)
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
result.Promoted = true
|
||||
result.Stages = append(result.Stages, work.EvolutionPromoted)
|
||||
result.LearningLedgerOutcomeRef, err = ops.LearningLedgerOutcome(result)
|
||||
if err != nil || result.LearningLedgerOutcomeRef == "" {
|
||||
return result, ErrGovernedEvolution
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func rollbackEvolution(result work.GovernedEvolutionResult, candidate work.EvolutionCandidate, ops work.GovernedEvolutionOps) work.GovernedEvolutionResult {
|
||||
ref, err := ops.Rollback(candidate)
|
||||
if err == nil && ref != "" {
|
||||
result.RollbackRef = ref
|
||||
result.Stages = append(result.Stages, work.EvolutionRolledBack)
|
||||
result.LearningLedgerOutcomeRef, _ = ops.LearningLedgerOutcome(result)
|
||||
}
|
||||
return result
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package domain_test
|
||||
|
||||
import (
|
||||
"git.cin.su/m/Assistant/contracts/work"
|
||||
"git.cin.su/m/Assistant/modules/work/domain"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestGovernedEvolutionExecutesGatesAndLedgerOutcome(t *testing.T) {
|
||||
calls := []string{}
|
||||
result, err := domain.RunGovernedEvolution("need-1", work.GovernedEvolutionOps{
|
||||
CreateCandidate: func() (work.EvolutionCandidate, error) {
|
||||
calls = append(calls, "candidate")
|
||||
return work.EvolutionCandidate{ID: "candidate-1", ProposalRef: "proposal-1", CreatorIdentity: "creator", RollbackRef: "rollback-plan"}, nil
|
||||
},
|
||||
Evaluate: func(c work.EvolutionCandidate) (work.EvolutionEvaluation, error) {
|
||||
calls = append(calls, "evaluate")
|
||||
return work.EvolutionEvaluation{CandidateRef: c.ID, EvaluatorIdentity: "independent", Approved: true, MustNotWorsenPassed: true, EvidenceRefs: []work.EvidenceRef{"eval"}, RecordedAtUnixMillis: 1}, nil
|
||||
},
|
||||
SandboxBuild: func(work.EvolutionCandidate) (work.EvidenceRef, error) {
|
||||
calls = append(calls, "sandbox-build")
|
||||
return "sandbox", nil
|
||||
},
|
||||
Benchmark: func(work.EvolutionCandidate) (work.EvidenceRef, bool, error) {
|
||||
calls = append(calls, "benchmark")
|
||||
return "benchmark", true, nil
|
||||
},
|
||||
Canary: func(work.EvolutionCandidate) (work.EvidenceRef, bool, error) {
|
||||
calls = append(calls, "canary")
|
||||
return "canary", true, nil
|
||||
},
|
||||
Promote: func(work.EvolutionCandidate, work.EvolutionEvaluation) (string, error) {
|
||||
calls = append(calls, "promote")
|
||||
return "promotion", nil
|
||||
},
|
||||
Rollback: func(work.EvolutionCandidate) (string, error) {
|
||||
calls = append(calls, "rollback")
|
||||
return "rollback", nil
|
||||
},
|
||||
LearningLedgerOutcome: func(work.GovernedEvolutionResult) (string, error) {
|
||||
calls = append(calls, "ledger")
|
||||
return "ledger-outcome", nil
|
||||
},
|
||||
})
|
||||
if err != nil || !result.Promoted || result.LearningLedgerOutcomeRef != "ledger-outcome" {
|
||||
t.Fatalf("result=%+v err=%v", result, err)
|
||||
}
|
||||
want := []string{"candidate", "evaluate", "sandbox-build", "benchmark", "canary", "promote", "ledger"}
|
||||
if len(calls) != len(want) {
|
||||
t.Fatalf("calls=%v", calls)
|
||||
}
|
||||
for i := range want {
|
||||
if calls[i] != want[i] {
|
||||
t.Fatalf("calls=%v", calls)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestGovernedEvolutionRollsBackOnMustNotWorsenFailure(t *testing.T) {
|
||||
rolledBack := false
|
||||
result, err := domain.RunGovernedEvolution("need-1", work.GovernedEvolutionOps{
|
||||
CreateCandidate: func() (work.EvolutionCandidate, error) {
|
||||
return work.EvolutionCandidate{ID: "candidate-1", ProposalRef: "proposal-1", CreatorIdentity: "creator", RollbackRef: "rollback-plan"}, nil
|
||||
},
|
||||
Evaluate: func(c work.EvolutionCandidate) (work.EvolutionEvaluation, error) {
|
||||
return work.EvolutionEvaluation{CandidateRef: c.ID, EvaluatorIdentity: "independent", Approved: true, MustNotWorsenPassed: true, EvidenceRefs: []work.EvidenceRef{"eval"}, RecordedAtUnixMillis: 1}, nil
|
||||
},
|
||||
SandboxBuild: func(work.EvolutionCandidate) (work.EvidenceRef, error) { return "sandbox", nil }, Benchmark: func(work.EvolutionCandidate) (work.EvidenceRef, bool, error) { return "benchmark", false, nil },
|
||||
Promote: func(work.EvolutionCandidate, work.EvolutionEvaluation) (string, error) {
|
||||
t.Fatal("promotion bypassed failed benchmark")
|
||||
return "", nil
|
||||
}, Rollback: func(work.EvolutionCandidate) (string, error) { rolledBack = true; return "rollback-evidence", nil }, LearningLedgerOutcome: func(r work.GovernedEvolutionResult) (string, error) { return "ledger-rollback", nil },
|
||||
})
|
||||
if err == nil || !rolledBack || result.RollbackRef != "rollback-evidence" || result.Promoted {
|
||||
t.Fatalf("result=%+v err=%v", result, err)
|
||||
}
|
||||
}
|
||||
@@ -11,7 +11,7 @@ func AssembleSpecialists(p work.PerspectiveSpec, subtasks []string) work.TeamDec
|
||||
}
|
||||
assignments := make([]work.SpecialistAssignment, 0, len(subtasks))
|
||||
for _, s := range subtasks {
|
||||
assignments = append(assignments, work.SpecialistAssignment{Perspective: p, SubtaskRef: s})
|
||||
assignments = append(assignments, work.SpecialistAssignment{Perspective: p, SubtaskRef: s, FocusRef: p.FocusRef, SkillRefs: append([]string(nil), p.SkillRefs...), ToolRefs: append([]string(nil), p.ToolRefs...)})
|
||||
}
|
||||
return work.TeamDecision{UseTeam: true, Reason: "independent subtasks justify bounded perspectives", Assignments: assignments}
|
||||
}
|
||||
|
||||
@@ -7,7 +7,7 @@ import (
|
||||
)
|
||||
|
||||
func TestPerspectiveTeamIsBoundedByIndependentSubtasks(t *testing.T) {
|
||||
p := work.PerspectiveSpec{ID: "architect", ObjectiveLens: "architecture", EvaluationCriteria: []string{"correctness"}, ExpectedOutputShape: "finding"}
|
||||
p := work.PerspectiveSpec{ID: "architect", ObjectiveLens: "architecture", FocusRef: "focus-1", SkillRefs: []string{"skill-1"}, ToolRefs: []string{"tool-1"}, EvaluationCriteria: []string{"correctness"}, ExpectedOutputShape: "finding"}
|
||||
if d := domain.AssembleSpecialists(p, []string{"a"}); d.UseTeam {
|
||||
t.Fatal("team for one subtask")
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user