pulse

type BeatInput struct {
	Queue  string // the queue directory: pending, launched, done, failed and the state files
	Cairn  string // the cairn file this beat is appended to
	Title  string // the one-line title of this beat
	Resume string // the resume rule; empty takes DefaultResume
	Now    func() time.Time
	Stdout io.Writer
	Stderr io.Writer
}

type BenchReading struct {
	Name    string
	Live    int
	Cores   int
	Load    int
	FreeGB  int
	MemGB   int
	Allowed int
	Hygiene int // reaps and deletions on this bench since the window opened
	// Down is the bench that did not answer. It is NOT a bench with nothing to do, and the
	// difference is what the 2026-09-17 pit stop cost: a row of zeros reads as an idle
	// bench, so a fleet nobody could see looked like a fleet with nothing to do. The page
	// says DOWN, the metrics row writes a dash for its disk rather than a number the bench
	// never gave, and the STATUS HTML line counts it.
	Down bool
	// Note says WHY, when the bench answered well enough to tell us. A bench whose home is
	// not there answers every other question perfectly and then reports no disk, which read
	// as "out of disk, allowed 0" on every row of a page that was otherwise right.
	Note string
}

type BenchShell interface {
	Run(bench, script string) (string, error)
}

type CIJob struct {
	Name        string `json:"name"`
	Log         string `json:"log"`
	StartedAt   string `json:"startedAt"`
	CompletedAt string `json:"completedAt"`
}

type CIRun struct {
	ID         int64  `json:"databaseId"`
	Status     string `json:"status"`
	Conclusion string `json:"conclusion"`
	HeadSHA    string `json:"headSha"`
	Workflow   string `json:"workflowName"`
	Event      string `json:"event"`
	CreatedAt  string `json:"createdAt"`
	UpdatedAt  string `json:"updatedAt"`
}

type Candidate struct {
	Source   string
	ID       string
	Kind     string
	Title    string
	Template string
}

type Capacity interface {
	Capacity(bench string) (int, error)
}

type CardLauncher interface {
	Launch(bench, card string) error
}

type CardRow struct {
	Label string
	Slot  string
	Model string
	Card  string
}

type Config struct {
	Slots map[string]int
	// Headroom is a ratio of the bench's cores, so it is a decimal: the spec writes it
	// `cores x 1.5` and 2.5 is a value a person writes (issue #869).
	Headroom            map[string]float64
	TickSeconds         int
	RefillCadence       int
	IntegrationBranches []string
	RunnersPerMachine   int
	Files               int    // the --files budget every launched card carries
	Tokens              string // the --tokens budget: a number, or the word `unmetered`
}

type CutInput struct {
	Pool      string // path to pool.tsv: source, id, kind, title, template per line
	Templates string // the directory holding read.md fix.md text.md replay.md drift.md tone.md and benches.tsv (or routes.tsv, or a models.tsv fallback)
	Out       string // the directory the card files go into
	Root      string // the state root; skipped.tsv and retry.tsv are read and written here
	Local     string // an optional ollama tag that overrides the flash model for read and text cards
	Max       int    // cap on the cards cut, and on the skipped lines printed; 0 means no cap
	Probe     bool   // run the learned admission checklist before writing each card (#585)
	History   string // the abstain history the checklist is cut from, when Probe is set
	Budget    int    // the card's byte budget, when Probe is set; 0 means unbounded
	Stdout    io.Writer
	Stderr    io.Writer
}

type CutKindInput struct {
	Kind      string
	Repo      string // owner/name; line 1 names the repo for every kind
	PR        int    // read, rebase
	Head      string // read
	Issue     int    // fix
	Title     string // fix, spec, rebase, and the parenthesised title of a read
	Branch    string // rebase: the branch rebased onto the base
	Base      string // rebase: the branch it is rebased onto
	BodyFile  string // fix, spec: the numbered steps this card carries
	Prior     string // fix: what a prior attempt did, so the worker never repeats it
	Names     string // replay: the replay names, comma separated
	SpecLines string // replay: the spec lines the replays are named at
	Out       string // the directory the card is written into
	Queue     string // the queue directory holding the state file and its lock
	Stdout    io.Writer
	Stderr    io.Writer
}

