webauto

type Automation struct {
	Name        string `yaml:"-"`
	Description string `yaml:"description,omitempty"`
	Profile     string `yaml:"web_profile,omitempty"`
	URL         string `yaml:"url,omitempty"`
	// Agent is the registry name of the autonomous agent an `##auto agent`
	// recipe drives (the same name @agent-name prompts address).
	Agent string `yaml:"agent,omitempty"`
	// Humanoid is the registry name of the humanoid an `##auto humanoid`
	// recipe drives.
	Humanoid string `yaml:"humanoid,omitempty"`
	// Workdir is the project directory an `##auto code` recipe works in
	// (exposed to the prompt as {{workdir}}; relative values are anchored
	// under the session's work dir, ~ expands to the home directory).
	Workdir string `yaml:"workdir,omitempty"`
	// WebRead selects how a web recipe's AI observes pages: "text" (default —
	// get_text/get_elements DOM extraction) or "screenshot" (the screenshot
	// action; captures are delivered to the model as images it can see).
	// Web kind only; other kinds ignore it.
	WebRead string `yaml:"web_read,omitempty"`
	// OnSuccess names the recipe to run when this one COMPLETES — a loop
	// ending FULFILLED, or a plain run finishing cleanly. Same kind by
	// default; "<kind>:<name>" targets another kind. Cancel/error never
	// chains; chains are capped at depth 8.
	OnSuccess string `yaml:"on_success,omitempty"`
	// Notify, when set, sends the run's outcome summary through a humanoid's
	// channel adapter when the run ends (any cause). See NotifyConfig.
	Notify *NotifyConfig `yaml:"notify,omitempty"`
	// Schedule is an optional cron expression ("0 8 * * *", "@every 2h").
	// When set, the daemon's boot-time sync registers an `auto-<kind>-<name>`
	// ##cron job running the recipe; absent → the recipe is purely on-demand
	// and scheduling machinery never touches it. The explicit off-switch
	// "off" (also "none"/"disabled") REMOVES the recipe's auto job at boot —
	// absence can't do that, since an existing job may be manually managed.
	Schedule string   `yaml:"schedule,omitempty"`
	Args     []string `yaml:"args,omitempty"` // documented arg names, e.g. [query, label]
	// OutputDir is where the recipe's results are saved (exposed to the prompt
	// as {{output_dir}} and read back by `##auto web results`). Empty →
	// <recipe-dir>/<name>/results; a relative value is anchored under the
	// recipe directory; an absolute value is used as-is. See ResolveOutputDir.
	OutputDir string `yaml:"output_dir,omitempty"`
	// Step groups the run-loop / auto-continue budget (see StepConfig). Absent →
	// all defaults. When Loop.Do is also present, Loop.Do wins (Step is the
	// plain single-run spelling of the same block).
	Step *StepConfig `yaml:"step,omitempty"`
	// Loop is the loop-engineering layout: `loop: {do, while}`. `do` is the
	// per-pass budget (same shape as `step`); `while` is the outer semantic
	// loop that repeats the pass until its `until` prompt is judged
	// fulfilled. See LoopConfig.
	Loop *LoopConfig `yaml:"loop,omitempty"`
	// Record turns on run recording (web kind only): a browser screenshot
	// every Interval for the whole run, encoded to one video. See RecordConfig.
	Record *RecordConfig `yaml:"record,omitempty"`
	Prompt string        `yaml:"-"`
}

type BudgetConfig struct {
	Size  string       `yaml:"size,omitempty"`
	Watch *WatchConfig `yaml:"watch,omitempty"`
}

type FloorConfig struct {
	TriggerIterations int    `yaml:"trigger_iterations,omitempty"`
	TriggerDuration   string `yaml:"trigger_duration,omitempty"`
	TriggerSize       string `yaml:"trigger_size,omitempty"`
	Iterations        int    `yaml:"iterations,omitempty"`
	Duration          string `yaml:"duration,omitempty"`
	Size              string `yaml:"size,omitempty"`
}

type Kind string

type LoopConfig struct {
	Do    *StepConfig  `yaml:"do,omitempty"`
	While *WhileConfig `yaml:"while,omitempty"`
}

type LoopPromptsConfig struct {
	Until       string `yaml:"until,omitempty"`
	IterateWith string `yaml:"iterate_with,omitempty"`
}

