pausereason

const (
	// CodeUsageCap is a Claude Code subscription window whose configured
	// per-project cap has been reached, or that is exhausted outright while
	// budget.block_extra_usage keeps the run from spilling into extra usage
	// (Task 20440). This is the one pause that reliably ends on its own, which
	// is why it carries ResumesAt.
	CodeUsageCap Code = "usage_cap"
	// CodeBudget is a configured spend limit: the daily/global budget in
	// pkg/budget, or a per-task cost ceiling.
	CodeBudget Code = "budget"
	// CodeTokenBudget is the --token-budget cumulative token ceiling.
	CodeTokenBudget Code = "token_budget"
	// CodeStepLimit is the --steps or per-project max-steps ceiling.
	CodeStepLimit Code = "step_limit"
	// CodeApproval is a human-in-the-loop gate: an approval declined, or an
	// interactive review the operator quit.
	CodeApproval Code = "approval"
	// CodeAbort is a provider or harness refusal that waiting will not fix —
	// a hard quota, a rejected credential, a harness that would not start.
	CodeAbort Code = "abort"
	// CodeCancelled is a context cancellation: Ctrl-C, a deadline, or the
	// hub stopping the run.
	CodeCancelled Code = "cancelled"
	// CodePlanOnly is --plan-only: the plan was decomposed and shown, and
	// execution was never intended.
	CodePlanOnly Code = "plan_only"
	// CodeIdle is the ordinary end of a run — every runnable task is done and
	// auto-evolve is off, so there is nothing left to do until someone adds
	// work. It is a pause rather than a completion because the plan may still
	// grow.
	CodeIdle Code = "idle"
	// CodeOperator is a stop the operator asked for through the hub or CLI.
	CodeOperator Code = "operator"
	// CodeStale is a run that died without saying so — the process vanished
	// and the hub reconciled its status on the way back up.
	CodeStale Code = "stale"
	// CodeStateNotPersisted is a run that stopped itself because the project
	// database refused a write it could not do without: a task's outcome, a
	// pause, a plan change. Carrying on would have reported work the database
	// does not hold. Like CodeAbort it needs a human — free the disk, fix the
	// permissions, repair the row — and the next run recovers the tasks this
	// one left in progress.
	CodeStateNotPersisted Code = "state_not_persisted"
	// CodeUncommittedWork is a run that stopped because its tasks kept ending
	// with their changes uncommitted — or committed but not pushed — under a
	// project's "done means committed" setting (Task 20370): each such attempt
	// goes back to pending with its work left in the tree, and after the run's
	// consecutive-abort ceiling it stops rather than loop. A human decides: the
	// work is there to finish, commit or revert.
	CodeUncommittedWork Code = "uncommitted_work"
	// CodeDiskLow is a run that stopped starting work because a volume it
	// writes to — the one holding the project's .cloop, or the working
	// tree's — has less free space than orchestrator.min_free_disk_mb
	// (Task 20381), or because a task's outcome only reached the disk by
	// spending the space .cloop/reserve held back for it. A write that fails
	// for want of space is how a run used to learn this, and the write that
	// fails first is often the one recording what a task did.
	//
	// It is the one pause the run waits out itself: the process stays up,
	// checks again every minute, and carries on once the volume is back above
	// the floor plus a tenth — see RunWaits.
	CodeDiskLow Code = "disk_low"
	// CodeExecutorLost is a run whose executor stopped answering mid-run and
	// that nothing carried on (Task 20396): the supervisor declared the node
	// lost and claimed its session, and either no executor could take the run,
	// executors.failover.max_attempts allowed no further re-dispatch, a task it
	// was running was quarantined as a suspected node killer, or the
	// replacement could not be started. The detail names the lost executor and
	// why the run stopped there. A human decides: bring the executor back or
	// bind the project to another, then press Run.
	CodeExecutorLost Code = "executor_lost"
	// CodeDiskLimit is a run whose executor stopped it because its workspace
	// grew past its disk limit — .cloop/sandbox.yaml resources.disk, or an
	// operator's disk ceiling (Task 20405). The detail names both sizes. The
	// run is not retried: the task it was running goes back to pending, and a
	// human decides — free space in the workspace or raise the limit, then
	// press Run. A workspace still over the limit is refused at the next start.
	CodeDiskLimit Code = "disk_limit"
	// CodeStarterUnavailable is a run the hub would have carried on by itself
	// — an automatic resume after a usage cap, a failover's replacement — but
	// could not act for the person who started it (Task 20443): on a hub with
	// single sign-on their Claude Code home is gone (they were offboarded), they
	// are denied on the hub, or nobody can be named. Carrying on would have
	// spent the hub's shared login, or another person's. The detail names who
	// and why. A human decides: start the run as themselves, which acts on
	// their own account.
	CodeStarterUnavailable Code = "starter_unavailable"
)