procgroup

type Adjudication struct {
	Status                Status                `json:"status"`
	Outcome               Outcome               `json:"outcome"`
	RecordCount           int                   `json:"record_count"`
	Launches              int                   `json:"launches"`
	UnobservedLaunches    int                   `json:"unobserved_launches"`
	CaseInconclusiveState CaseInconclusiveState `json:"-"`
	Reason                string                `json:"reason"`
	FullyObserved         bool                  `json:"-"`
}

type CaseInconclusiveState string

type DescendantObservation struct {
	Scope       string            `json:"scope"`
	IntervalMS  int               `json:"interval_ms"`
	Processes   []ObservedProcess `json:"processes"`
	Absent      bool              `json:"absent"`
	Failures    []string          `json:"failures"`
	Limitations []string          `json:"limitations"`
}

type Observation struct {
	DescendantObservation *DescendantObservation
	Stdout                []byte
	Stderr                []byte
	Usage                 *ResourceUsage

	ExitStatus                     int
	ExitObserved                   bool
	Signal                         string
	Err                            error
	Started                        bool
	TimedOut                       bool
	Cancelled                      bool
	OutputOverflow                 bool
	StdoutOverflow                 bool
	StderrOverflow                 bool
	WaitCompleted                  bool
	PipesDrained                   bool
	OwnedProcessGroupCleanup       bool
	DescendantCleanupStatus        string
	DescendantCleanupQualification string
}

type ObservedProcess struct {
	PID       int    `json:"pid"`
	ParentPID int    `json:"parent_pid"`
	Start     string `json:"start"`
	State     string `json:"state"`
}

type Outcome string

type OverflowPolicy uint8

type PrelaunchRefusal string

type ResourceUsage struct {
	UserCPUNs   int64
	SystemCPUNs int64
	MaxRSSBytes int64
}

type Spec struct {
	Argv  []string
	Dir   string
	Env   []string
	Stdin []byte
	// Dialogue is an internal bounded stdio protocol. It must stop when its
	// streams close, never spawn unjoined work, and enforce its input bound.
	// The process lifecycle closes both streams on every stop and joins it.
	Dialogue                 func(io.Reader, io.WriteCloser) error
	Timeout                  time.Duration
	ShutdownTimeout          time.Duration
	InputLimit               int
	OutputLimit              int
	StderrLimit              int // Zero inherits the normalized OutputLimit.
	OverflowPolicy           OverflowPolicy
	RequireDescendantCleanup bool
	// ObserveDescendants additionally tracks observed PID/start identities,
	// including children that leave the owned group. This is bounded observation,
	// not full containment: a fast detach between samples can remain unobserved.
	ObserveDescendants bool
	// JoinAncestorProcessGroup makes this leader join the process group of
	// whichever process starts it, instead of creating a new one. Set this
	// only when the caller is itself a leader running inside an ancestor's
	// owned process group (a nested Run inside a Run): it lets the
	// ancestor's group-directed kill reach this leader and its own
	// descendants directly, no matter how deeply Run calls nest. This Run
	// call in turn stops only its own pid on its own timeout or cancel,
	// since it does not own the shared group. It therefore cannot prove its
	// descendants gone: the observation reports DescendantCleanupStatus
	// "ancestor-process-group", a PARTIAL qualification, and never
	// OwnedProcessGroupCleanup; the ancestor's own Run carries that proof.
	JoinAncestorProcessGroup bool
	// BeforeStop is an audited internal, synchronous cleanup hook. It must honor
	// its context and leave no asynchronous work. The allowance is at most one
	// second (half ShutdownTimeout), in addition to the normal shutdown budget;
	// arbitrary callbacks cannot be forcibly bounded safely.
	BeforeStop func(context.Context, int) error
	// AfterStart may register a leader-bound observer; output drains start as
	// soon as the pipes exist, before this hook runs, so a child that fills a
	// pipe cannot block behind it. It has the same cooperative allowance as
	// BeforeStop; any observer it starts must be joined by BeforeStop,
	// including after an initialization failure.
	AfterStart func(context.Context, int) error
}

type Status string