orchestrator

type Adversary struct {
	Agent        AdversaryAgent
	Workdir      string
	MaxAttacks   int
	ProbeTimeout time.Duration
}

type AdversaryAgent interface {
	ProposeAttacks(ctx context.Context, diff, impactBrief string, maxAttacks int) ([]Attack, error)
}

type AdversaryResult struct {
	Attacks []Attack
	Landed  int
	Cleared bool
}

type Agent interface {
	Name() string
	Config() AgentConfig
	Run(ctx context.Context, task *Task, scratch *Scratchpad) (string, error)
}

type AgentConfig struct {
	Name          string   `toml:"name"`
	Description   string   `toml:"description"`
	Type          TaskType `toml:"type"`
	Provider      string   `toml:"provider"`
	BaseURL       string   `toml:"base_url"`
	Model         string   `toml:"model"`
	MaxTokens     int      `toml:"max_tokens"`
	Temperature   float64  `toml:"temperature"`
	SystemFile    string   `toml:"system_file"`
	MaxContext    int      `toml:"max_context_tokens"`
	ToolsAllow    []string `toml:"tools_allow"`
	ToolsDeny     []string `toml:"tools_deny"`
	MemoryNS      string   `toml:"memory_namespace"`
	RetentionDays int      `toml:"retention_days"`
}

type AgentFactory func(rung Rung) []Agent

type AgentState struct {
	TaskID         string          `json:"task_id"`
	EpisodeCursor  int64           `json:"episode_cursor"`
	ScratchpadHash string          `json:"scratchpad_hash"`
	HeldLeases     []int64         `json:"held_leases"`
	LastVerdict    json.RawMessage `json:"last_verdict,omitempty"`
}

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

type Artifact struct {
	Type string
	Data any
}

type Attack struct {
	Kind        AttackKind
	Hypothesis  string
	ProbeSource string
	Landed      bool
	Output      string
}

type AttackKind string

type Attempt struct {
	Round    int
	Output   string
	Verdict  *Verdict
	Diagnose string
}

type BlameResult struct {
	Culprit    *EditRecord
	Check      Check
	Bisections int
	PriorGreen int
}

type Blamer struct {
	Verifier *Verifier
}

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

type Candidate struct {
	ID       string
	Agent    Agent
	Worktree string
	Output   string
	Verdict  *Verdict
	Err      error
}

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

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

type ChainTemplate struct {
	ID            int64
	Class         TaskClass
	Sequence      []ToolCall
	Support       int
	SuccessRate   float64
	Status        string
	LiveTrials    int
	LiveSuccesses int
}

type ChangedLine struct {
	File string
	Line int
	Text string
}

type Check struct {
	Kind         CheckKind
	Name         string
	Cmd          []string
	Timeout      time.Duration
	AllowedPaths []string
}

type CheckKind string

type CheckResult struct {
	Check    Check
	Passed   bool
	Output   string
	Duration time.Duration
}

type Checkpoint struct {
	ID        int64
	Label     string
	TreeSHA   string
	State     AgentState
	Green     bool
	CreatedAt time.Time
}

type CompiledContext struct {
	Prompt   string
	Included []string
	Evicted  []string
	Used     int
	Budget   int
}

type ConfidenceClaim struct {
	AgentName string
	TaskClass TaskClass
	Declared  float64
	Passed    bool
}

type Conflict struct {
	HeldBy  string
	TaskID  string
	Intent  string
	Overlap string
}

type ContextCompiler struct {
	Budget   int
	KindCaps map[string]int
}

type ContextItem struct {
	Kind      string
	Name      string
	Body      string
	Relevance float64
	Pinned    bool
}

type Contract struct {
	TaskID             string
	AllowedGlobs       []string
	FrozenGlobs        []string
	ForbiddenPatterns  []ForbiddenPattern
	MaxFilesChanged    int
	MaxLinesChanged    int
	RequiredInvariants []Check
}

