Timings and defaults¶

Name	Value	What it is
`dispatch.UnresolvedMinAge`	10 minutes	the default for how long an attempt's outcome stays unknown before it escalates; `dispatch.WithUnresolvedAge`
`dispatch.CleanupDeadline`	30 minutes	the default for how long after a cancel the record may stay unsettled before it escalates, once; `dispatch.WithCleanupDeadline`
`dispatch.CallDeadline`	30 seconds	how far ahead of now a hold, release or requeue call's deadline is set
`dispatch.SharedHoldFor`	24 hours	the deadline of the hold a recovery rule becomes under a shared checkpoint
`dispatch.CessationInterval`	1 minute	how often the adapter's cessation signal is asked again while that hold stands
`records.DefaultSubmitRetries`	2	the default for how many times `Start` is retried for one submission after an unknown outcome; `dispatch.WithSubmitRetries`
`supervise.DefaultDrain`	30 seconds	how long a stopping supervisor may spend finishing the step in flight; `supervise.WithDrain`
`supervise.DefaultPoll`	30 seconds	the longest a supervisor sleeps without looking at the backend; `supervise.WithPoll`
`dispatch.HoldBase`	315,576,000 seconds (ten Julian years)	the offset of a Slurm hold's far-future start time from the job's submit time; see holds as a far-future start time

The retry bound, the clean-up deadline and the escalation age are a job's own: set at submit, recorded in the record's header, and read from there by every actor. The call deadline, the shared-checkpoint hold and the cessation interval are constants. A call counts as expired at its deadline plus the adapter's declared CallBound, as recorded in the job's header.

Each adapter works out its own CallBound: the Slurm adapter from its preflight's measurements (how the call bound is made), and the Kubeflow adapter from its timeouts.apiserverRequest setting (declarations).

supervise.New refuses a poll interval longer than any PolledLoss window the adapter declares, unless the adapter implements Watcher. A window of dispatch.Unbounded never refuses one.

supervise.Healthy(loopAt, poll, now) calls a supervisor healthy while its last completed loop is no older than three poll intervals. Where the store implements the optional records.Health, the supervisor records that time after every pass that completes, and records.Health.Loop reads it back. It is display-only: it is not a commit, never moves the revision, and a failure to record it changes nothing the supervisor does.

Supervisor options¶

Option	Default	Sets
`supervise.WithDrain(d)`	30 seconds	the drain bound; must be positive
`supervise.WithPoll(d)`	30 seconds	the poll interval; must be positive
`supervise.WithIdentity(id)`	`supervisor`	the supervisor's id in the record and in the ownership lease
`supervise.WithDeliver(f)`	none	how escalations reach a person

Submit options¶

Option	Default	Sets
`dispatch.WithSupervisor()`	off	the host will supervise the job, so the supervisor may enforce its rules
`dispatch.WithIdempotencyKey(k)`	none	a repeated `Submit` with `k` returns the existing job's plan
`dispatch.WithUnmatched(p)`	`UnmatchedResidual`	how an attempt with an unknown outcome affects settlement
`dispatch.AcceptUnverified(rule, e)`	none	accept a rule whose `Perform` is `unknown`, naming its enforcer
`dispatch.AcceptUnenforced(rule)`	none	accept that nobody enforces a rule
`dispatch.WithSubmitRetries(n)`	2	how often an ambiguous submit is retried; 0 disables retries
`dispatch.WithCleanupDeadline(d)`	30 minutes	how long clean-up may stay pending before it escalates
`dispatch.WithUnresolvedAge(d)`	10 minutes	how long attempts may stay unknown before they escalate

Supersede takes the same options.