type CutValidatedInput struct {
	Source     string // issue, rows or branch-from
	Issue      string // <owner>/<repo>#<n> when Source is issue
	Rows       string // the rows.tsv path when Source is rows
	BranchFrom string // <owner>/<repo>#<n> when Source is branch-from
	Templates  string // the directory holding the source's .md template
	Out        string // the directory the cards go into
	Repo       string // the clone every git call runs in: `git -C <repo> ...`, never the working directory
	Base       string // the base branch a source that names none is cut onto; "" is dev
	Cards      string // where the cards.tsv goes; "" is <out>/cards.tsv, which puts a table in a queue directory
	Max        int    // cap on the cards cut; 0 lifts it
	Stdout     io.Writer
	Stderr     io.Writer
}

type Decider interface {
	Decide(ctx context.Context, state string, qs map[string]decide.Question) (map[string]decide.Answer, decide.Usage, error)
}

type Enqueuer interface {
	Enqueue(repo string, pr int) error
}

type FillInput struct {
	Ready    string        // the queue/ready directory the card-<n>.md are popped from
	Launched string        // the queue/launched directory they are moved into; its cards are live
	Lanes    string        // the lanes file: <name>\t<path prefixes> per line; empty names no lane
	Machines string        // the machines registry; a bench whose roles lack `bench` is refused
	Session  string        // the session id stamped into every launched card's marker
	Benches  []string      // the benches to fill, in order
	Only     []string      // glob patterns over a card's filename; empty takes every ready card
	Once     bool          // true runs exactly one tick and returns
	Interval time.Duration // how long between ticks; 0 takes FillInterval
	Stdout   io.Writer
	Stderr   io.Writer
	Now      func() time.Time
	Sleep    func(time.Duration)
	Launcher CardLauncher
	Capacity Capacity
}

type FleetAddInput struct {
	Bench  string
	Queue  string
	Roots  string
	Probe  string
	Stdout io.Writer
	Stderr io.Writer
}

type FleetBench struct {
	Name string
	SSH  string
	Home string
	MAC  string
}

type FleetJoinInput struct {
	Benches    string // the fleet file
	Machines   string // the machines registry; a machine whose roles lack `bench` is refused
	Name       string // the one bench, which is also its tailnet hostname
	SSH        string // the ssh program; empty is "ssh"
	Tailscale  string // the absolute path of tailscale ON THE BENCH
	AuthKeyEnv string // the environment variable holding the auth key
	Getenv     func(string) string
	Timeout    time.Duration
	Runner     FleetRunner
	Stdout     io.Writer
	Stderr     io.Writer
}

type FleetMirrorInput struct {
	Benches  string // the fleet file
	Machines string // the machines registry; a machine whose roles lack `bench` is refused
	Name     string // the one bench
	SSH      string // the ssh program; empty is "ssh"
	Repo     string // the https remote to mirror
	Path     string // the absolute path of the bare mirror on the bench
	Timeout  time.Duration
	Runner   FleetRunner
	Stdout   io.Writer
	Stderr   io.Writer
}

type FleetProbeJob struct {
	Runner     string
	Conclusion string
}

type FleetProbeRecord struct {
	Run   string
	Bench string
	Jobs  []FleetProbeJob
}

type FleetReader func(benches []FleetBench, now time.Time) []BenchReading

type FleetRebootInput struct {
	Benches  string
	Machines string // the machines registry; empty leaves the older refusals as the guard
	Names    []string
	SSH      string // the ssh program; empty is "ssh"
	Wait     time.Duration
	Timeout  time.Duration
	Max      int // at most this many FLEET lines; 0 is all
	Now      func() time.Time
	Sleep    func(time.Duration)
	Stdout   io.Writer
	Stderr   io.Writer
}

type FleetRegistryInput struct {
	Machines string // the machines file
	Role     string // list only the machines carrying this role; empty is all of them
	Max      int    // at most this many MACHINE lines; 0 is all
	Stdout   io.Writer
	Stderr   io.Writer
}