type LoopSpec struct {
	// Enabled is true when a while block is configured, not switched off
	// (`enabled: false`), and has an until prompt (without an exit condition
	// there is nothing to loop for).
	Enabled bool
	// MaxIterations caps the outer passes while Until stays unfulfilled, and
	// divides the while totals during redistribution.
	MaxIterations int
	// MaxDuration is the while-loop's wall-clock TOTAL, kept as a hard outer
	// deadline. Non-zero only when the redistribute branch fired for the
	// duration axis (while.max_duration > per-pass do.max_duration); 0 means
	// no outer time constraint (axis omitted, unparseable, or disabled by the
	// policy).
	MaxDuration time.Duration
	// MaxTokens is the while-loop's token TOTAL, mirrored for reporting.
	// Non-zero only when the redistribute branch fired for the token axis;
	// its enforcement is the even division itself — each pass is armed with
	// MaxTokens/MaxIterations, so N passes spend ≈ the total (a takeover
	// floor may raise a wrap-up leg past its share; a clipped wrap-up loses
	// the pass's work, which costs more than the overshoot).
	MaxTokens int
	// Until is the LLM-judged exit condition, evaluated against the latest
	// saved results after each pass.
	Until string
	// IterateWith is the prompt for passes 2..N (never empty when Enabled —
	// falls back to DefaultLoopIteratePrompt).
	IterateWith string
	// JudgeModel / JudgeEffort are the resolved judge seat (while.model /
	// while.effort, recipe > config; empty → session defaults).
	JudgeModel  string
	JudgeEffort string
}

type NotifyConfig struct {
	Humanoid string `yaml:"humanoid,omitempty"`
	Channel  string `yaml:"channel,omitempty"`
	To       string `yaml:"to,omitempty"`
}

type RecordConfig struct {
	Enabled   *bool  `yaml:"enabled,omitempty"`
	Path      string `yaml:"path,omitempty"`
	Interval  string `yaml:"interval,omitempty"`
	Format    string `yaml:"format,omitempty"`
	Quality   int    `yaml:"quality,omitempty"`
	MaxFrames int    `yaml:"max_frames,omitempty"`
}

type RecordFlags struct {
	On       bool
	Off      bool
	Path     string
	Interval time.Duration
}

type RecordSpec struct {
	Enabled   bool
	Path      string // may be empty/relative here; see ResolvePath
	Interval  time.Duration
	Format    string
	Quality   int
	MaxFrames int
}

type RunBudget struct {
	AutoContinue     bool
	AutoApprove      bool          // run tool calls without the approval dialog
	MaxIterations    int           // total steps ceiling → takeover
	MaxDuration      time.Duration // wall-clock ceiling → takeover
	StepInterval     int           // steps per leg (checkpoint/auto-resume cadence)
	MaxContextTokens int           // cumulative token ceiling (budget.size) → takeover
	TakeoverWhen     int           // % of every ceiling consumed before the takeover leg starts
	// Model / Effort are the resolved executor seat (recipe > config; empty →
	// session defaults). FinalizerModel/FinalizerEffort are the finalizer
	// seat; empty falls back to Model/Effort downstream.
	Model           string
	Effort          string
	FinalizerModel  string
	FinalizerEffort string
	// Floor is the resolved takeover-floor policy (recipe > config > built-in),
	// applied by WithTakeoverFloor. Zero value → built-in floor.
	Floor TakeoverFloor
}

type StepConfig struct {
	Interval      int    `yaml:"interval,omitempty"`
	MaxIterations int    `yaml:"max_iterations,omitempty"`
	MaxDuration   string `yaml:"max_duration,omitempty"`
	AutoContinue  *bool  `yaml:"auto_continue,omitempty"`
	AutoApprove   *bool  `yaml:"auto_approve,omitempty"`
	// Model / Effort override the executor's model and effort for this
	// recipe's main legs (seat 1 of 3; empty → session defaults). Effort is
	// low|medium|high|xhigh|max.
	Model  string        `yaml:"model,omitempty"`
	Effort string        `yaml:"effort,omitempty"`
	Budget *BudgetConfig `yaml:"budget,omitempty"`
}

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

type TakeoverFloor struct {
	TriggerIterations int
	TriggerDuration   time.Duration
	TriggerTokens     int
	Iterations        int
	Duration          time.Duration
	Tokens            int
}

type WatchConfig struct {
	TakeoverWhen   int    `yaml:"takeover_when,omitempty"`
	TakeoverPrompt string `yaml:"takeover_prompt,omitempty"`
	// Model / Effort override the model/effort for the FINALIZER (takeover)
	// leg only (seat 2 of 3) — the mechanical wrap-up can run on a cheaper
	// model. Empty → fall back to the step's Model/Effort, then defaults.
	Model  string       `yaml:"model,omitempty"`
	Effort string       `yaml:"effort,omitempty"`
	Floor  *FloorConfig `yaml:"floor,omitempty"`
}

type WhileConfig struct {
	Enabled       *bool  `yaml:"enabled,omitempty"`
	MaxIterations int    `yaml:"max_iterations,omitempty"`
	MaxDuration   string `yaml:"max_duration,omitempty"`
	Budget        string `yaml:"budget,omitempty"`
	// Model / Effort select the UNTIL-JUDGE's model and effort (seat 3 of 3;
	// empty → session defaults). A cheap fast model usually suffices for the
	// strict YES/NO evaluation.
	Model   string             `yaml:"model,omitempty"`
	Effort  string             `yaml:"effort,omitempty"`
	Prompts *LoopPromptsConfig `yaml:"prompts,omitempty"`
}