ooda

type ActionEnvelope struct {
	Name      string                 `json:"name"`
	Arguments map[string]interface{} `json:"arguments"`
}

type Actor interface {
	Act(ctx context.Context, frame *CognitiveFrame) error
}

type Atom struct {
	Predicate    string    `json:"predicate"`
	Subject      string    `json:"subject"`
	Object       string    `json:"object"`
	Weight       float64   `json:"weight"` // 1.0 (Fact) to 0.1 (Guess)
	OriginIntent IntentStr `json:"origin_intent,omitempty"`
}

type AuditResult struct {
	Pass          bool      `json:"pass"`
	ViolationTier TrustTier `json:"violation_tier"` // Which tier was violated
	TierID        string    `json:"tier_id"`
	ConflictPath  string    `json:"conflict_path"` // "safety.dl:42"
	ProofTree     any       `json:"proof_tree"`    // "Why" it failed
	EntropyDelta  float64   `json:"entropy_delta"` // Feedback for EAST
}

type Brain interface {
	// Evaluate makes a decision based on the input and context.
	// Returns a Decision with AuditTrail explaining which rules were matched.
	Evaluate(ctx context.Context, frame *CognitiveFrame) (*core.Decision, error)

	// Verify validates an action result against policy requirements.
	Verify(ctx context.Context, frame *CognitiveFrame) (*core.AuditTrail, error)

	// LoadPolicy loads additional policy rules.
	LoadPolicy(ctx context.Context, rules string) error
}

type Builder struct {
	// contains filtered or unexported fields
}

type CognitiveFrame struct {
	ID        uuid.UUID
	Timestamp time.Time
	Intent    IntentStr
	Phase     Phase

	// Task Metadata
	TaskType   TaskType
	OutputType OutputType

	// Input Stimulus
	Input string

	// Memory & Logic
	Context       []Atom         // Soft Logic (INT8) - Observed facts, pruneable
	AttentionSink []Atom         // Hard Logic (FP32) - Immutable Axioms (Tier 0), never pruned
	ActiveGenes   []DomainGene   // Logic Pinning - crystallized rules for this epoch
	RawContext    map[string]any // Legacy escape hatch for transitional state

	// Knowledge Scope
	GraphID   string // MEB graph scope for this epoch
	KBVersion string // Cache invalidation token

	// Reasoning
	Draft  any          // Neural proposal: *Plan for PLAN output, []byte for RULE output
	Proof  *AuditResult // Verification trace
	Status VerifyStatus

	// Telemetry
	TraceID        string
	SessionHistory []AuditResult
	EAST           EASTState

	// Staging
	IsProposal bool

	// === NEW: OODA Chassis Fields ===
	// Components (set via Builder)
	Memory     Memory      `json:"-"` // Memory interface for Recall/Commit
	Brain      Brain       `json:"-"` // Brain interface for Evaluate/Verify
	Executor   Executor    `json:"-"` // Legacy executor interface (deprecated, use Dispatcher)
	Dispatcher *Dispatcher `json:"-"` // Action dispatcher for mapping decisions to tools

	// Execution State
	Decision     *core.Decision   // Decision from Brain
	AuditTrail   *core.AuditTrail // Audit trail from evaluation
	ActionResult any              // Result from Executor or Dispatcher

	// Session State (for workflow integration)
	SessionID        string                 // Session identifier for workflow continuity
	WorkflowID       string                 // Current workflow being executed
	WorkflowInstance *core.WorkflowInstance // Current workflow instance state

	// === Dual Memory Architecture ===
	// Long-term Memory: MEB-backed knowledge store (persistent across sessions)
	KnowledgeStore ports.KnowledgeStore `json:"-"`
	// Transient Memory: Session store (transient, RAM-only) for coordination facts
	TransientStore ports.TransientStore `json:"-"`
	// Reasoning Port: For KB-backed EAST steering (14-east.dl)
	ReasoningPort ports.ReasoningPort `json:"-"`

	// Configuration
	MaxRetries int           `json:"max_retries"`
	Timeout    time.Duration `json:"timeout"`

	// Middleware configuration for LLM-based actions.
	// When set, these options are passed to the TextGenerator during Act phase.
	GenerateOptions []core.GenerateOption `json:"-"`

	// Metrics
	RetryCount     int                     `json:"retry_count"`
	PhaseDurations map[Phase]time.Duration `json:"phase_durations"`
}

