feat(core): wire durable self learning evidence

This commit is contained in:
m
2026-08-30 22:48:46 +03:00
parent b4c3479614
commit 75fa8477d8
8 changed files with 155 additions and 2 deletions
+67
View File
@@ -11,8 +11,11 @@ import (
"git.cin.su/m/Assistant/contracts/continuity"
"git.cin.su/m/Assistant/contracts/epistemics"
"git.cin.su/m/Assistant/contracts/interaction"
selfcontract "git.cin.su/m/Assistant/contracts/self"
capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
epistemicsdomain "git.cin.su/m/Assistant/modules/epistemics/domain"
selfdomain "git.cin.su/m/Assistant/modules/self/domain"
"git.cin.su/m/Assistant/platform/ids"
"git.cin.su/m/Assistant/platform/telemetry"
)
@@ -29,15 +32,55 @@ type learningCapabilityStore interface {
SaveSkillProfile(context.Context, capability.SkillProfile) error
}
type learningSelfStore interface {
SaveLearningSignal(context.Context, selfcontract.LearningSignal) error
SaveImprovementNeed(context.Context, selfcontract.ImprovementNeed) error
SaveLearningLedger(context.Context, selfcontract.LearningLedgerEntry) error
}
type learningRecorder struct {
epistemics learningEpistemicsStore
capability capabilityLearningStore
self learningSelfStore
}
type capabilityLearningStore interface {
learningCapabilityStore
}
func (r learningRecorder) recordSelfSignal(ctx context.Context, signal selfcontract.LearningSignal) {
if r.self == nil {
return
}
if err := signal.Validate(); err != nil {
log.Printf("learning SELF signal invalid: %v", err)
return
}
if err := r.self.SaveLearningSignal(ctx, signal); err != nil {
log.Printf("learning SELF signal unavailable: %v", err)
return
}
diagnosis := selfdomain.AttributeFailure(signal)
need, err := selfdomain.BuildImprovementNeed(signal, diagnosis, string(signal.Kind))
if err != nil {
log.Printf("learning SELF improvement need invalid: %v", err)
return
}
if err := r.self.SaveImprovementNeed(ctx, need); err != nil {
log.Printf("learning SELF improvement need unavailable: %v", err)
return
}
needRef := selfcontract.SemanticReference{OwnerNamespace: "self", SemanticKind: "improvement_need", StableID: ids.StableID(need.ID)}
ledger := selfcontract.LearningLedgerEntry{ID: selfcontract.LearningLedgerEntryID("ledger:observed:" + signal.ID), PrincipalID: signal.PrincipalID, ImprovementNeedRef: &needRef, ObservedProblem: need.ProblemSummary, EvidenceRefs: signal.EvidenceRefs, Diagnosis: string(diagnosis.Class), Hypothesis: diagnosis.Rationale, ProposedChangeRef: signal.SubjectRef, ExpectedImprovement: need.ExpectedBenefit, Decision: "OBSERVED_REQUIRES_GOVERNED_REVIEW", RecordedAt: signal.ObservedAt}
if err := r.self.SaveLearningLedger(ctx, ledger); err != nil {
log.Printf("learning SELF ledger unavailable: %v", err)
}
}
func selfEvidence(owner, kind, stable string) selfcontract.SemanticReference {
return selfcontract.SemanticReference{OwnerNamespace: owner, SemanticKind: kind, StableID: ids.StableID(stable)}
}
type reminderResponseLearningInput struct {
Utterance interaction.HumanUtterance
Intent interaction.OriginalHumanIntent
@@ -157,6 +200,11 @@ func (r learningRecorder) recordCorrection(ctx context.Context, input correction
RecordedAtUnixMillis: input.At.UnixMilli(),
}
r.saveExperienceAndReflection(ctx, experience)
r.recordSelfSignal(ctx, selfcontract.LearningSignal{
ID: "signal:correction:" + string(input.Utterance.ID), PrincipalID: string(input.Utterance.PrincipalID), Kind: selfcontract.SignalUserCorrection,
TaskPattern: "interaction-correction", ScopeKey: "principal:" + string(input.Utterance.PrincipalID),
SubjectRef: selfEvidence("interaction", "intent", string(input.Intent.ID)), EvidenceRefs: []selfcontract.SemanticReference{selfEvidence("epistemics", "experience", string(input.Utterance.ID))}, ObservedAt: input.At.UnixMilli(), Severity: 2, UserImpact: 2,
})
}
func (r learningRecorder) createDelegationCandidateSkill(ctx context.Context, input delegationLearningInput, experience epistemics.ExperienceRecord) {
@@ -209,6 +257,11 @@ func (r learningRecorder) recordFastPathDecline(ctx context.Context, input fastP
if ok {
r.updateReminderSkill(ctx, saved, capability.UsageSkipped, false)
}
r.recordSelfSignal(ctx, selfcontract.LearningSignal{
ID: "signal:fast-path:" + string(input.Utterance.ID), PrincipalID: string(input.Utterance.PrincipalID), Kind: selfcontract.SignalSkillFallback,
TaskPattern: "fast-path", ScopeKey: "principal:" + string(input.Utterance.PrincipalID), SubjectRef: selfEvidence("capability", "skill", string(reminderResponseSkillID)),
EvidenceRefs: []selfcontract.SemanticReference{selfEvidence("epistemics", "experience", string(input.Utterance.ID))}, ActualOutcome: string(input.Reason), ObservedAt: input.At.UnixMilli(), Severity: 1,
})
}
func (r learningRecorder) recordCapabilityUse(ctx context.Context, input capabilityLearningInput) {
@@ -242,6 +295,13 @@ func (r learningRecorder) recordCapabilityUse(ctx context.Context, input capabil
RecordedAtUnixMillis: input.At.UnixMilli(),
}
r.saveExperienceAndReflection(ctx, experience)
if input.Outcome == capability.UsageFailed || input.Outcome == capability.UsageUnknown {
r.recordSelfSignal(ctx, selfcontract.LearningSignal{
ID: "signal:capability:" + string(input.Utterance.ID), PrincipalID: string(input.Utterance.PrincipalID), Kind: selfcontract.SignalVerifiedFailure,
TaskPattern: "capability-use", ScopeKey: "principal:" + string(input.Utterance.PrincipalID), SubjectRef: selfEvidence("capability", "implementation", string(input.ImplementationID)), EvidenceRefs: []selfcontract.SemanticReference{selfEvidence("epistemics", "experience", string(input.Utterance.ID))},
ActualOutcome: string(input.Outcome), ObservedAt: input.At.UnixMilli(), Severity: 2,
})
}
}
func (r learningRecorder) recordDelegationOutcome(ctx context.Context, input delegationLearningInput) {
@@ -282,6 +342,13 @@ func (r learningRecorder) recordDelegationOutcome(ctx context.Context, input del
if ok && input.Verified {
r.createDelegationCandidateSkill(ctx, input, saved)
}
if !input.Verified {
r.recordSelfSignal(ctx, selfcontract.LearningSignal{
ID: "signal:delegation:" + input.DelegationID, PrincipalID: string(input.Utterance.PrincipalID), Kind: selfcontract.SignalVerifiedFailure,
TaskPattern: "delegation", ScopeKey: "principal:" + string(input.Utterance.PrincipalID), SubjectRef: selfEvidence("capability", "implementation", string(input.ImplementationID)), EvidenceRefs: []selfcontract.SemanticReference{selfEvidence("epistemics", "experience", input.OutcomeRef)},
ActualOutcome: string(actual), ObservedAt: input.At.UnixMilli(), Severity: 2,
})
}
}
func (r learningRecorder) saveExperienceAndReflection(ctx context.Context, value epistemics.ExperienceRecord) (epistemics.ExperienceRecord, bool) {
+37
View File
@@ -8,6 +8,7 @@ import (
"git.cin.su/m/Assistant/contracts/capability"
"git.cin.su/m/Assistant/contracts/epistemics"
"git.cin.su/m/Assistant/contracts/interaction"
selfcontract "git.cin.su/m/Assistant/contracts/self"
)
type learningEpistemicsStub struct {
@@ -31,6 +32,25 @@ type learningCapabilityStub struct {
saved []capability.SkillProfile
}
type learningSelfStub struct {
signals int
needs int
ledgers int
}
func (s *learningSelfStub) SaveLearningSignal(context.Context, selfcontract.LearningSignal) error {
s.signals++
return nil
}
func (s *learningSelfStub) SaveImprovementNeed(context.Context, selfcontract.ImprovementNeed) error {
s.needs++
return nil
}
func (s *learningSelfStub) SaveLearningLedger(context.Context, selfcontract.LearningLedgerEntry) error {
s.ledgers++
return nil
}
func (s *learningCapabilityStub) LoadSkillProfile(context.Context, capability.SkillProfileID) (capability.SkillProfile, error) {
s.loadCalls++
return capability.SkillProfile{}, nil
@@ -67,3 +87,20 @@ func TestGenericCorrectionDoesNotDegradeReminderSkill(t *testing.T) {
t.Fatalf("generic correction must remain evidence without a reminder skill reference: %#v", epistemicsStore.experiences)
}
}
func TestCorrectionWritesBoundedSelfEvidenceWithoutChangingResponsePath(t *testing.T) {
epistemicsStore := &learningEpistemicsStub{}
selfStore := &learningSelfStub{}
recorder := learningRecorder{epistemics: epistemicsStore, self: selfStore}
recorder.recordCorrection(context.Background(), correctionLearningInput{
Intent: interaction.OriginalHumanIntent{ID: "intent-2"},
Utterance: interaction.HumanUtterance{ID: "utterance-2", PrincipalID: "principal-2"},
At: time.UnixMilli(2000),
})
if selfStore.signals != 1 || selfStore.needs != 1 || selfStore.ledgers != 1 {
t.Fatalf("self evidence counts: signals=%d needs=%d ledgers=%d", selfStore.signals, selfStore.needs, selfStore.ledgers)
}
if len(epistemicsStore.experiences) != 1 {
t.Fatalf("completed learning path was changed")
}
}
+21 -1
View File
@@ -44,6 +44,7 @@ const (
creatorSessionKeyPath = "/run/secrets/creator_session_signing_key"
epistemicsDBPasswordPath = "/run/secrets/epistemics_db_password"
interactionDBPasswordPath = "/run/secrets/interaction_db_password"
selfDBPasswordPath = "/run/secrets/self_db_password"
)
const maxCreatorCredentialsBytes = 4 << 10
@@ -117,6 +118,25 @@ func main() {
log.Fatal(err)
}
defer interactionRepository.Close()
var selfRepository *postgres.SelfRepository
selfUser := os.Getenv("SELF_POSTGRES_USER")
selfPassword := ""
if selfUser != "" && os.Getenv("SELF_POSTGRES_CREDENTIAL_REF") != "" {
selfPassword, err = readCredentialRefSecret("SELF_POSTGRES_PASSWORD", "SELF_POSTGRES_CREDENTIAL_REF", selfDBPasswordPath)
if err != nil {
log.Printf("SELF learning repository unavailable; user responses remain unaffected: %v", err)
}
}
if selfUser != "" && selfPassword != "" {
selfRepository, err = postgres.OpenSelf(context.Background(), postgres.ContinuityConfig{Host: os.Getenv("POSTGRES_HOST"), Port: os.Getenv("POSTGRES_PORT"), Database: os.Getenv("POSTGRES_DATABASE"), User: selfUser, Password: selfPassword})
if err != nil {
log.Printf("SELF learning repository unavailable; user responses remain unaffected: %v", err)
} else {
defer selfRepository.Close()
}
} else if selfUser == "" || os.Getenv("SELF_POSTGRES_CREDENTIAL_REF") == "" {
log.Printf("SELF learning repository is not configured; user responses remain unaffected")
}
reminderClient, err := newContinuityReminderClient(envOr("CONTINUITY_RUNTIME_URL", "http://continuity-runtime:8081"), &http.Client{Timeout: 5 * time.Second})
if err != nil {
log.Fatal(err)
@@ -137,7 +157,7 @@ func main() {
if err != nil {
log.Fatal(err)
}
learning := learningRecorder{epistemics: epistemicsRepository, capability: capabilityRepository}
learning := learningRecorder{epistemics: epistemicsRepository, capability: capabilityRepository, self: selfRepository}
mux := http.NewServeMux()
authenticateCreator := func(w http.ResponseWriter, r *http.Request) (identity.CreatorSession, bool) {
session, err := identitydomain.ValidateCreatorSession(sessionKey, bearerToken(r), time.Now())