type Critic struct {
	Verifier *Verifier
	Checks   []Check
	Policy   RepairPolicy
}

type CriticResult struct {
	Attempts []Attempt
	Final    *Verdict
	Passed   bool
}

type DagExecutor struct {
	Leases      *LeaseTable
	MaxParallel int
	AgentID     string
}

type DagResult struct {
	Status map[string]NodeStatus
	Order  []string
}

type Decision string

type Decl struct {
	Key string
	Src string
	Pos int
}

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

type EditLog struct {
	TaskID  string
	Workdir string
	Base    string
	Edits   []EditRecord
}

type EditRecord struct {
	Seq     int
	SHA     string
	Path    string
	Summary string
}

type EditRequest struct {
	TaskID             string
	Edits              map[string][]byte
	DeclaredConfidence float64
}

type Episode struct {
	ID        int64           `json:"id"`
	Intent    string          `json:"intent"`
	TaskTitle string          `json:"task_title"`
	PlanJSON  json.RawMessage `json:"plan"`
	Diff      string          `json:"diff,omitempty"`
	Score     float64         `json:"score"`
	Passed    bool            `json:"passed"`
	Rounds    int             `json:"rounds"`
	CreatedAt time.Time       `json:"created_at"`
}

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

type Escalation struct {
	FromRung string
	ToRung   string
	Reason   string
	Verdict  *Verdict
	At       time.Time
}

type ForbiddenPattern struct {
	Name        string
	Pattern     *regexp.Regexp
	OnlyNewCode bool
}

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

type FuncStage struct {
	StageName string
	In, Out   string
	Fn        func(ctx context.Context, in Artifact) (Artifact, error)
}

type Governor struct {
	Ladder   []Rung
	Verifier *Verifier
	Checks   []Check
	RepoRoot string
	Factory  AgentFactory
	Router   *StrategyRouter
}

type GovernorResult struct {
	Passed      bool
	FinalRung   string
	Verdict     *Verdict
	Escalations []Escalation
	TotalRounds int
}

type Impact struct {
	ChangedPkgs      []string
	AffectedPkgs     []string
	AffectedTestPkgs []string
	Radius           float64
}

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

type Intent string

type Kernel struct {
	Workdir string
	// contains filtered or unexported fields
}

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

type Lease struct {
	ID        int64
	AgentID   string
	TaskID    string
	Globs     []string
	Intent    string
	ExpiresAt time.Time
}

type LeaseTable struct {
	DefaultTTL time.Duration
	// contains filtered or unexported fields
}

type MacroResult struct {
	Applied       bool
	Verdict       *Verdict
	Trace         *Trace
	Decision      Decision
	ResumeContext string
}

type Macros struct {
	Workdir  string
	Contract *Contract
	Targeted *TargetedVerifier
	Probe    func(testCmd []string) *MutationProbe
	Calib    *Calibrator
	Policy   MergePolicy
	Agent    string
	Class    TaskClass
}

type MergePolicy struct {
	AutoMergeThreshold float64
	ReviewThreshold    float64
}

type MergeResult struct {
	Merged     []byte
	Conflicts  []SemConflict
	AutoMerged int
}

type Miner struct {
	MinSupport     int
	MinSuccessRate float64
	MinLength      int
	MaxLength      int
	// contains filtered or unexported fields
}

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

type Mutation struct {
	File   string
	Line   int
	Before string
	After  string
	Rule   string
	Killed bool
}

type MutationProbe struct {
	Workdir      string
	TestCmd      []string
	MaxMutations int
}

type NIMAgent = LLMAgent

type NodeRunner func(ctx context.Context, node *PlanNode) error

type NodeStatus string

type Orchestrator struct {
	Registry    *Registry
	Planner     *Planner
	Dispatcher  *Dispatcher
	Aggregator  *Aggregator
	Scratchpad  *Scratchpad
	MaxParallel int
}

