generate

type Assembler interface {
	Assemble(ctx context.Context, req assemble.Request) (assemble.Result, error)
}

type Backends struct {
	Claude      func(model string) CheckedBackend
	Codex       func(model string) CheckedBackend
	CursorAgent func(model string) CheckedBackend
	Anthropic   func(model string) CheckedBackend
}

type Category string

type CheckedBackend interface {
	agent.Backend
	// Check returns the installed version.
	Check(ctx context.Context) (version string, err error)
}

type Error struct {
	Category Category
	Err      error
	// contains filtered or unexported fields
}

type ExplicitPathError struct {
	Backend config.Backend
	Path    string
	Err     error
}

type Group struct {
	// Name is the group's name, the document's stack title unless
	// GeneratedName.
	Name string
	// GeneratedName gives the document's stack title the name the model
	// writes for the group, when it wrote a usable one: a stack group's,
	// whose name is baum's. A group the person named keeps Name.
	GeneratedName bool
	// Members are the group's pull requests in group order.
	Members []GroupMember
	// MemberReviews is written to the run directory as members.json, the
	// members' own reviews in brief for the model to read.
	MemberReviews []byte
}

type GroupMember struct {
	Number int
	// Head, when not empty, is the head the run was confirmed for: a member
	// whose head moved fails the run before any model call.
	Head string
	// ReviewVersion is the member's saved review version the run reads,
	// recorded in the document's stack; at least 1.
	ReviewVersion int
}

type Options struct {
	PriceList *pricing.List
	Assembler Assembler
	// Request names the pull request and the limits. Run sets its Checkout and
	// Attachments writers.
	Request assemble.Request
	Backend agent.Backend
	// BackendVersion is the installed backend's version, for the progress line.
	BackendVersion string
	Model          string
	Budgets        agent.Budgets
	// PassTimeout bounds each backend call; zero leaves it to the wall clock.
	PassTimeout time.Duration
	// TileKinds is the tile allow-list; empty offers no tiles.
	TileKinds []string
	// Prompts defaults to this module's public prompt.
	Prompts agent.Prompts
	// Staged writes a single pull request's review in stages
	// (agent.Generator.StagedReview) instead of in one pass: the outline,
	// then the sections' details and the context. A section whose details
	// fail is published without them and a context that fails is left out;
	// only a failed outline (or no section with details) fails the run. A
	// review group is always written in one pass.
	Staged bool
	// StagedPrompts defaults to this module's public staged prompt.
	StagedPrompts agent.StagedPrompts
	// OnDraft, for a staged run, receives the review so far each time a
	// stage result lands, masked and completed as the published document is
	// (CompleteStaged) but with the sections still being written pending.
	// It is never a version. Calls come one at a time, from a goroutine of
	// the run, and the last one returns before Run does.
	OnDraft func(document []byte)
	// Continue, for a staged run, is the saved version to complete instead
	// of writing a new one: the latest version, some of whose sections
	// failed. Only the details of those sections are written again
	// (agent.StagedRun.Outline), against the version's head, base and merge
	// base, and the result is the same version with its metadata, model,
	// prompt version and generation time. Request.Previous must be the
	// version before it, which it was reconciled with. Nothing is kept for
	// a chat.
	Continue  *store.Version
	Validator *review.DocumentValidator
	Redactor  *bundle.Redactor
	// Progress receives one line per step; nil discards them. The document is
	// never written to it.
	Progress io.Writer
	// OnRepairs receives the validation repairs made so far after each
	// validation, over every stage of a staged run, without model text.
	OnRepairs func(repairs int)
	// KeepRunDir keeps the run directory and reports its path on Progress.
	KeepRunDir bool
	// KeepSession persists the backend's session and keeps the run directory,
	// under SessionRoot, when the run succeeds with a session id, and records
	// both in the version's Metadata.Session so a later chat can continue the
	// session in the same directory. A failed run, a missing session id and a
	// group review remove the directory as usual. Only a local Claude Code or
	// Codex backend supports it.
	KeepSession bool
	// SessionRoot is the directory kept runs are made in; empty is
	// reviewruns.DefaultRoot.
	SessionRoot string
	// Stored, for Publish, runs once the version is stored, with its metadata.
	// The version is already published: an error is a warning on Progress.
	Stored func(ctx context.Context, key store.Key, m store.Metadata) error
	// BundleOut, when not empty, receives the exact bundle the model was given.
	BundleOut string
	// DiagnosticsOut, when not empty, receives the run's redacted outcome as
	// JSON: usage, repairs, findings and at most agent.MaxDiagnostics events.
	// It is written for failed runs too.
	DiagnosticsOut string
	// Now defaults to time.Now.
	Now func() time.Time
	// Group, when set, generates a review group's combined review of the
	// pull requests it names instead of the one Request names; Prompts then
	// defaults to the public group prompt.
	Group *Group
}

type Result struct {
	Attachments []store.Attachment
	// Document is the finished, strictly valid document. Nil on any failure.
	Document []byte
	Metadata store.Metadata
	Outcome  agent.Outcome
	// RunDir is the run directory when KeepRunDir or KeepSession kept it.
	RunDir string
	// Elapsed is the wall time of the run.
	Elapsed time.Duration
	// FailedSections, for a staged run, are the sections the document holds
	// without their details, and ContextFailed says it has no context.
	FailedSections []string
	ContextFailed  bool
}

type Selected struct {
	Backend CheckedBackend
	Version string
	// Model is the model the backend was built with; empty is its default.
	Model string
}

type TaskOptions struct {
	Backend agent.Backend
	// Task is the task; its Budgets' WallClock bounds the whole run.
	Task agent.Task
	// PassTimeout bounds each backend call; zero leaves it to the wall clock.
	PassTimeout time.Duration
	Redactor    *bundle.Redactor
	Logger      *slog.Logger
}

type Versions interface {
	Latest(context.Context, store.Key) (store.Version, error)
	BeginRun(context.Context, store.Key, time.Time) (int64, error)
	HeartbeatRun(context.Context, int64, time.Time) error
	FinishRun(context.Context, int64, string) error
	Put(context.Context, store.Key, store.Version, store.Version) error
}