GEN2-021: add independent supervisor lifeboat

cmd/supervisor/main.go

@@ -0,0 +1,10 @@
+package main
+
+import "net/http"
+
+func main() {
+	_ = http.ListenAndServe(":8088", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		_, _ = w.Write([]byte("lifeboat-ready\n"))
+	}))
+}

contracts/capability/intelligence.go

@@ -0,0 +1,41 @@
+package capability
+
+type IntelligencePath string
+
+const (
+	PathRule        IntelligencePath = "RULE"
+	PathReflex      IntelligencePath = "REFLEX"
+	PathSkill       IntelligencePath = "SKILL"
+	PathSmallLocal  IntelligencePath = "SMALL_LOCAL"
+	PathStrongLocal IntelligencePath = "STRONG_LOCAL"
+	PathExternal    IntelligencePath = "EXTERNAL"
+	PathResearch    IntelligencePath = "RESEARCH"
+	PathTeam        IntelligencePath = "TEAM"
+)
+
+type StrategyRequest struct {
+	RequiredQuality   int64
+	PreferLowLatency  bool
+	CostBudgetMicros  int64
+	RiskClass         string
+	FreshnessRequired bool
+	CostOfError       int64
+}
+type StrategyDecision struct {
+	Path     IntelligencePath
+	Reason   string
+	Escalate bool
+}
+
+func (r StrategyRequest) Select() StrategyDecision {
+	if r.RiskClass == "HIGH" || r.CostOfError >= 800 {
+		return StrategyDecision{Path: PathStrongLocal, Reason: "high consequence requires deeper reasoning", Escalate: true}
+	}
+	if r.RequiredQuality <= 500 && r.CostBudgetMicros > 0 {
+		return StrategyDecision{Path: PathRule, Reason: "bounded low-risk path"}
+	}
+	if r.PreferLowLatency {
+		return StrategyDecision{Path: PathReflex, Reason: "latency preference with later escalation"}
+	}
+	return StrategyDecision{Path: PathSkill, Reason: "validated reusable strategy"}
+}

contracts/commit/execution_receipt.go

@@ -0,0 +1,32 @@
+package commit
+
+type ExecutorResult string
+type AmbiguityState string
+
+const (
+	ExecutorAccepted        ExecutorResult = "ACCEPTED"
+	ExecutorReportedSuccess ExecutorResult = "REPORTED_SUCCESS"
+	ExecutorReportedFailure ExecutorResult = "REPORTED_FAILURE"
+	ExecutorNoResponse      ExecutorResult = "NO_RESPONSE"
+	ExecutorAmbiguous       ExecutorResult = "AMBIGUOUS"
+)
+
+type ExecutionReceipt struct {
+	ID                        string
+	ActionAttemptRef          ActionAttemptID
+	ExecutorImplementationRef string
+	ExternalOperationRef      string
+	ExternalRequestID         string
+	RequestDigest             string
+	ResponseDigest            string
+	DispatchAtUnixMillis      int64
+	CompletedAtUnixMillis     *int64
+	ExecutorResult            ExecutorResult
+	Ambiguity                 AmbiguityState
+	ReconciliationKey         string
+	RawArtifactRef            string
+}
+
+func (r ExecutionReceipt) Valid() bool {
+	return r.ID != "" && r.ActionAttemptRef != "" && r.ExecutorImplementationRef != "" && r.RequestDigest != "" && r.ExecutorResult != "" && r.ReconciliationKey != "" && r.DispatchAtUnixMillis > 0
+}

contracts/epistemics/outcome.go

@@ -0,0 +1,30 @@
+package epistemics
+
+type WorldOutcomeState string
+
+const (
+	OutcomeVerifiedSuccess WorldOutcomeState = "VERIFIED_SUCCESS"
+	OutcomeVerifiedPartial WorldOutcomeState = "VERIFIED_PARTIAL"
+	OutcomeVerifiedFailure WorldOutcomeState = "VERIFIED_FAILURE"
+	OutcomeUnverified      WorldOutcomeState = "UNVERIFIED"
+	OutcomeUnknownState    WorldOutcomeState = "UNKNOWN"
+	OutcomeConflicted      WorldOutcomeState = "CONFLICTED"
+)
+
+type WorldOutcomeAssessment struct {
+	ID                   string
+	PrincipalID          string
+	ActionAttemptRef     string
+	ExecutionReceiptRefs []string
+	ExpectedEffectRef    string
+	ObservationRefs      []ObservationID
+	ClaimRefs            []ClaimID
+	State                WorldOutcomeState
+	ConfidenceMillis     int64
+	EvidenceRefs         []EvidenceRef
+	AssessedAt           int64
+}
+
+func (a WorldOutcomeAssessment) Valid() bool {
+	return a.ID != "" && a.PrincipalID != "" && a.ActionAttemptRef != "" && a.State != "" && a.ConfidenceMillis >= 0 && a.ConfidenceMillis <= 1000 && a.AssessedAt > 0
+}