type FleetRunner interface {
	Run(ctx context.Context, target, script string) (string, error)
}

type FleetSecretsInput struct {
	Benches string
	SSH     string
	Timeout time.Duration
	Max     int
	Stdout  io.Writer
	Stderr  io.Writer
}

type FleetSleepInput struct {
	Benches  string // the fleet file
	Machines string // the machines registry; a machine whose roles lack `bench` is refused
	Name     string // the one bench to put to sleep
	SSH      string // the ssh program; empty is "ssh"
	Force    bool   // sleep even a busy bench
	IfIdle   bool   // skip a busy bench instead of refusing it
	Timeout  time.Duration
	Max      int
	Stdout   io.Writer
	Stderr   io.Writer
}

type FleetStandardInput struct {
	Benches   string // the fleet file: name<TAB>ssh target<TAB>home<TAB>mac
	Machines  string // the machines registry; a machine whose roles lack `bench` is refused
	Name      string // the one bench to check
	SSH       string // the ssh program; empty is "ssh"
	OS        string // "linux" or "darwin"; empty asks the bench with uname -s
	Go        string // the Go toolchain the fleet is on; empty is go1.26.5
	Want      string // the nova bins' stamp; empty reports what the bench has
	MinFreeGB int    // the floor on free space under HOME
	Timeout   time.Duration
	Max       int // at most this many lines; 0 is all
	Runner    FleetRunner
	Stdout    io.Writer
	Stderr    io.Writer
}

type FleetSuspendInput struct {
	Benches  string
	Machines string // the machines registry; empty leaves the older refusals as the guard
	Names    []string
	SSH      string // the ssh program; empty is "ssh"
	Force    bool   // suspend even a busy bench
	IfIdle   bool   // skip a busy bench instead of refusing it
	Timeout  time.Duration
	Max      int // at most this many FLEET lines; 0 is all
	Stdout   io.Writer
	Stderr   io.Writer
}

type FleetWakeInput struct {
	Benches  string
	Machines string // the machines registry; empty leaves the older refusals as the guard
	Names    []string
	SSH      string // the ssh program; empty is "ssh"
	Wait     time.Duration
	Timeout  time.Duration
	Max      int // at most this many FLEET lines; 0 is all
	Now      func() time.Time
	Sleep    func(time.Duration)
	Send     func(packet []byte, addr string) error
	Stdout   io.Writer
	Stderr   io.Writer
}

type Forge interface {
	FindPR(repo, branch string) (int, error)
	CreatePR(repo, base, branch, title, body string) (int, error)
}

type GHEnqueuer struct{ Timeout time.Duration }

type GHRunners struct{ Timeout time.Duration }

type GHSource struct{ Timeout time.Duration }

type GHWork struct{ Timeout time.Duration }

type GateInput struct {
	Repo   string
	Branch string
	Queue  string // the queue directory STOP lives in
	Source RunSource
	Stdout io.Writer
	Stderr io.Writer

	// Decide turns on the gate's typed decision: a failing job is classified behind Floor,
	// and a flaky verdict reruns the failed jobs once for the head. A decision below the
	// floor is a suggestion, never an authorization, and today's STOP stands.
	Decide  bool
	Floor   float64
	Decider Decider
}

type Gater interface {
	// Gate reports whether the branch is red this tick, the sha or reason that says so,
	// and an error when the probe itself could not run (never a verdict).
	Gate(tick int) (red bool, why string, err error)
}

