Files

73 lines
3.5 KiB
Go

package domain
import "git.cin.su/m/Assistant/contracts/epistemics"
// AssessFreshness receives the Work-owned requirement as primitive policy
// inputs, keeping the Epistemics owner independent of Work package types.
func AssessFreshness(applicability epistemics.TemporalApplicability, mode string, maximumAgeMillis *int64, nowMillis int64) epistemics.FreshnessAssessment {
return AssessFreshnessForRequirement(applicability, epistemics.FreshnessRequirement{Mode: mode, MaximumAgeMillis: maximumAgeMillis}, nowMillis)
}
// AssessFreshnessForRequirement evaluates evidence for the task at hand. It
// never writes a permanent stale marker: the same evidence may be current for
// one task and historical-only for another.
func AssessFreshnessForRequirement(applicability epistemics.TemporalApplicability, requirement epistemics.FreshnessRequirement, nowMillis int64) epistemics.FreshnessAssessment {
basis := applicability.ObservedAtUnixMillis
if applicability.LastVerifiedAtUnixMillis != nil && *applicability.LastVerifiedAtUnixMillis > basis {
basis = *applicability.LastVerifiedAtUnixMillis
}
age := nowMillis - basis
if age < 0 {
age = 0
}
state := epistemics.FreshnessAssessmentCurrent
reason := "evidence is within task applicability window"
versionState := "NOT_REQUIRED"
if applicability.ValidFromUnixMillis != nil && nowMillis < *applicability.ValidFromUnixMillis {
state, reason = epistemics.FreshnessAssessmentHistoricalOnly, "valid-from has not started"
}
if applicability.ValidUntilUnixMillis != nil && nowMillis > *applicability.ValidUntilUnixMillis {
state, reason = epistemics.FreshnessAssessmentStale, "valid-until elapsed"
}
if applicability.Volatility.HardStaleAfterMillis != nil && age > *applicability.Volatility.HardStaleAfterMillis {
state, reason = epistemics.FreshnessAssessmentStale, "hard volatility window elapsed"
}
if applicability.Volatility.RevalidateAfterMillis != nil && age > *applicability.Volatility.RevalidateAfterMillis && state == epistemics.FreshnessAssessmentCurrent {
state, reason = epistemics.FreshnessAssessmentAging, "revalidation window elapsed"
}
if requirement.MaximumAgeMillis != nil && age > *requirement.MaximumAgeMillis {
state, reason = epistemics.FreshnessAssessmentStale, "task maximum age exceeded"
}
if len(requirement.RequiredVersionRefs) > 0 {
versionState = versionMatchState(applicability, requirement.RequiredVersionRefs)
if versionState == "MISMATCH" {
state, reason = epistemics.FreshnessAssessmentVersionMismatch, "task version does not match evidence applicability"
} else if versionState == "UNKNOWN" && state == epistemics.FreshnessAssessmentCurrent {
state, reason = epistemics.FreshnessAssessmentHistoricalOnly, "task version applicability is unknown"
}
}
if requirement.Mode == "LIVE_REQUIRED" {
state, reason = epistemics.FreshnessAssessmentHistoricalOnly, "live source required"
}
return epistemics.FreshnessAssessment{SourceKnowledgeRef: "knowledge", TaskRef: "task", State: state, Reason: reason, AgeMillis: age, VersionMatchState: versionState, AssessedAtUnixMillis: nowMillis}
}
func versionMatchState(applicability epistemics.TemporalApplicability, required []epistemics.SemanticReference) string {
if len(applicability.VersionBindings) == 0 {
return "UNKNOWN"
}
for _, target := range required {
matched := false
for _, binding := range applicability.VersionBindings {
if binding.VersionRef == target {
matched = true
break
}
}
if !matched {
return "MISMATCH"
}
}
return "MATCH"
}