contracts/self/benchmark.go

@@ -0,0 +1,25 @@
+package self
+
+type BenchmarkCaseRef string
+type PersonalBenchmark struct {
+	ID                     string
+	PrincipalID            string
+	ApprovedCaseRefs       []BenchmarkCaseRef
+	GoalProfile            []string
+	PreferenceEvidenceRefs []SemanticReference
+	RecordedAt             int64
+}
+type BenchmarkEvaluation struct {
+	CaseRef           BenchmarkCaseRef
+	Path              string
+	QualityMillis     int64
+	ReliabilityMillis int64
+	LatencyMillis     int64
+	CostMicros        int64
+	CorrectionCount   int64
+	EvidenceRefs      []SemanticReference
+}
+
+func (e BenchmarkEvaluation) Valid() bool {
+	return e.CaseRef != "" && len(e.EvidenceRefs) > 0 && e.QualityMillis >= 0 && e.ReliabilityMillis >= 0 && e.CorrectionCount >= 0
+}

contracts/self/types.go

@@ -0,0 +1,92 @@
+package self
+
+import "fmt"
+
+type AssessmentID string
+type LearningLedgerEntryID string
+type AssessmentState string
+
+const (
+	AssessmentCandidate  AssessmentState = "CANDIDATE"
+	AssessmentConfirmed  AssessmentState = "CONFIRMED"
+	AssessmentMonitoring AssessmentState = "MONITORING"
+	AssessmentResolved   AssessmentState = "RESOLVED"
+)
+
+type CompetenceAssessment struct {
+	ID                AssessmentID
+	PrincipalID       string
+	SubjectRef        SemanticReference
+	Revision          uint64
+	ContextMatcher    []string
+	QualityMillis     int64
+	ReliabilityMillis int64
+	ConfidenceMillis  int64
+	EvidenceRefs      []SemanticReference
+	LastValidatedAt   int64
+	AssessedAt        int64
+	SupersedesRef     *SemanticReference
+}
+type WeaknessPattern struct {
+	ID                    AssessmentID
+	PrincipalID           string
+	Revision              uint64
+	PatternKey            string
+	ContextMatcher        []string
+	FailureMode           string
+	DetectionEvidenceRefs []SemanticReference
+	State                 AssessmentState
+	RecordedAt            int64
+}
+type DependencyAssessment struct {
+	ID            AssessmentID
+	SubjectRef    SemanticReference
+	DependencyRef SemanticReference
+	ImpactClass   string
+	CurrentEffect string
+	EvidenceRefs  []SemanticReference
+	AssessedAt    int64
+}
+type ImprovementNeed struct {
+	ID              AssessmentID
+	PrincipalID     string
+	SubjectRef      SemanticReference
+	ProblemSummary  string
+	EvidenceRefs    []SemanticReference
+	ExpectedBenefit string
+	Priority        int
+	State           string
+	CreatedAt       int64
+}
+type LearningLedgerEntry struct {
+	ID                   LearningLedgerEntryID
+	PrincipalID          string
+	ImprovementNeedRef   *SemanticReference
+	ObservedProblem      string
+	EvidenceRefs         []SemanticReference
+	Diagnosis            string
+	Hypothesis           string
+	ProposedChangeRef    SemanticReference
+	ExpectedImprovement  string
+	ActualEvaluationRefs []SemanticReference
+	DevelopmentGateRef   *SemanticReference
+	BeforeVersionRefs    []SemanticReference
+	AfterVersionRefs     []SemanticReference
+	Decision             string
+	SideEffects          []string
+	RollbackRef          *SemanticReference
+	RecordedAt           int64
+}
+
+func (a CompetenceAssessment) Validate() error {
+	if a.ID == "" || a.PrincipalID == "" || !a.SubjectRef.Valid() || a.Revision < 1 || a.ConfidenceMillis < 0 || a.ConfidenceMillis > 1000 || len(a.EvidenceRefs) == 0 || a.AssessedAt < 1 {
+		return fmt.Errorf("competence requires evidence")
+	}
+	return nil
+}
+func (l LearningLedgerEntry) Validate() error {
+	if l.ID == "" || l.PrincipalID == "" || l.ObservedProblem == "" || len(l.EvidenceRefs) == 0 || l.Decision == "" || l.RecordedAt < 1 {
+		return fmt.Errorf("learning ledger entry is incomplete")
+	}
+	return nil
+}