type HarvestInput struct {
	ID           string
	Root         string
	Sources      string
	Templates    string
	MaxBodyBytes int
	Max          int
	Stdout       io.Writer
	Stderr       io.Writer
	Now          func() time.Time

	// Decide turns on the harvest's one typed decision per finished job: before
	// any push each done card's RESULT.md is classified behind Floor as fixed,
	// already-fixed, no-change, failed or off-branch. Decider is the typed
	// decision seam (the shipped *decide.Client; a test's fake). A nil Decider
	// leaves the harvest exactly as it was.
	Decide  bool
	Floor   float64
	Decider Decider

	// Bench turns the harvest around: the jobs are read on that bench over the
	// BenchShell seam rather than under a local root, and Root names the swarm
	// root ON the bench (comma separated for more than one). A bench harvest
	// wants no --sources, no --templates and no --id -- which a `cut --rows`
	// never produces -- and never relaunches: it folds what is there.
	Bench string
	// Machines is the machines registry --bench is held against before the first ssh
	// (Glenn's lock of 2026-09-18: runner hosts are CI-only). An empty path leaves the
	// verb unguarded, which is what a test and a by-hand run want; cmd/nova-pulse names
	// the registry on every real invocation.
	Machines     string
	SSH          string   // the ssh program the shipped shell runs; "" is "ssh"
	Clones       []string // <owner>/<name>=<dir>, or a bare <dir> for any repo
	Session      string   // only jobs whose RESULT.md names this session
	BranchPrefix string   // only branches under this prefix; "" is rowan/
	Base         string   // the base of a card that names none; "" is dev
	Since        time.Duration
	Shell        BenchShell
	Forge        Forge

	// Launched is the queue directory `fill` moves live cards into. When it is
	// named, harvest drains it: a card whose job has finished leaves it for Done
	// or Failed, its launched marker goes with it, and its lane is free.
	Launched string
	Done     string
	Failed   string
}

type Harvester interface {
	Harvest(tick int) (done int, undecided []Undecided, err error)
}

type HygieneDisk interface {
	FreeGB() int
	Free() string
	SizeGB(path string) int
}

type HygieneInput struct {
	Verb   string // run, reap, delete-job, delete-slot, drop-cache, log
	Slot   string
	Job    string
	DryRun bool
	N      int // log: how many trailing lines

	Home      string   // every root, the log and the cache hang under it
	Roots     []string // default <home>/rowan-swarm-root, <home>/rowan-working/tmp
	LogPath   string   // default <home>/hygiene.log
	CachePath string   // default <home>/.cache/go-build
	Hostname  string   // default the short local host name

	// The runner `_diag` prune's two rules. Zero means the default.
	DiagDays     int   // age window in days, default HygieneDiagDaysDefault
	DiagMaxBytes int64 // per-runner-directory cap, default HygieneDiagMaxBytesDefault

	Now    func() time.Time
	Procs  HygieneProcs
	Disk   HygieneDisk
	Stdout io.Writer
	Stderr io.Writer
}

type HygieneProcs interface {
	Busy(path string) bool
}

type LaunchInput struct {
	Cards    string // path to cards.tsv: label<TAB>slot<TAB>model<TAB>card
	Root     string // the pulse root; the swarm pool lives under <root>/pool
	Slots    int    // the ceiling on free slots launch considers
	Deadline string // the whole pulse's deadline, whole seconds
	Queue    bool   // true keeps the overflow in queue.tsv instead of refusing
	Files    int    // the --files budget every card in the batch carries; 0 takes the default
	Tokens   string // the --tokens budget; empty takes the default
	QueueDir string // the queue directory STOP lives in; empty falls back to Root (admission.go)
	// Routes is the routes.tsv the typed decision reads to pick each card's worker. Empty
	// means no routing: the cards group by their own model column, exactly as before.
	Routes  string
	Floor   float64 // answers below the floor keep the card's own model as the default worker
	KeyEnv  string  // the environment variable the decision's key comes from
	BaseURL string  // the decision provider endpoint
	Stdout  io.Writer
	Stderr  io.Writer
	Now     func() time.Time
	// Log is where the structured JSON event line goes, beside the stdout line and never
	// instead of it. nil writes no JSON line, which is how the tests that predate the
	// slice keep their exact stdout and stderr; cmd/nova-pulse passes stderr, which on a
	// bench is the systemd journal.
	Log io.Writer
	// GUID is the source of this run's guid. nil reads the real /proc in production; a
	// test injects a fixed one so it reads no /proc.
	GUID func() string
}

type Launcher interface {
	Launch(tick int) (launched, free int, err error)
}

