feat: add goals, drives, affect state, predictions and curiosity
Phase 9. Goals form a mind-scoped tree with kind, priority, progress and blockers; their deterministic relevance to a candidate feeds the goal_relevance attention feature and a goal monitor raises stalled goals and observations that touch one. Drives are a closed set of eight scalars with operator-configured ranges and personality-derived baselines; there is no self-preservation, replication or acquisition drive and no way to add one at runtime. Affect is ten scalars moved by an explicit rule table over events and decaying towards baseline; both modulate attention weights each cycle and the effective weights are recorded with every cycle and shown beside the configured ones. Predictions carry a window and machine-checkable criteria (event terms occurring or staying absent, a belief reaching a confidence, or operator judgement). A resolver job judges them deterministically, keeps an append-only outcome history for calibration (accuracy, Brier score, confidence buckets, overconfidence flag), emits prediction_error events scaled by how confident the miss was, and feeds the outcome back into the linked belief as evidence. Causal hypotheses derive predictions automatically. Curiosity turns misses, contradictions and unexplained observations into questions that compete for attention and become investigation goals when admitted. Brain gains after-cycle hooks and goal/motivation state. API, UI (goals, prediction dashboard, cognitive state panel, effective weights) and CLI (goal, prediction, state). Demo scenario 4 verified end to end.
This commit is contained in:
Andy Dixon
@@ -0,0 +1,356 @@
|
||||
// Package goals stores a mind's goal tree: what it is trying to do, why, how
|
||||
// far it has got and what blocks it. Goals bias attention through the
|
||||
// goal-relevance feature and are created by operators, curiosity and
|
||||
// reflection; they never grant capabilities.
|
||||
package goals
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"github.com/andydixon/noema/internal/storage"
|
||||
"github.com/andydixon/noema/pkg/ids"
|
||||
)
|
||||
|
||||
// Status of a goal.
|
||||
type Status string
|
||||
|
||||
// Statuses.
|
||||
const (
|
||||
StatusActive Status = "active"
|
||||
StatusBlocked Status = "blocked"
|
||||
StatusPaused Status = "paused"
|
||||
StatusCompleted Status = "completed"
|
||||
StatusAbandoned Status = "abandoned"
|
||||
)
|
||||
|
||||
// Kind of goal.
|
||||
type Kind string
|
||||
|
||||
// Kinds. Investigation and question goals come from curiosity; task goals
|
||||
// from operators; maintenance from reflection.
|
||||
const (
|
||||
KindTask Kind = "task"
|
||||
KindInvestigation Kind = "investigation"
|
||||
KindQuestion Kind = "question"
|
||||
KindMaintenance Kind = "maintenance"
|
||||
)
|
||||
|
||||
// Goal is one node of the tree.
|
||||
type Goal struct {
|
||||
ID ids.ID `json:"id"`
|
||||
MindID ids.ID `json:"mind_id"`
|
||||
ParentID ids.ID `json:"parent_id,omitempty"`
|
||||
Title string `json:"title"`
|
||||
Description string `json:"description"`
|
||||
Kind Kind `json:"kind"`
|
||||
Status Status `json:"status"`
|
||||
Priority float64 `json:"priority"`
|
||||
Progress float64 `json:"progress"`
|
||||
Owner string `json:"owner"`
|
||||
Blockers []string `json:"blockers"`
|
||||
OriginEvent ids.ID `json:"origin_event,omitempty"`
|
||||
Subject string `json:"subject"`
|
||||
DueAt *time.Time `json:"due_at,omitempty"`
|
||||
LastProgressAt time.Time `json:"last_progress_at"`
|
||||
CreatedAt time.Time `json:"created_at"`
|
||||
UpdatedAt time.Time `json:"updated_at"`
|
||||
CompletedAt *time.Time `json:"completed_at,omitempty"`
|
||||
}
|
||||
|
||||
// ErrInvalid marks bad input.
|
||||
var ErrInvalid = errors.New("goals: invalid")
|
||||
|
||||
// Store persists goals.
|
||||
type Store struct{ db *pgxpool.Pool }
|
||||
|
||||
// NewStore creates a store.
|
||||
func NewStore(db *pgxpool.Pool) *Store { return &Store{db: db} }
|
||||
|
||||
// New describes a goal to create.
|
||||
type New struct {
|
||||
MindID ids.ID
|
||||
ParentID ids.ID
|
||||
Title string
|
||||
Description string
|
||||
Kind Kind
|
||||
Priority float64
|
||||
Owner string
|
||||
Subject string
|
||||
OriginEvent ids.ID
|
||||
DueAt *time.Time
|
||||
}
|
||||
|
||||
// Create inserts a goal using q.
|
||||
func (s *Store) Create(ctx context.Context, q storage.Querier, n New) (Goal, error) {
|
||||
n.Title = strings.TrimSpace(n.Title)
|
||||
if n.MindID.IsZero() || n.Title == "" || len(n.Title) > 300 {
|
||||
return Goal{}, fmt.Errorf("%w: title required (max 300 chars)", ErrInvalid)
|
||||
}
|
||||
switch n.Kind {
|
||||
case KindTask, KindInvestigation, KindQuestion, KindMaintenance:
|
||||
default:
|
||||
n.Kind = KindTask
|
||||
}
|
||||
if n.Owner == "" {
|
||||
n.Owner = "mind"
|
||||
}
|
||||
if n.Priority <= 0 || n.Priority > 1 {
|
||||
n.Priority = 0.5
|
||||
}
|
||||
g := Goal{ID: ids.New(), MindID: n.MindID, ParentID: n.ParentID, Title: n.Title, Description: n.Description, Kind: n.Kind, Status: StatusActive, Priority: n.Priority, Owner: n.Owner,
|
||||
Blockers: []string{}, OriginEvent: n.OriginEvent, Subject: n.Subject, DueAt: n.DueAt, LastProgressAt: time.Now(), CreatedAt: time.Now(), UpdatedAt: time.Now()}
|
||||
_, err := q.Exec(ctx, `INSERT INTO goals (id, mind_id, parent_id, title, description, kind, status, priority, owner, origin_event, subject, due_at)
|
||||
SELECT $1,$2,$3,$4,$5,$6,'active',$7,$8,$9,$10,$11 WHERE $3::uuid IS NULL OR EXISTS (SELECT 1 FROM goals WHERE id=$3 AND mind_id=$2)`,
|
||||
g.ID, g.MindID, nullID(g.ParentID), g.Title, g.Description, string(g.Kind), g.Priority, g.Owner, nullID(g.OriginEvent), g.Subject, g.DueAt)
|
||||
if err != nil {
|
||||
return Goal{}, err
|
||||
}
|
||||
return g, nil
|
||||
}
|
||||
|
||||
func nullID(id ids.ID) *string {
|
||||
if id.IsZero() {
|
||||
return nil
|
||||
}
|
||||
s := string(id)
|
||||
return &s
|
||||
}
|
||||
|
||||
const cols = `id, mind_id, parent_id, title, description, kind, status, priority, progress, owner, blockers, origin_event, subject, due_at, last_progress_at, created_at, updated_at, completed_at`
|
||||
|
||||
func scan(row pgx.Row) (Goal, error) {
|
||||
var g Goal
|
||||
var parent, origin *string
|
||||
var kind, status string
|
||||
var blockers []byte
|
||||
if err := row.Scan(&g.ID, &g.MindID, &parent, &g.Title, &g.Description, &kind, &status, &g.Priority, &g.Progress, &g.Owner, &blockers, &origin, &g.Subject, &g.DueAt, &g.LastProgressAt, &g.CreatedAt, &g.UpdatedAt, &g.CompletedAt); err != nil {
|
||||
return g, storage.Translate(err)
|
||||
}
|
||||
g.Kind, g.Status = Kind(kind), Status(status)
|
||||
if parent != nil {
|
||||
g.ParentID = ids.ID(*parent)
|
||||
}
|
||||
if origin != nil {
|
||||
g.OriginEvent = ids.ID(*origin)
|
||||
}
|
||||
json.Unmarshal(blockers, &g.Blockers) //nolint:errcheck
|
||||
if g.Blockers == nil {
|
||||
g.Blockers = []string{}
|
||||
}
|
||||
return g, nil
|
||||
}
|
||||
|
||||
// Get fetches a goal scoped to a mind.
|
||||
func (s *Store) Get(ctx context.Context, mind, id ids.ID) (Goal, error) {
|
||||
return scan(s.db.QueryRow(ctx, `SELECT `+cols+` FROM goals WHERE id=$1 AND mind_id=$2`, id, mind))
|
||||
}
|
||||
|
||||
// List returns goals, optionally filtered by status, priority descending.
|
||||
func (s *Store) List(ctx context.Context, mind ids.ID, statuses []Status, limit int) ([]Goal, error) {
|
||||
if limit <= 0 || limit > 500 {
|
||||
limit = 200
|
||||
}
|
||||
ss := make([]string, len(statuses))
|
||||
for i, st := range statuses {
|
||||
ss[i] = string(st)
|
||||
}
|
||||
rows, err := s.db.Query(ctx, `SELECT `+cols+` FROM goals WHERE mind_id=$1 AND (cardinality($2::text[])=0 OR status = ANY($2)) ORDER BY priority DESC, created_at LIMIT $3`, mind, ss, limit)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []Goal
|
||||
for rows.Next() {
|
||||
g, err := scan(rows)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, g)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// Active returns live goals (active or blocked) for attention scoring.
|
||||
func (s *Store) Active(ctx context.Context, mind ids.ID) ([]Goal, error) {
|
||||
return s.List(ctx, mind, []Status{StatusActive, StatusBlocked}, 100)
|
||||
}
|
||||
|
||||
// Update changes mutable fields. Nil pointers leave a field untouched.
|
||||
type Update struct {
|
||||
Status *Status
|
||||
Progress *float64
|
||||
Priority *float64
|
||||
Blockers *[]string
|
||||
Title *string
|
||||
Desc *string
|
||||
}
|
||||
|
||||
// Apply updates a goal and returns the new row; status transitions set timestamps.
|
||||
func (s *Store) Apply(ctx context.Context, q storage.Querier, mind, id ids.ID, u Update) (Goal, error) {
|
||||
g, err := scan(q.QueryRow(ctx, `SELECT `+cols+` FROM goals WHERE id=$1 AND mind_id=$2`, id, mind))
|
||||
if err != nil {
|
||||
return Goal{}, err
|
||||
}
|
||||
if u.Status != nil {
|
||||
switch *u.Status {
|
||||
case StatusActive, StatusBlocked, StatusPaused, StatusCompleted, StatusAbandoned:
|
||||
g.Status = *u.Status
|
||||
default:
|
||||
return Goal{}, fmt.Errorf("%w: unknown status", ErrInvalid)
|
||||
}
|
||||
if g.Status == StatusCompleted {
|
||||
now := time.Now()
|
||||
g.CompletedAt, g.Progress = &now, 1
|
||||
}
|
||||
}
|
||||
if u.Progress != nil {
|
||||
g.Progress = clamp(*u.Progress)
|
||||
g.LastProgressAt = time.Now()
|
||||
}
|
||||
if u.Priority != nil {
|
||||
g.Priority = clamp(*u.Priority)
|
||||
}
|
||||
if u.Blockers != nil {
|
||||
g.Blockers = *u.Blockers
|
||||
if len(g.Blockers) > 0 && g.Status == StatusActive {
|
||||
g.Status = StatusBlocked
|
||||
} else if len(g.Blockers) == 0 && g.Status == StatusBlocked {
|
||||
g.Status = StatusActive
|
||||
}
|
||||
}
|
||||
if u.Title != nil && strings.TrimSpace(*u.Title) != "" {
|
||||
g.Title = strings.TrimSpace(*u.Title)
|
||||
}
|
||||
if u.Desc != nil {
|
||||
g.Description = *u.Desc
|
||||
}
|
||||
blockers, _ := json.Marshal(g.Blockers)
|
||||
_, err = q.Exec(ctx, `UPDATE goals SET status=$3, progress=$4, priority=$5, blockers=$6, title=$7, description=$8, last_progress_at=$9, completed_at=$10, updated_at=now() WHERE id=$1 AND mind_id=$2`,
|
||||
id, mind, string(g.Status), g.Progress, g.Priority, blockers, g.Title, g.Description, g.LastProgressAt, g.CompletedAt)
|
||||
return g, err
|
||||
}
|
||||
|
||||
func clamp(v float64) float64 {
|
||||
if v < 0 {
|
||||
return 0
|
||||
}
|
||||
if v > 1 {
|
||||
return 1
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// Stalled returns active goals without progress for longer than d.
|
||||
func (s *Store) Stalled(ctx context.Context, mind ids.ID, d time.Duration) ([]Goal, error) {
|
||||
rows, err := s.db.Query(ctx, `SELECT `+cols+` FROM goals WHERE mind_id=$1 AND status='active' AND last_progress_at < $2 ORDER BY priority DESC LIMIT 20`, mind, time.Now().Add(-d))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []Goal
|
||||
for rows.Next() {
|
||||
g, err := scan(rows)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, g)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// FindBySubject returns a live goal about a subject, for de-duplication.
|
||||
func (s *Store) FindBySubject(ctx context.Context, q storage.Querier, mind ids.ID, kind Kind, subject string) (Goal, error) {
|
||||
return scan(q.QueryRow(ctx, `SELECT `+cols+` FROM goals WHERE mind_id=$1 AND kind=$2 AND subject=$3 AND status IN ('active','blocked','paused') ORDER BY created_at DESC LIMIT 1`, mind, string(kind), subject))
|
||||
}
|
||||
|
||||
// Stats counts goals by status.
|
||||
type Stats struct {
|
||||
ByStatus map[string]int64 `json:"by_status"`
|
||||
Total int64 `json:"total"`
|
||||
}
|
||||
|
||||
// Stats returns counts.
|
||||
func (s *Store) Stats(ctx context.Context, mind ids.ID) (Stats, error) {
|
||||
st := Stats{ByStatus: map[string]int64{}}
|
||||
rows, err := s.db.Query(ctx, `SELECT status, count(*) FROM goals WHERE mind_id=$1 GROUP BY status`, mind)
|
||||
if err != nil {
|
||||
return st, err
|
||||
}
|
||||
defer rows.Close()
|
||||
for rows.Next() {
|
||||
var k string
|
||||
var n int64
|
||||
if err := rows.Scan(&k, &n); err != nil {
|
||||
return st, err
|
||||
}
|
||||
st.ByStatus[k] = n
|
||||
st.Total += n
|
||||
}
|
||||
return st, rows.Err()
|
||||
}
|
||||
|
||||
// Relevance scores how much text relates to the active goals: the best token
|
||||
// overlap with any goal, weighted by that goal's priority. Deterministic and
|
||||
// cheap; it feeds the goal_relevance attention feature.
|
||||
func Relevance(text string, active []Goal) (float64, ids.ID) {
|
||||
toks := tokenSet(text)
|
||||
if len(toks) == 0 {
|
||||
return 0, ids.Nil
|
||||
}
|
||||
var best float64
|
||||
var bestID ids.ID
|
||||
for _, g := range active {
|
||||
gt := tokenSet(g.Title + " " + g.Subject + " " + g.Description)
|
||||
if len(gt) == 0 {
|
||||
continue
|
||||
}
|
||||
inter := 0
|
||||
for w := range toks {
|
||||
if gt[w] {
|
||||
inter++
|
||||
}
|
||||
}
|
||||
if inter == 0 {
|
||||
continue
|
||||
}
|
||||
score := float64(inter) / float64(min(len(toks), len(gt))) * (0.5 + 0.5*g.Priority)
|
||||
if score > best {
|
||||
best, bestID = score, g.ID
|
||||
}
|
||||
}
|
||||
if best > 1 {
|
||||
best = 1
|
||||
}
|
||||
return best, bestID
|
||||
}
|
||||
|
||||
var stop = map[string]bool{"the": true, "a": true, "an": true, "is": true, "are": true, "of": true, "to": true, "in": true, "on": true, "at": true, "for": true, "and": true, "or": true, "that": true, "this": true, "it": true, "with": true, "why": true, "what": true, "how": true, "did": true, "does": true, "do": true}
|
||||
|
||||
func tokenSet(s string) map[string]bool {
|
||||
out := map[string]bool{}
|
||||
var cur strings.Builder
|
||||
flush := func() {
|
||||
w := strings.Trim(cur.String(), ".-_")
|
||||
cur.Reset()
|
||||
if len(w) >= 3 && !stop[w] {
|
||||
out[w] = true
|
||||
}
|
||||
}
|
||||
for _, r := range strings.ToLower(s) {
|
||||
if r >= 'a' && r <= 'z' || r >= '0' && r <= '9' || r == '-' || r == '.' || r == '_' {
|
||||
cur.WriteRune(r)
|
||||
} else {
|
||||
flush()
|
||||
}
|
||||
}
|
||||
flush()
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package goals
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/andydixon/noema/internal/minds"
|
||||
"github.com/andydixon/noema/internal/storage"
|
||||
"github.com/andydixon/noema/migrations"
|
||||
)
|
||||
|
||||
func TestGoalsLifecycleAndRelevance(t *testing.T) {
|
||||
pool := storage.TestPool(t, migrations.FS)
|
||||
ctx := context.Background()
|
||||
ms := minds.NewStore(pool)
|
||||
a, _ := ms.Create(ctx, minds.CreateParams{Slug: "a"})
|
||||
b, _ := ms.Create(ctx, minds.CreateParams{Slug: "b"})
|
||||
s := NewStore(pool)
|
||||
root, err := s.Create(ctx, pool, New{MindID: a.ID, Title: "Find the cause of atlas latency", Kind: KindInvestigation, Priority: 0.9, Subject: "atlas latency", Owner: "operator"})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
child, err := s.Create(ctx, pool, New{MindID: a.ID, ParentID: root.ID, Title: "Check disk latency on atlas", Priority: 0.7})
|
||||
if err != nil || child.ParentID != root.ID {
|
||||
t.Fatalf("child: %v %+v", err, child)
|
||||
}
|
||||
if _, err := s.Create(ctx, pool, New{MindID: b.ID, ParentID: root.ID, Title: "cross-mind child"}); err == nil {
|
||||
if got, _ := s.List(ctx, b.ID, nil, 10); len(got) != 0 {
|
||||
t.Fatal("cross-mind parent accepted")
|
||||
}
|
||||
}
|
||||
rel, id := Relevance("query latency on atlas rose sharply", []Goal{root, child})
|
||||
if rel < 0.3 || id != root.ID {
|
||||
t.Fatalf("relevance wrong: %v %v", rel, id)
|
||||
}
|
||||
if rel0, _ := Relevance("weather is mild", []Goal{root}); rel0 != 0 {
|
||||
t.Fatalf("unrelated text should score 0, got %v", rel0)
|
||||
}
|
||||
p := 0.5
|
||||
g, err := s.Apply(ctx, pool, a.ID, child.ID, Update{Progress: &p, Blockers: &[]string{"no metrics access"}})
|
||||
if err != nil || g.Status != StatusBlocked || g.Progress != 0.5 {
|
||||
t.Fatalf("apply: %v %+v", err, g)
|
||||
}
|
||||
done := StatusCompleted
|
||||
g, _ = s.Apply(ctx, pool, a.ID, child.ID, Update{Status: &done})
|
||||
if g.Progress != 1 || g.CompletedAt == nil {
|
||||
t.Fatalf("completion wrong: %+v", g)
|
||||
}
|
||||
pool.Exec(ctx, `UPDATE goals SET last_progress_at = now() - interval '2 days' WHERE id=$1`, root.ID) //nolint:errcheck
|
||||
stalled, _ := s.Stalled(ctx, a.ID, 24*time.Hour)
|
||||
if len(stalled) != 1 || stalled[0].ID != root.ID {
|
||||
t.Fatalf("stalled wrong: %+v", stalled)
|
||||
}
|
||||
if _, err := s.FindBySubject(ctx, pool, a.ID, KindInvestigation, "atlas latency"); err != nil {
|
||||
t.Fatal("subject lookup failed")
|
||||
}
|
||||
st, _ := s.Stats(ctx, a.ID)
|
||||
if st.Total != 2 || st.ByStatus["completed"] != 1 {
|
||||
t.Fatalf("stats: %+v", st)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user