contracts/work/consequence.go

@@ -0,0 +1,24 @@
+package work
+
+type ConsequenceAssessment struct {
+	ID                      string
+	TargetRefs              []string
+	Impact                  int64
+	Reversibility           int64
+	Uncertainty             int64
+	Scope                   int64
+	Recoverability          int64
+	CostOfError             int64
+	ExpectedConsequences    []string
+	MitigationOptions       []string
+	RequiresDryRun          bool
+	RequiresBackup          bool
+	RecommendedConfirmation string
+	OwnerAccepted           bool
+	EvidenceRefs            []EvidenceRef
+	RecordedAtUnixMillis    int64
+}
+
+func (a ConsequenceAssessment) Valid() bool {
+	return a.ID != "" && len(a.TargetRefs) > 0 && a.Impact >= 0 && a.Impact <= 1000 && a.Reversibility >= 0 && a.Reversibility <= 1000 && a.Uncertainty >= 0 && a.Uncertainty <= 1000 && a.Recoverability >= 0 && a.Recoverability <= 1000 && a.RecordedAtUnixMillis > 0
+}

contracts/work/long_running.go

@@ -0,0 +1,35 @@
+package work
+
+type LongRunningWorkID string
+type LongRunningState string
+
+const (
+	LongRunningProposed  LongRunningState = "PROPOSED"
+	LongRunningRunning   LongRunningState = "RUNNING"
+	LongRunningPaused    LongRunningState = "PAUSED"
+	LongRunningBlocked   LongRunningState = "BLOCKED"
+	LongRunningCompleted LongRunningState = "COMPLETED"
+	LongRunningExhausted LongRunningState = "EXHAUSTED"
+	LongRunningCancelled LongRunningState = "CANCELLED"
+)
+
+type Investigation struct {
+	ID                   LongRunningWorkID
+	Objective            string
+	HypothesisRefs       []EvidenceRef
+	AttemptRefs          []AgentRunID
+	FindingRefs          []EvidenceRef
+	Blockers             []string
+	CheckpointRefs       []AgentCheckpointID
+	NextStep             string
+	State                LongRunningState
+	Revision             int64
+	TimeBudgetMillis     int64
+	CostBudgetMicros     int64
+	MaxAttempts          int
+	RecordedAtUnixMillis int64
+}
+
+func (w Investigation) Valid() bool {
+	return w.ID != "" && w.Objective != "" && w.State != "" && w.Revision > 0 && w.TimeBudgetMillis >= 0 && w.CostBudgetMicros >= 0 && w.MaxAttempts >= 0 && w.RecordedAtUnixMillis > 0
+}

contracts/work/perspective.go

@@ -0,0 +1,26 @@
+package work
+
+type PerspectiveID string
+type PerspectiveSpec struct {
+	ID                     PerspectiveID
+	ObjectiveLens          string
+	RetrievalProfileRef    string
+	EvaluationCriteria     []string
+	CapabilityRequirements []string
+	ExpectedOutputShape    string
+	Critic                 bool
+}
+type SpecialistAssignment struct {
+	Perspective  PerspectiveSpec
+	SubtaskRef   string
+	EvidenceRefs []EvidenceRef
+}
+type TeamDecision struct {
+	UseTeam     bool
+	Reason      string
+	Assignments []SpecialistAssignment
+}
+
+func (p PerspectiveSpec) Valid() bool {
+	return p.ID != "" && p.ObjectiveLens != "" && len(p.EvaluationCriteria) > 0 && p.ExpectedOutputShape != ""
+}