type LedgerRow struct {
	PR         int
	Head       string
	Card       string
	Verdict    string // APPROVE, HOLD, STALE
	At         string // when the verdict was recorded, RFC3339 UTC
	EnqueuedAt string // when the merge was enqueued, or "-"
	ClosedAt   string // when the row was closed, or "-"
}

type LoopCount struct {
	Label string
	N     int
}

type ManagerInput struct {
	Policy string // the finite policy this shift executes
	Queue  string // the queue directory: pending, launched, done, failed and the state files
	Roots  string // comma-separated swarm roots, the benches this shift harvests
	Bus    string // the nova-bus clone this shift is the single waiter on
	As     string // the name this shift waits and receipts as
	Hours  float64
	Max    int
	Stdout io.Writer
	Stderr io.Writer
	Now    func() time.Time
}

type Notifier interface {
	Note(subject, body string) error
}

type OSDisk struct{ Home string }

type OSProcs struct{ Timeout time.Duration }

type OpenIssue struct {
	Number int
	Title  string
	Body   string
}

type OpenPR struct {
	Number int
	Head   string
	Draft  bool
	Title  string
	Body   string
}

type PRCheck struct {
	Name  string
	State string
}

type PRSource interface {
	View(repo string, pr int) (PRView, error)
}

type PRView struct {
	Number  int
	State   string // OPEN, MERGED, CLOSED
	IsDraft bool
	Head    string
	Labels  []string
	Title   string
	Checks  []PRCheck
	// AutoMerge says the forge is carrying a STANDING INSTRUCTION to merge this pull
	// request when its checks go green. It is not an enqueue and it is not ours: the sweep
	// reads it as a hold, and `nova-merge queue audit` takes it off.
	AutoMerge bool
}

type Packet struct {
	Case    string
	Ref     string
	Result  []string // the RESULT lines of the card the case is about
	Refusal string   // the harness's refusal line, one line
	Rules   []RuleRow
}

type PoolInput struct {
	Sources string        // path to the declared sources TSV (kind, locator, template)
	Root    string        // root directory holding seen.tsv and the default pool.tsv
	Out     string        // path pool.tsv is written to; empty means <root>/pool.tsv
	Timeout time.Duration // bound on every gh child, default 120s
	Max     int           // bound on admitted candidates; 0 means no bound
	Stdout  io.Writer
	Stderr  io.Writer
}

type PoolRow = Candidate

type ProbeInput struct {
	Label   string
	Card    string
	History string
	Budget  int
	Stdout  io.Writer
	Stderr  io.Writer
}

type Proc struct {
	PID  int
	Age  time.Duration
	Args string
}

type ProcessTable interface {
	List() ([]Proc, error)
	Alive(pid int) bool
	Kill(pid int) error
}

type ProgressInput struct {
	Queue  string // the queue directory: pending, launched, done and the POLICY
	Roots  string // comma-separated swarm roots, the benches whose usage.tsv is read
	Day    string // YYYY-MM-DD the day window starts at; empty means today (UTC)
	Stdout io.Writer
	Stderr io.Writer
	Now    func() time.Time
}

type PublishFile struct {
	Name string
	Body []byte
}

type Publisher func(dest string, files []PublishFile, timeout time.Duration) error

type ReapInput struct {
	Roots    string // comma-separated swarm roots
	Queue    string // the queue directory holding pending, launched and failed
	Deadline time.Duration
	DryRun   bool
	Procs    ProcessTable
	TempGlob string        // default "/tmp/*swarmtest*"; a test points it at its own directory
	TempRoot string        // the directory the temp glob must sit under; empty derives it from the glob's literal prefix
	TempAge  time.Duration // default 30 minutes

	// Rule E2 (runners.go): a runner busy with no in-progress run on Repo for longer than
	// RunnerIdle is restarted through its service. With no Repo and no Runners table the
	// rule does not run and the count is zero: a bench with no self-hosted runner has no
	// jam to clear.
	Repo       string
	Runners    RunnerTable
	Restarter  RunnerRestarter
	RunnerIdle time.Duration // default DefaultRunnerIdle (5 minutes)
	Now        func() time.Time
	Stdout     io.Writer
	Stderr     io.Writer
}

