router

type Beta struct{ A, B float64 }

type Check struct {
	Violated    bool      `json:"violated,omitempty"`
	TestsSeen   bool      `json:"tests_seen,omitempty"`
	TestsPassed bool      `json:"tests_passed,omitempty"`
	At          time.Time `json:"at"`
}

type Checks struct {
	Path string // "" = do not persist

	// Run checks a run (tests replace it); default CheckRun.
	Run func(history.Run, time.Time) Check
	// contains filtered or unexported fields
}

type Counts struct {
	S, F   float64 // weighted
	OK, N  int     // raw: successes and runs with a signal
	Recent [2]int  // raw, last 30 days: successes, runs
}

type Decision struct {
	Type, Tier string
	Score      int   // the tier rules' points
	Hits       []Hit // the tier rules that applied
	Estimates  []Estimate
	Draws      map[string]float64 // the Thompson draw of each arm
	Chain      []string           // best first; the rest is the fallback
	Favorite   string             // the first arm by posterior mean (no exploration)
	Explored   bool               // Chain[0] is not the favorite: this pick explores
	ExploreP   float64            // how often a draw picks something other than the favorite
	External   string             // what the external router did ("" = not configured)
	Picked     bool               // the external router picked Chain[0]
	Why        string             // one line, in English
}

type Estimate struct {
	Arm      string
	Rank     int
	Prior    float64 // prior(tier, rank)
	Lift     float64 // the arm's record against the prior over all its runs
	Base     float64 // the prior with its odds multiplied by Lift
	Arm1     Counts  // the arm, every type and tier
	ArmTier  Counts  // the arm, this tier
	Cell     Counts  // the arm, this type and tier
	TierPost Beta    // (arm, tier)
	Post     Beta    // (arm, type, tier): what is sampled
}

type Evidence struct {
	Key     string // run key (<ID>-<agent>)
	Arm     string
	CLI     string
	Type    string
	Tier    string
	At      time.Time // when it ended (else started)
	Outcome Outcome
}

type External struct {
	Command string
	Timeout time.Duration // 0 = DefaultExternalTimeout
	Env     []string      // added to the environment (tests)
}

type ExternalAnswer struct {
	Tier string `json:"tier"`
	Arm  string `json:"arm,omitempty"`
}

type ExternalInput struct {
	Task     string   `json:"task"`
	Dir      string   `json:"dir,omitempty"`
	ReadOnly bool     `json:"read_only"`
	Type     string   `json:"type"`
	Tier     string   `json:"tier"`
	Score    int      `json:"score"`
	Pool     []string `json:"pool"`
}

type Features struct {
	Type     string // report.TaskType: review, fix, tests, refactor, docs, feature, other
	Length   int    // characters of the task's goal (report.Goal)
	Files    int    // files the task allows to modify (changes.Allowed)
	Dirs     int    // directories it allows to modify
	Steps    int    // numbered or bulleted lines
	ReadOnly bool
	// contains filtered or unexported fields
}

type Hit struct {
	Rule   string
	Points int
}

type Observation struct {
	Status      runs.Status
	Violated    bool   // it broke the task's rules (internal/changes)
	Rating      string // the user's rating (internal/feedback)
	TestsSeen   bool   // tests ran in its activity (internal/activity)
	TestsPassed bool   // and the last ones passed
}

type Outcome int

type Request struct {
	Task     string
	Dir      string
	ReadOnly bool
	// Pool is the arms, cheapest first, as chain links ("cli:model[:effort]").
	Pool []string
	// Evidence is what the past runs say (Gather).
	Evidence []Evidence
	// OutOfQuota: CLIs known to be out of quota right now. Their arms go to
	// the end of the chain.
	OutOfQuota map[string]bool
	Now        time.Time
	Rand       *rand.Rand // nil = seeded from the clock
	External   *External  // nil = only the built-in router
}

type Table = table