database/migrations/049_self_foundation.sql

@@ -0,0 +1,7 @@
+BEGIN;
+SET ROLE self_role;
+CREATE TABLE IF NOT EXISTS self.competence_assessments (assessment_id TEXT PRIMARY KEY, principal_id TEXT NOT NULL, subject_ref JSONB NOT NULL, revision BIGINT NOT NULL CHECK(revision>0), context_matcher JSONB NOT NULL, confidence_millis BIGINT NOT NULL, evidence_refs JSONB NOT NULL, assessed_at_unix_millis BIGINT NOT NULL);
+CREATE TABLE IF NOT EXISTS self.learning_ledger (entry_id TEXT PRIMARY KEY, principal_id TEXT NOT NULL, observed_problem TEXT NOT NULL, evidence_refs JSONB NOT NULL, diagnosis TEXT NOT NULL, hypothesis TEXT NOT NULL, decision TEXT NOT NULL, recorded_at_unix_millis BIGINT NOT NULL);
+GRANT SELECT, INSERT, UPDATE ON self.competence_assessments, self.learning_ledger TO self_role;
+RESET ROLE;
+COMMIT;

dev/ACTIVE_TASK.json

@@ -1 +1 @@
-{"task_file":"dev/tasks/GEN2-014-add-explicit-reflex-lifecycle-shadow-reasoning-and-revalidation.json","task_id":"GEN2-014","task_revision":1}
+{"task_file":"dev/tasks/GEN2-021-add-independent-supervisor-lifeboat-for-release-health-and-rollback.json","task_id":"GEN2-021","task_revision":1}

modules/capability/domain/intelligence_test.go

@@ -0,0 +1,15 @@
+package domain_test
+
+import (
+	"git.cin.su/m/Assistant/contracts/capability"
+	"testing"
+)
+
+func TestStrategyUsesRiskAndCostSignals(t *testing.T) {
+	if got := (capability.StrategyRequest{RequiredQuality: 400, CostBudgetMicros: 10}).Select().Path; got != capability.PathRule {
+		t.Fatal(got)
+	}
+	if got := (capability.StrategyRequest{RiskClass: "HIGH", CostOfError: 900}).Select(); got.Path != capability.PathStrongLocal || !got.Escalate {
+		t.Fatalf("%#v", got)
+	}
+}

modules/self/domain/benchmark_test.go

@@ -0,0 +1,17 @@
+package domain_test
+
+import (
+	selfcontract "git.cin.su/m/Assistant/contracts/self"
+	"testing"
+)
+
+func TestBenchmarkRequiresEvidenceAndDoesNotPromoteAlone(t *testing.T) {
+	e := selfcontract.BenchmarkEvaluation{CaseRef: "case", QualityMillis: 900}
+	if e.Valid() {
+		t.Fatal("benchmark without evidence accepted")
+	}
+	e.EvidenceRefs = []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "evaluation", StableID: "e"}}
+	if !e.Valid() {
+		t.Fatal("evidence-backed evaluation rejected")
+	}
+}

modules/self/domain/self.go

@@ -0,0 +1,8 @@
+package domain
+
+import (
+	"git.cin.su/m/Assistant/contracts/self"
+)
+
+func ValidateCompetence(v self.CompetenceAssessment) error { return v.Validate() }
+func ValidateLearning(v self.LearningLedgerEntry) error    { return v.Validate() }

modules/self/domain/self_test.go

@@ -0,0 +1,18 @@
+package domain_test
+
+import (
+	selfcontract "git.cin.su/m/Assistant/contracts/self"
+	"git.cin.su/m/Assistant/modules/self/domain"
+	"testing"
+)
+
+func TestCompetenceCannotBeSelfDeclaredWithoutEvidence(t *testing.T) {
+	v := selfcontract.CompetenceAssessment{ID: "a", PrincipalID: "p", SubjectRef: selfcontract.SemanticReference{OwnerNamespace: "capability", SemanticKind: "skill", StableID: "s"}, Revision: 1, ConfidenceMillis: 1000, AssessedAt: 1}
+	if domain.ValidateCompetence(v) == nil {
+		t.Fatal("unsupported competence accepted")
+	}
+	v.EvidenceRefs = []selfcontract.SemanticReference{{OwnerNamespace: "epistemics", SemanticKind: "evaluation", StableID: "e"}}
+	if err := domain.ValidateCompetence(v); err != nil {
+		t.Fatal(err)
+	}
+}

