GEN2 M4 remediation: durable recovery and governed evolution
CI / test (push) Failing after 26s

This commit is contained in:
m
2026-08-29 11:47:05 +03:00
parent 96687140ce
commit 839b35f310
13 changed files with 536 additions and 3 deletions
+35
View File
@@ -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
}
+21
View File
@@ -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)
}
}
+76
View File
@@ -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)
}
}
+1 -1
View File
@@ -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}
}
+1 -1
View File
@@ -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")
}