worker

type Config struct {
	Owner        string        // lease owner identity (default: auto)
	Concurrency  int           // parallel task executions (default 2)
	PollInterval time.Duration // idle poll gap (default 250ms)
	// IdlePollMax caps the adaptive idle poll gap: consecutive empty
	// claims (ErrNoTaskDue) double the gap up to this cap, and any claim
	// resets it to PollInterval — an idle pool stops paying the full
	// candidate-scan cost at every tick while a fresh task is still
	// claimed within the cap. Default 2s; negative disables the ladder
	// (fixed PollInterval, the historical behavior).
	IdlePollMax time.Duration

	// Wake is the optional claim-wake channel (queue.Waker.Notify from a
	// Waker store): a commit that may have landed a task in PENDING
	// fires it, so an idle loop re-claims in milliseconds instead of
	// waiting out the idle ladder, and the wake resets the ladder to
	// full cadence. The ladder stays the degraded fallback — a nil Wake
	// (or a store without the seam) keeps the pure poll behavior, and
	// the signal is process-local, so same-DB pools in other processes
	// still poll.
	Wake <-chan struct{}

	Lease       time.Duration // claim lease length (default 2m)
	Heartbeat   time.Duration // heartbeat cadence, < Lease (default 30s)
	TaskTimeout time.Duration // per-task execution cap (default 10m)
	Executors   *executor.Registry
	Backoff     func(attempt int) time.Duration // retry backoff (default exp)
	// PreflightBackoff delays re-claiming after a preflight refusal
	// (dirty repo, missing autonomy config). Default 2m. No attempt is
	// burned by preflight refusals.
	PreflightBackoff time.Duration

	// EnvRequeueBurn bounds the environmental-requeue ladder (R3 option
	// (a), docs/planning/2026-10-01_11-19_env-requeue-circuit-breaker.md):
	// after this many consecutive preflight/gate refusals the attempt
	// burns (store.Fail, exponential NotBefore escalation) instead of
	// requeueing again, so a sustained-sick gate cannot churn claims
	// forever. Default 3; negative disables (pure requeue behavior).
	EnvRequeueBurn int

	// Budget is the claim-time spend gate: before a claimed task's
	// executor runs, the hook decides whether the pool may start another
	// paid turn at all. A blocked task is requeued WITHOUT burning an
	// attempt, parked until the returned delay passes (a daily cap
	// resolves at local midnight), so work enqueued before the cap bit
	// cannot burn money after it. The reason rides the task.requeued
	// fact with requeue class "budget". Nil = ungated (historical
	// behavior); budget refusals never ride the environmental
	// streak/burn ladder — an exhausted budget is policy, not a sick
	// environment.
	Budget func(ctx context.Context) (blocked bool, reason string, retryIn time.Duration)

	// DonePreflight is the claim-time done gate: before a claimed task's
	// executor runs, the hook decides whether the task's work is provably
	// already done (footer commits exist, todo item ticked, fix cured…). A
	// done task completes immediately — no agent session, no attempt burn,
	// no review minted — with an AgentResult carrying PreflightDone=reason
	// as the completion detail. The hook must fail open (return false) on
	// its own errors: it augments dispatch, never blocks it. Nil =
	// ungated (historical behavior).
	DonePreflight func(ctx context.Context, t task.Task) (done bool, reason string)
}

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