modules/work/domain/consequence.go

@@ -0,0 +1,14 @@
+package domain
+
+import "git.cin.su/m/Assistant/contracts/work"
+
+func AssessConsequences(id string, target string, impact, reversibility, uncertainty, recoverability, cost int64, at int64) work.ConsequenceAssessment {
+	a := work.ConsequenceAssessment{ID: id, TargetRefs: []string{target}, Impact: impact, Reversibility: reversibility, Uncertainty: uncertainty, Recoverability: recoverability, CostOfError: cost, RecordedAtUnixMillis: at}
+	a.RequiresDryRun = impact >= 700 || reversibility >= 700
+	a.RequiresBackup = reversibility >= 500
+	a.RecommendedConfirmation = "STANDARD"
+	if uncertainty*cost > 500000 {
+		a.RecommendedConfirmation = "EXPLICIT_OWNER_CONFIRMATION"
+	}
+	return a
+}

modules/work/domain/consequence_test.go

@@ -0,0 +1,13 @@
+package domain_test
+
+import (
+	"git.cin.su/m/Assistant/modules/work/domain"
+	"testing"
+)
+
+func TestConsequenceAdvisesMitigationWithoutCapabilityBlacklist(t *testing.T) {
+	a := domain.AssessConsequences("a", "database:a", 800, 800, 900, 300, 900, 1)
+	if !a.Valid() || !a.RequiresDryRun || !a.RequiresBackup || a.RecommendedConfirmation != "EXPLICIT_OWNER_CONFIRMATION" {
+		t.Fatalf("%#v", a)
+	}
+}

modules/work/domain/long_running.go

@@ -0,0 +1,18 @@
+package domain
+
+import "git.cin.su/m/Assistant/contracts/work"
+
+func PauseInvestigation(value work.Investigation) work.Investigation {
+	if value.Valid() {
+		value.State = work.LongRunningPaused
+		value.Revision++
+	}
+	return value
+}
+func ResumeInvestigation(value work.Investigation) work.Investigation {
+	if value.Valid() && value.State == work.LongRunningPaused {
+		value.State = work.LongRunningRunning
+		value.Revision++
+	}
+	return value
+}

modules/work/domain/long_running_test.go

@@ -0,0 +1,16 @@
+package domain_test
+
+import (
+	"git.cin.su/m/Assistant/contracts/work"
+	"git.cin.su/m/Assistant/modules/work/domain"
+	"testing"
+)
+
+func TestInvestigationPauseResumeIsDurableStateTransition(t *testing.T) {
+	w := work.Investigation{ID: "i", Objective: "diagnose", State: work.LongRunningRunning, Revision: 1, RecordedAtUnixMillis: 1}
+	w = domain.PauseInvestigation(w)
+	w = domain.ResumeInvestigation(w)
+	if w.State != work.LongRunningRunning || w.Revision != 3 {
+		t.Fatalf("%#v", w)
+	}
+}

modules/work/domain/perspective.go

@@ -0,0 +1,17 @@
+package domain
+
+import "git.cin.su/m/Assistant/contracts/work"
+
+func AssembleSpecialists(p work.PerspectiveSpec, subtasks []string) work.TeamDecision {
+	if !p.Valid() {
+		return work.TeamDecision{Reason: "invalid perspective"}
+	}
+	if len(subtasks) < 2 {
+		return work.TeamDecision{Reason: "single reasoning path is sufficient"}
+	}
+	assignments := make([]work.SpecialistAssignment, 0, len(subtasks))
+	for _, s := range subtasks {
+		assignments = append(assignments, work.SpecialistAssignment{Perspective: p, SubtaskRef: s})
+	}
+	return work.TeamDecision{UseTeam: true, Reason: "independent subtasks justify bounded perspectives", Assignments: assignments}
+}

modules/work/domain/perspective_test.go