type Decider interface {
	Decide(ctx context.Context, frame *CognitiveFrame) error
}

type Dispatcher struct {
	// contains filtered or unexported fields
}

type DomainGene struct {
	Name         string    `json:"name"`
	Tier         TrustTier `json:"tier"`
	TierID       string    `json:"tier_id"`
	Rules        []byte    `json:"rules"`     // Compiled Datalog content
	Signature    [32]byte  `json:"signature"` // SHA256 integrity hash
	MMapAddr     uintptr   `json:"-"`         // Zero-copy mmap pointer
	Capabilities []string  `json:"capabilities"`
	Intents      []string  `json:"intents"`
	FactPath     string    `json:"fact_path,omitempty"`
	SourcePath   string    `json:"source_path,omitempty"`
	IsUnverified bool      `json:"is_unverified"`
}

type EASTState struct {
	LogicSuccess       float64        `json:"logic_success"`       // L (0.0 - 1.0)
	EntropyCoefficient float64        `json:"entropy_coefficient"` // N (Novelty)
	SteeringMagnitude  float64        `json:"steering_magnitude"`  // P = exp(1-L) / N
	Entropy            float64        `json:"entropy"`             // E: 0.0 (stable) to 1.0 (chaotic)
	Activity           map[string]int `json:"activity"`            // A: fact/rule usage counts
	Saliency           []string       `json:"saliency"`            // S: prioritized input signals
	TrustTier          TrustTier      `json:"trust_tier"`          // T: T0 to T3
}

type ExecutionObject struct {
	AttentionSink []Atom       // FP32 — immutable Tier 0 axioms, never pruned
	Context       []Atom       // INT8 — observed facts from MEB, prunable
	ActiveRules   []DomainGene // Datalog rules active for this epoch
	EAST          EASTState    // Steering state computed during Orient
	GraphID       string       // MEB graph scope for this epoch
	KBVersion     string       // Cache invalidation token
}

type ExecutionPath int

type Executor interface {
	// Execute performs the action selected by the Brain.
	// Returns the result of the execution.
	Execute(ctx context.Context, frame *CognitiveFrame, decision *core.Decision) (any, error)

	// Rollback reverses a previous execution if needed.
	Rollback(ctx context.Context, frame *CognitiveFrame, result any) error
}

type IntentStr string

type Loop struct {
	// contains filtered or unexported fields
}

type Memory interface {
	// Recall retrieves relevant context from memory based on the input.
	// This is called during the Orient phase to hydrate the frame with facts.
	Recall(ctx context.Context, input string) ([]Atom, error)

	// Commit stores the results of an action back into memory.
	// This is called after the Act phase to persist the outcome.
	Commit(ctx context.Context, frame *CognitiveFrame) error

	// Store stores a single atom into memory.
	Store(ctx context.Context, atom Atom) error

	// Query retrieves atoms matching a predicate pattern.
	Query(ctx context.Context, predicate string) ([]Atom, error)
}

type Observer interface {
	Observe(ctx context.Context, frame *CognitiveFrame) error
}

type Orienter interface {
	Orient(ctx context.Context, frame *CognitiveFrame) error
}

type OutputType string

type Phase string

type Planner interface {
	Plan(ctx context.Context, frame *CognitiveFrame) error
}

type RefinementContext struct {
	FailedRules   []string
	ConflictPath  string
	PreviousDraft any
	AttemptNumber int
}

type Registry struct {
	// contains filtered or unexported fields
}

type TaskType string

type ToolFunc func(ctx context.Context, args map[string]interface{}) (string, error)

type TrustTier string

type ValidationError struct {
	RuleName     string
	Tier         TrustTier
	Message      string
	ConflictPath string
}

type Verifier interface {
	Verify(ctx context.Context, frame *CognitiveFrame) error
}

type VerifyStatus string