type Reaper interface {
	Reap(tick int) (requeued, failed int, undecided []Undecided, err error)
}

type Refiller interface {
	Refill(tick int) (added int, err error)
}

type Rerunner interface {
	RerunFailed(repo string, runID int64) error
}

type RuleRow struct {
	Kind      string
	Condition string
	Verdict   string
	State     string
}

type RunInput struct {
	Queue  string // the queue directory: pending, launched, done, failed, STOP, RULES.tsv
	Roots  string // the benches, comma separated
	Repo   string // owner/name, the repo the gate watches
	Branch string // the branch the gate watches
	Hours  float64
	Tick   time.Duration
	Once   bool
	Max    int
	Bus    string // a nova-bus clone; empty sends notes to <queue>/ESCALATE
	As     string // the name notes are sent to
	Stdout io.Writer
	Stderr io.Writer

	Now   func() time.Time
	Sleep func(time.Duration)

	// GateEvery is how many ticks apart the gate's own probe runs; 0 is gateEvery. It is a
	// field and not a constant so a bench with a slow gh and a bench with a fixture can
	// each say how often the probe is worth its seconds.
	GateEvery int

	// Configured, when set, is handed the configuration after every re-read, so the seams
	// run on the same values this loop does and pulse.toml has ONE reader per tick.
	Configured func(Config)

	Gate     Gater
	Harvest  Harvester
	Sweep    Sweeper
	Reap     Reaper
	Refill   Refiller
	Launcher Launcher
	Notifier Notifier
}

type RunSource interface {
	LatestRun(repo, branch string) ([]CIRun, error)
	FailedJob(repo string, runID int64) (CIJob, error)
}

type Runner struct {
	Name   string `json:"name"`
	Status string `json:"status"` // online, offline
	Busy   bool   `json:"busy"`
}

type RunnerRestarter interface {
	Restart(name string) error
}

type RunnerService struct {
	Name   string
	Host   string // "-" or empty is this machine
	Kind   string // systemd or svc
	Target string // the unit, or the runner directory holding svc.sh
}

type RunnerTable interface {
	Runners(repo string) ([]Runner, error)
	InProgress(repo string) (int, error)
}

type SSHRunner struct {
	Program string
}

type SelfReader func(name string, loops []string, now time.Time) SelfReading

type SelfReading struct {
	Name      string
	CIRunners int
	Cores     int
	Load      int
	FreeGB    int
	Orphans   int
	Loops     []LoopCount
	Unknown   bool // the host could not be read; it renders like a DOWN bench
}

type ServiceRestarter struct {
	Queue   string
	Timeout time.Duration
}

type StandardCheck struct {
	Name  string // the token the STANDARD line carries
	OS    string // "linux", "darwin", or "" for every bench
	Probe string // one line of POSIX shell printing the value on stdout
	Match string // one of the Match* constants
	Want  string // what Match compares against
	// Root, when set, is the TOOLCHAIN ROOT this check is the standard's own copy of, in the
	// slash form internal/swarm/toolchain.go declares it: HOME-relative (`sdk`) or absolute
	// (`/opt/homebrew/Cellar/go`). The wall grants exactly these paths, so the standard and
	// the wall are ONE LIST checked in both directions, per OS, by the class test in
	// internal/ci -- a root the wall grants that no bench provisions is a wall naming a path
	// that will not be there, and a root a bench has that the wall never names is the hurt of
	// 2026-09-18 returning. The KIND of each grant is the wall's decision and lives with the
	// wall, not here: a bench only has to HAVE a root.
	Root string
}

type State struct {
	NextCard   int
	Tick       int
	RefillTick int
	Gate       int
}