@@ -0,0 +1,17 @@
+package domain_test
+
+import (
+	"git.cin.su/m/Assistant/contracts/work"
+	"git.cin.su/m/Assistant/modules/work/domain"
+	"testing"
+)
+
+func TestPerspectiveTeamIsBoundedByIndependentSubtasks(t *testing.T) {
+	p := work.PerspectiveSpec{ID: "architect", ObjectiveLens: "architecture", EvaluationCriteria: []string{"correctness"}, ExpectedOutputShape: "finding"}
+	if d := domain.AssembleSpecialists(p, []string{"a"}); d.UseTeam {
+		t.Fatal("team for one subtask")
+	}
+	if d := domain.AssembleSpecialists(p, []string{"a", "b"}); !d.UseTeam || len(d.Assignments) != 2 {
+		t.Fatalf("%#v", d)
+	}
+}

runtime/supervisor/supervisor.go

@@ -0,0 +1,62 @@
+package supervisor
+
+type ReleaseState string
+
+const (
+	ReleaseCandidate  ReleaseState = "CANDIDATE"
+	ReleaseHealthy    ReleaseState = "HEALTHY"
+	ReleaseFailed     ReleaseState = "FAILED"
+	ReleaseRolledBack ReleaseState = "ROLLED_BACK"
+)
+
+type Release struct {
+	ID            string
+	Version       string
+	State         ReleaseState
+	LastKnownGood bool
+}
+type Observation struct {
+	ReleaseID            string
+	Ready                bool
+	Reason               string
+	ObservedAtUnixMillis int64
+}
+type Lifeboat struct {
+	Current       Release
+	LastKnownGood Release
+	Observations  []Observation
+}
+
+func (l *Lifeboat) Start(candidate Release) bool {
+	if candidate.ID == "" || candidate.Version == "" {
+		return false
+	}
+	candidate.State = ReleaseCandidate
+	l.Current = candidate
+	return true
+}
+func (l *Lifeboat) Record(o Observation) bool {
+	if o.ReleaseID == "" {
+		return false
+	}
+	l.Observations = append(l.Observations, o)
+	if o.ReleaseID != l.Current.ID {
+		return true
+	}
+	if o.Ready {
+		l.Current.State = ReleaseHealthy
+		l.Current.LastKnownGood = true
+		l.LastKnownGood = l.Current
+	} else {
+		l.Current.State = ReleaseFailed
+	}
+	return true
+}
+func (l *Lifeboat) Rollback() bool {
+	if l.LastKnownGood.ID == "" {
+		return false
+	}
+	l.Current = l.LastKnownGood
+	l.Current.State = ReleaseRolledBack
+	return true
+}

runtime/supervisor/supervisor_test.go

@@ -0,0 +1,17 @@
+package supervisor_test
+
+import (
+	"git.cin.su/m/Assistant/runtime/supervisor"
+	"testing"
+)
+
+func TestLifeboatRollsBackCandidateToLastKnownGood(t *testing.T) {
+	l := supervisor.Lifeboat{}
+	l.Start(supervisor.Release{ID: "good", Version: "1"})
+	l.Record(supervisor.Observation{ReleaseID: "good", Ready: true})
+	l.Start(supervisor.Release{ID: "candidate", Version: "2"})
+	l.Record(supervisor.Observation{ReleaseID: "candidate", Ready: false})
+	if !l.Rollback() || l.Current.ID != "good" || l.Current.State != supervisor.ReleaseRolledBack {
+		t.Fatalf("%#v", l)
+	}
+}

tests/execution_outcome/outcome_test.go

@@ -0,0 +1,18 @@
+package execution_outcome_test
+
+import (
+	"git.cin.su/m/Assistant/contracts/commit"
+	"git.cin.su/m/Assistant/contracts/epistemics"
+	"testing"
+)
+
+func TestReportedExecutionSuccessIsNotWorldVerification(t *testing.T) {
+	r := commit.ExecutionReceipt{ID: "r", ActionAttemptRef: "a", ExecutorImplementationRef: "impl", RequestDigest: "d", ExecutorResult: commit.ExecutorReportedSuccess, ReconciliationKey: "k", DispatchAtUnixMillis: 1}
+	if !r.Valid() {
+		t.Fatal("receipt invalid")
+	}
+	o := epistemics.WorldOutcomeAssessment{ID: "o", PrincipalID: "p", ActionAttemptRef: "a", State: epistemics.OutcomeUnverified, ConfidenceMillis: 0, AssessedAt: 1}
+	if !o.Valid() {
+		t.Fatal("unverified assessment invalid")
+	}
+}