GEN2-018: add bounded perspectives over Work Graph

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/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/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 != ""
+}

dev/ACTIVE_TASK.json

@@ -1 +1 @@
-{"task_file":"dev/tasks/GEN2-015-add-evidence-backed-self-foundation-and-learning-ledger.json","task_id":"GEN2-015","task_revision":1}
+{"task_file":"dev/tasks/GEN2-018-add-perspective-and-dynamic-specialist-team-semantics-on-existing-work-g.json","task_id":"GEN2-018","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

@@ -1,4 +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()}
+
+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

@@ -1,3 +1,18 @@
 package domain_test
-import("testing"; selfcontract "git.cin.su/m/Assistant/contracts/self"; "git.cin.su/m/Assistant/modules/self/domain")
-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)}}
+
+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/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)
+	}
+}