isotope

type AgentState struct {
	AgentID        string
	FailedTests    map[string]int // isotope family → count of failures
	TotalDistance  int            // Sum of all failed test weights
	Position       Position
	PreviousRung   int
	RungHistory    []int  // Historical rung values for trend analysis
	DemotionReason string // Why agent was demoted (if applicable)
	LastUpdated    int64  // Unix timestamp of last update
}

type Agreement struct {
	IsotopeFamily  string
	IsotopeVersion int
	RequiredQuorum int // Minimum alarms needed for consensus
	Reports        []ConsensusReport
}

type AlarmID string

type AlarmTestResult struct {
	AlarmID          AlarmID
	ServiceID        string
	Timestamp        time.Time
	TestResults      []IndividualTestResult
	ConsensusReports []ConsensusReport
}

type CanonicalToken struct {
	Type  string // "FEATURE", "SCENARIO", "GIVEN", "WHEN", "THEN", "AND", "BUT"
	Key   string // e.g., "name", "hash"
	Value string // the canonical value
}

type ChainLink struct {
	Role      string // "requester", "secondary", "verifier"
	Isotope   Isotope
	Timestamp time.Time
}

type ChaosPhase struct {
	DurationCycles  int    // number of test cycles to run this phase
	DegradationType string // "latency", "entropy", "input-ignorance", "none"
	Severity        int    // 0-100 for latency %, 0-1 for entropy (bool)
	Description     string
}

type ChaosProfile struct {
	Name        string
	Description string
	Phases      []ChaosPhase
}

type ChaosSnapshot struct {
	Cycle             int
	ServiceDistance   int
	ServiceRung       int
	ConsensusFormed   bool
	HealthyAlarmCount int
	FailedAlarmCount  int
	AverageLatencyMs  int
	SuccessRate       float64
}

type ChaosTestResult struct {
	ServiceID         string
	Profile           ChaosProfile
	Timeline          []ChaosSnapshot
	DetectionCycle    int // when consensus first failed
	EvictionCycle     int // when service would be evicted (rung threshold exceeded)
	FinalDistance     int
	FinalRung         int
	TotalCycles       int
	RecoverySucceeded bool
	TimeToDetection   int // cycles from start to detection
	TimeToEviction    int // cycles from start to eviction threshold
}

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

type ConsensusGap struct {
	IsotopeFamily string
	AlarmCount    int // How many alarms disagreed
	TotalAlarms   int
	GapWeight     int // 42i contribution
	Reason        string
}

type ConsensusReport struct {
	AlarmID   AlarmID
	Isotope   Isotope
	Signature string    // Signature of the isotope (proves it came from this alarm)
	Timestamp time.Time // When the report was generated
}

type ConsensusReporter struct {
	AlarmID    AlarmID
	SigningKey []byte
}

type ConsensusResult struct {
	TestIsotope       Isotope
	AlarmCount        int
	AgreedCount       int
	ConsensusFormed   bool
	Outliers          []AlarmID
	ByzantineCapacity int
}

type DevModeSimulator struct {
	AlarmCount int           // Number of simulated alarms (typically 3, 5, or 7)
	Alarms     []*AgentState // One AgentState per simulated alarm
	Results    []ConsensusReport
	Ledger     *ResultLedger
}

type DevTestScenario struct {
	Name        string
	Description string
	Steps       []DevTestStep
}

type DevTestStep struct {
	Action      string // "test", "fail", "inject_byzantine", "check_consensus"
	TestIsotope *Isotope
	TestPassed  bool
	AlarmIndex  int // For inject_byzantine
	Description string
}

type Feature struct {
	Name      string
	Scenarios []Scenario
}

type GherkinAST struct {
	Features []Feature
}

type GherkinKeyword string

type History struct {
	Isotope   Isotope
	Family    string // Convenience copy
	Version   int    // Convenience copy
	Results   []TestResult
	FirstSeen time.Time
	LastSeen  time.Time
	PassCount int
	FailCount int
	Flakiness float64 // 0.0 to 1.0
	Stability float64 // Pass rate
	Trend     string  // "improving", "stable", "degrading", "unknown"
}

type HostedService struct {
	ServiceID        string
	State            *AgentState // The service's own 42i state
	Tests            map[string]*ServiceTest
	TestHistory      []ServiceTestRun
	StartTime        time.Time
	LastTestTime     time.Time
	ConsecutiveFails int
}

type IndividualTestResult struct {
	TestFamily   string
	Passed       bool
	LatencyMs    int
	SLALatencyMs int
	ErrorReason  string
}

type InstanceIdentity struct {
	// Isotope is the public identifier, safe to expose via the MCP API.
	// It is derived from the startup nonce but reveals nothing about secret.
	Isotope string
	// contains filtered or unexported fields
}

