171 lines
7.4 KiB
Go
171 lines
7.4 KiB
Go
package postgres
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
selfcontract "git.cin.su/m/Assistant/contracts/self"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
// SelfRepository persists only SELF-owned derived assessments and ledger
|
|
// evidence. It never evaluates, promotes or changes Capability state.
|
|
type SelfRepository struct{ pool *pgxpool.Pool }
|
|
|
|
type AcceptanceSummary struct {
|
|
LearningSignals int `json:"learning_signals"`
|
|
ImprovementNeeds int `json:"improvement_needs"`
|
|
LearningLedger int `json:"learning_ledger"`
|
|
SyntheticPrincipal string `json:"synthetic_principal"`
|
|
}
|
|
|
|
func OpenSelf(ctx context.Context, config ContinuityConfig) (*SelfRepository, error) {
|
|
pool, err := openPool(ctx, config)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &SelfRepository{pool: pool}, nil
|
|
}
|
|
|
|
func (r *SelfRepository) Close() { r.pool.Close() }
|
|
|
|
func (r *SelfRepository) AcceptanceSummary(ctx context.Context, principalID string) (AcceptanceSummary, error) {
|
|
var value AcceptanceSummary
|
|
value.SyntheticPrincipal = principalID
|
|
if err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM self.learning_signals WHERE principal_id=$1`, principalID).Scan(&value.LearningSignals); err != nil {
|
|
return AcceptanceSummary{}, err
|
|
}
|
|
if err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM self.improvement_needs WHERE principal_id=$1`, principalID).Scan(&value.ImprovementNeeds); err != nil {
|
|
return AcceptanceSummary{}, err
|
|
}
|
|
if err := r.pool.QueryRow(ctx, `SELECT COUNT(*) FROM self.learning_ledger WHERE principal_id=$1`, principalID).Scan(&value.LearningLedger); err != nil {
|
|
return AcceptanceSummary{}, err
|
|
}
|
|
return value, nil
|
|
}
|
|
|
|
func (r *SelfRepository) SaveImprovementNeed(ctx context.Context, value selfcontract.ImprovementNeed) error {
|
|
subject, err := json.Marshal(value.SubjectRef)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
evidence, err := json.Marshal(value.EvidenceRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = r.pool.Exec(ctx, `INSERT INTO self.improvement_needs(improvement_need_id,principal_id,subject_ref,problem_summary,evidence_refs,expected_benefit,priority,state,created_at_unix_millis)
|
|
VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, subject, value.ProblemSummary, evidence, value.ExpectedBenefit, value.Priority, value.State, value.CreatedAt)
|
|
return err
|
|
}
|
|
|
|
func (r *SelfRepository) SaveLearningLedger(ctx context.Context, value selfcontract.LearningLedgerEntry) error {
|
|
evidence, err := json.Marshal(value.EvidenceRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
improvement, err := json.Marshal(value.ImprovementNeedRef)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
proposed, err := json.Marshal(value.ProposedChangeRef)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
evaluations, err := json.Marshal(value.ActualEvaluationRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
gate, err := json.Marshal(value.DevelopmentGateRef)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
before, err := json.Marshal(value.BeforeVersionRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
after, err := json.Marshal(value.AfterVersionRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sideEffects, err := json.Marshal(value.SideEffects)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rollback, err := json.Marshal(value.RollbackRef)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = r.pool.Exec(ctx, `INSERT INTO self.learning_ledger(entry_id,principal_id,improvement_need_ref,observed_problem,evidence_refs,diagnosis,hypothesis,proposed_change_ref,expected_improvement,evaluation_refs,development_gate_ref,before_version_refs,after_version_refs,decision,side_effects,rollback_ref,recorded_at_unix_millis)
|
|
VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, improvement, value.ObservedProblem, evidence, value.Diagnosis, value.Hypothesis, proposed, value.ExpectedImprovement, evaluations, gate, before, after, value.Decision, sideEffects, rollback, value.RecordedAt)
|
|
return err
|
|
}
|
|
|
|
func (r *SelfRepository) SaveLearningSignal(ctx context.Context, value selfcontract.LearningSignal) error {
|
|
if err := value.Validate(); err != nil {
|
|
return err
|
|
}
|
|
subject, err := json.Marshal(value.SubjectRef)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
evidence, err := json.Marshal(value.EvidenceRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
deps, err := json.Marshal(value.DependencyRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = r.pool.Exec(ctx, `INSERT INTO self.learning_signals(signal_id,principal_id,kind,task_pattern,scope_key,subject_ref,evidence_refs,expected_outcome,actual_outcome,dependency_refs,environment_version,observed_at_unix_millis,severity,user_impact,correction_count,decision_regret)
|
|
VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, value.Kind, value.TaskPattern, value.ScopeKey, subject, evidence, value.ExpectedOutcome, value.ActualOutcome, deps, value.EnvironmentVersion, value.ObservedAt, value.Severity, value.UserImpact, value.CorrectionCount, value.DecisionRegret)
|
|
return err
|
|
}
|
|
|
|
func (r *SelfRepository) SaveWeaknessPattern(ctx context.Context, value selfcontract.WeaknessPattern) error {
|
|
evidence, err := json.Marshal(value.DetectionEvidenceRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
deps, err := json.Marshal(value.DependencyRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = r.pool.Exec(ctx, `INSERT INTO self.weakness_patterns(assessment_id,principal_id,revision,pattern_key,task_pattern,scope_key,environment_version,dependency_refs,failure_mode,detection_evidence_refs,frequency,last_observed_at_unix_millis,severity,affected_component,affected_strategy,confidence_millis,epistemic_status,state,recorded_at_unix_millis)
|
|
VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, value.Revision, value.PatternKey, value.TaskPattern, value.ScopeKey, value.EnvironmentVersion, deps, value.FailureMode, evidence, value.Frequency, value.LastObservedAt, value.Severity, value.AffectedComponent, value.AffectedStrategy, value.ConfidenceMillis, value.EpistemicStatus, value.State, value.RecordedAt)
|
|
return err
|
|
}
|
|
|
|
func (r *SelfRepository) SaveImprovementCandidate(ctx context.Context, value selfcontract.ImprovementCandidate) error {
|
|
if err := value.Validate(); err != nil {
|
|
return err
|
|
}
|
|
need, err := json.Marshal(value.NeedRef)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
must, err := json.Marshal(value.MustNotWorsen)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
evidence, err := json.Marshal(value.EvidenceRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = r.pool.Exec(ctx, `INSERT INTO self.improvement_candidates(candidate_id,principal_id,need_ref,hypothesis,expected_effect,evaluation_plan,must_not_worsen,rollback_plan,resource_cost,creator,independent_evaluator,state,evidence_refs,created_at_unix_millis)
|
|
VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, need, value.Hypothesis, value.ExpectedEffect, value.EvaluationPlan, must, value.RollbackPlan, value.ResourceCost, value.Creator, value.IndependentEvaluator, value.State, evidence, value.CreatedAt)
|
|
return err
|
|
}
|
|
|
|
func (r *SelfRepository) SaveBenchmarkCase(ctx context.Context, value selfcontract.BenchmarkCase) error {
|
|
if !value.Valid() {
|
|
return fmt.Errorf("benchmark case is incomplete")
|
|
}
|
|
evidence, err := json.Marshal(value.EvidenceRefs)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
_, err = r.pool.Exec(ctx, `INSERT INTO self.personal_benchmark_cases(case_id,principal_id,task_class,evidence_refs,recorded_at_unix_millis) VALUES($1,$2,$3,$4,$5) ON CONFLICT DO NOTHING`, value.ID, value.PrincipalID, value.TaskClass, evidence, value.RecordedAt)
|
|
return err
|
|
}
|