type PkgNode struct {
	ImportPath string
	Dir        string
	GoFiles    []string
	TestFiles  []string
	Imports    []string
}

type Plan struct {
	ID         string    `json:"id"`
	Prompt     string    `json:"prompt"`
	Intent     Intent    `json:"intent"`
	Tasks      []*Task   `json:"tasks"`
	Created    time.Time `json:"created"`
	Started    time.Time `json:"started"`
	Completed  time.Time `json:"completed"`
	TotalCost  float64   `json:"total_cost"`
	TokensUsed int       `json:"tokens_used"`
	Success    bool      `json:"success"`
}

type PlanNode struct {
	Task      *Task
	DependsOn []string
	PathGlobs []string
}

type Planner struct {
	Router *Router
	Agents []AgentConfig
}

type ProbeResult struct {
	Mutations          []Mutation
	Killed             int
	Survived           int
	ObservabilityScore float64
}

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

type RepairPolicy struct {
	MaxAttempts    int
	MinImprovement float64
}

type Result struct {
	Plan        *Plan
	Sections    map[string]string
	TotalTasks  int
	OKTasks     int
	FailedTasks int
	Summary     string
}

type Router struct {
	Keywords map[Intent][]string
}

type RunOption func(*runConfig)

type Rung struct {
	Name         string
	Agents       int
	RepairRounds int
	Timeout      time.Duration
}

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

type ScratchpadEntry struct {
	Timestamp time.Time `json:"timestamp"`
	Agent     string    `json:"agent"`
	Section   string    `json:"section"`
	Content   string    `json:"content"`
	Version   int       `json:"version"`
}

type SemConflict struct {
	Key        string
	Base, A, B string
}

type SeqEpisode struct {
	EpisodeID int64
	Class     TaskClass
	Sequence  []ToolCall
	Passed    bool
}

type SpecResult struct {
	Winner     *Candidate
	Candidates []*Candidate
}

type SpeculativeRunner struct {
	RepoRoot    string
	Checks      []Check
	MaxParallel int
	KeepLosers  bool
	WorkdirBase string // optional override (defaults to os.TempDir()/sin-spec)
}

type Stage interface {
	Name() string
	InType() string
	OutType() string
	Run(ctx context.Context, in Artifact) (Artifact, error)
}

type StageResult struct {
	Stage    string
	Duration time.Duration
	Output   Artifact
	Err      error
}

type Strategy string

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

type Symbol struct {
	Key       string
	File      string
	Line      int
	Kind      string
	Signature string
	Rank      float64
}

type TargetedVerifier struct {
	Inner *Verifier
	Graph *ImpactGraph
}

type Task struct {
	ID          string     `json:"id"`
	Type        TaskType   `json:"type"`
	Title       string     `json:"title,omitempty"`
	Description string     `json:"description"`
	AgentName   string     `json:"agent"`
	DependsOn   []string   `json:"depends_on,omitempty"`
	Status      TaskStatus `json:"status"`
	Result      string     `json:"result,omitempty"`
	Error       string     `json:"error,omitempty"`
	Created     time.Time  `json:"created"`
	Started     *time.Time `json:"started,omitempty"`
	Completed   *time.Time `json:"completed,omitempty"`
	TokensUsed  int        `json:"tokens_used"`
	Cost        float64    `json:"cost"`
}

type TaskClass string

type TaskStatus string

type TaskType string

type ToolCall struct {
	Tool     string `json:"tool"`
	ArgShape string `json:"arg_shape"`
}

type Trace struct {
	Chain    string
	Results  []StageResult
	Halted   bool
	HaltedAt string
}

type Verdict struct {
	TaskID    string
	Candidate string
	Results   []CheckResult
	Score     float64
	Passed    bool
	CreatedAt time.Time
}

type Verifier struct {
	Workdir        string
	MandatoryKinds []CheckKind
}

type Violation struct {
	Kind   string
	Path   string
	Line   int
	Detail string
}