type Isotope struct {
	Family    string // e.g., "iso-login"
	Version   int    // v1, v2, v3 for semantic changes
	Signature string // HMAC-SHA256 signature
	Raw       string // The canonical token string that was signed
}

type MCPFailureEvent struct {
	FailureType    string // e.g., "timeout", "unauthorized-access", "corrupted-response"
	ServerID       string // Which MCP/ACP server failed
	ToolName       string // Which tool (if applicable)
	MethodName     string // JSON-RPC method (e.g., "tools/call")
	DistanceWeight int    // How much 42i_distance to add
	Direction      string // Which 42i direction (unpredictable-behavior, etc.)
	Severity       int    // 1-5 scale
	ErrorMessage   string
	LatencyMs      int
	Recoverable    bool
}

type Position struct {
	Real      float64 // Real axis: always 42
	Imaginary float64 // Imaginary axis: 42i_distance
	Magnitude float64 // Distance from origin: sqrt(42^2 + imaginary^2)
	Direction string  // Qualitative direction (e.g., "unpredictable-behavior")
	Rung      int     // Current capability rung (0-6)
	AtRisk    bool    // True if approaching rung threshold
}

type QuorumStatus struct {
	AgreedIsotopes  []Isotope // Isotopes that formed consensus
	AgreedCount     int       // Number of alarms in agreement
	DisagreedCount  int       // Number of alarms that disagreed
	Outliers        []AlarmID // Alarms that disagreed
	ConsensusFormed bool      // true if QuorumSize met
	ByzantineCount  int       // Number of failures tolerated (F = (N-1)/3)
}

type Record struct {
	Name         string    `json:"name"`
	Role         string    `json:"role"`
	Endpoint     string    `json:"endpoint"`
	Protocol     string    `json:"protocol"`
	TrustRung    int       `json:"trust_rung"`
	RungName     string    `json:"rung_name"`
	RegisteredAt time.Time `json:"registered_at"`
}

type Registration struct {
	Name     string `json:"name"`
	Role     string `json:"role"`
	Endpoint string `json:"endpoint"`
	Protocol string `json:"protocol,omitempty"`
}

type Result struct {
	TestIsotope    Isotope
	Passed         bool
	AgentID        string
	Weight         int // 42i contribution
	BeforePosition Position
	AfterPosition  Position
	RungChanged    bool
	NewRung        int
	CostAdjustment float64 // Multiplier for lemon cost
}

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

type RungBoundaryAlert struct {
	Status              string // "ok", "warning", "critical", "demoted"
	CurrentRung         int
	NextRung            int
	DistanceToThreshold int
	Message             string
}

type RungThreshold struct {
	Rung        int
	Name        string
	MaxDistance int
	Description string
}

type Scenario struct {
	Name  string
	Steps []Step
}

type Server interface {
	Shutdown()
}

type ServiceCluster struct {
	*DevModeSimulator
	HostedServices map[string]*HostedService
	SigningKey     []byte
}

type ServiceConsensus struct {
	ConsensusFormed bool
	QuorumSize      int
	TestAgreement   map[string]int // family → count of alarms that passed
}

type ServiceHealthSummary struct {
	ServiceID        string
	SuccessRate      float64
	TotalTestsRun    int
	ConsecutiveFails int
	AvgLatencyMs     int
	Uptime           time.Duration
	CurrentRung      int
	Distance42i      int
}

type ServiceTest struct {
	IsotopeFamily    string
	Description      string
	SLALatencyMs     int         // SLA: max latency
	SLAErrorRate     float64     // SLA: max error rate (0.0-1.0)
	DeclaredBehavior string      // What the service claims to do
	TestFunc         func() bool // The actual test (true=pass, false=fail)
}

type ServiceTestRun struct {
	Test        *ServiceTest
	Passed      bool
	LatencyMs   int
	Timestamp   time.Time
	AlarmID     AlarmID
	ErrorReason string
}

type ServiceTestingResult struct {
	ServiceID     string
	Timestamp     time.Time
	AlarmResults  []AlarmTestResult
	Consensus     ServiceConsensus
	ServiceHealth ServiceHealthSummary
}

type Step struct {
	Keyword GherkinKeyword
	Text    string
}

type TestResult struct {
	Isotope     Isotope
	Result      bool   // true = PASS, false = FAIL
	Reason      string // failure reason or note
	Timestamp   time.Time
	AlarmID     AlarmID
	FailureType string // "timeout", "assertion", "error", etc.
	ExecutionMs int    // How long the test took
}

type TrackedMCPServers map[string][]MCPFailureEvent