type StatusHTMLInput struct {
	HTML string // the local file to write
	// Machines is the fleet's truth: the machines registry (internal/fleet), seven columns
	// and roles. The benches read over ssh are its rows carrying role `bench`, and the page
	// says which machines serve the merge group's shards, instead of leaving that to a
	// second file nobody updates.
	Machines string
	// Benches is the retired four-column fleet file: name, ssh target, home, mac. It reads
	// for one more release, and every run of it says on stderr what to pass instead.
	Benches  string
	Queue    string   // the queue whose depth, fill log and REPO the page reads
	SSH      string   // the ssh program; empty is "ssh"
	Publish  string   // host:dir to ship the page and the series to; empty ships nothing
	GhConfig string   // GH_CONFIG_DIR for the gh children; empty leaves the caller's own
	DayStart string   // when the merged counter resets, as HH:MMZ; empty is 02:00Z
	Branch   string   // the branch whose merge queue and tip the page shows; empty is dev
	Self     string   // the name of the host running the verb; empty omits the row
	Loops    []string // label=pattern pairs counted on the self host
	Timeout  time.Duration
	Reader   FleetReader
	SelfRead SelfReader
	Ship     Publisher
	Now      func() time.Time
	Stdout   io.Writer
	Stderr   io.Writer
}

type StatusInput struct {
	Queue          string // the queue directory: pending, launched, done, failed and the state files
	Roots          string // comma-separated bench roots, the benches in scope
	SlotsStores    string // comma-separated bench slot-lease stores to report utilisation for
	Batches        string // the directory holding the swarm's batch-*.out outputs; empty claims nothing
	Day            string // YYYY-MM-DD the day window starts at; empty means today (UTC)
	Max            int
	Timeout        time.Duration
	ExpandingHours int // the sustained window the EXPANDING verdict requires, in whole hours; <= 0 means 2
	Stdout         io.Writer
	Stderr         io.Writer
	Now            func() time.Time
}

type SweepInput struct {
	Repo     string
	Queue    string
	Source   PRSource
	Enqueuer Enqueuer
	Now      func() time.Time
	Stdout   io.Writer
	Stderr   io.Writer
}

type Sweeper interface {
	Sweep(tick int) (swept int, err error)
}

type TriageInput struct {
	Case     string
	Queue    string
	Out      string
	Ref      string
	Evidence string // a file of the RESULT lines and the refusal line; default <queue>/UNDECIDED/<case>.txt
	Stdout   io.Writer
	Stderr   io.Writer

	// Decide turns on the verb's typed decision: the bounded packet is put to the provider
	// as one verdict question behind Floor, and the answer is printed as one advisory line
	// beside the verb's own. A decision below the floor is a suggestion, never an
	// authorization: the packet is cut and written exactly as it was before the flag.
	Decide  bool
	Floor   float64
	Decider Decider
}

type Undecided struct {
	Case    string
	Ref     string
	Result  []string
	Refusal string
}

type Verdict struct {
	Case    string
	Verdict string
	Rule    string // the condition of the row that decided it, or NEW
}

type WatchInput struct {
	Queue  string        // the merge queue: entry rows, the MERGED line and removal rows
	Bus    string        // the nova-bus checkout whose addressed notes are watched
	Jobs   string        // the job roots: <root>/<slot>/jobs/<label>/RESULT.md
	Until  string        // the event that ends the watch: pr=<n> merged, note-from=<name>, job=<label> done
	Cap    time.Duration // the wall it never runs past
	Now    func() time.Time
	Sleep  func(time.Duration)
	Stdout io.Writer
	Stderr io.Writer
}

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

type WiringInput struct {
	Queue    string
	Roots    string
	Repo     string
	Branch   string
	Deadline time.Duration // the batch deadline; 0 is DefaultCardDeadline
	Timeout  time.Duration // the bound on every child; 0 is childTimeout
	Max      int
	TempGlob string // the swarm test leftovers reap collects; empty is reap's own default
	TempRoot string // the directory the temp glob must sit under; empty derives it from the glob's prefix
	Now      func() time.Time
	Config   func() Config // the tick's configuration, re-read by run.go each tick
	Log      io.Writer     // where each verb's one line goes; nil is <queue>/pulse.log

	Runs      RunSource
	PRs       PRSource
	Enqueuer  Enqueuer
	Procs     ProcessTable
	Runners   RunnerTable
	Restarter RunnerRestarter
	Work      WorkSource
}

type WorkSource interface {
	OpenPRs(repo string) ([]OpenPR, error)
	OpenIssues(repo string) ([]OpenIssue, error)
}