delivery

type AckResult string

type Batch struct {
	// ID is S1's signed proof. It is sent back to ack or hold and nowhere
	// else: never logged, stored or put in argv.
	ID string
	// BatchKey is S1's stable hash over the ranges: the same messages, the
	// same key, across re-issued proofs. A lookup key, never evidence.
	BatchKey string
	WorkerID string
	Ranges   []Range
	Text     string
	// DeliverAfter has passed for every batch S1 returns; it is checked
	// anyway. BusyDeadline is DeliverAfter plus S9's busy-delay cap: a
	// working agent defers a batch until then and no later.
	DeliverAfter   time.Time
	BusyDeadline   time.Time
	ProofExpiresAt time.Time
	// Interrupt is set only for a halt (S6, phase 4): always false now.
	Interrupt bool
}

type Capabilities struct {
	// EnterOnly: an Enter-only send submits what the composer holds.
	EnterOnly map[string]bool
	// Clear: ClearKeys empties the family's composer.
	Clear map[string]bool
}

type Cover struct {
	// Full: every message of the batch was confirmed delivered. Ack it whole,
	// with no typing.
	Full bool
	// Through: the channels with a confirmed covered prefix, when not Full.
	// Channels left out are not covered and move nothing.
	Through []Through
	// Matched are the records that proved it.
	Matched []Record
}

type Deliverer struct {
	Server  Server
	Orca    Terminals
	Records *Records
	// LockDir holds the per-worker locks shared with C2.
	LockDir string
	Caps    Capabilities
	// Bound is the worker a worktree's session binding names, or "".
	Bound  func(worktree string) string
	Now    func() time.Time
	Budget time.Duration
	Emit   func(Event)

	// Wakes acknowledges wake proofs; nil leaves wakes unacknowledged.
	Wakes       WakeServer
	WakeRecords *WakeRecords
	// AckMixed is set only once A′ (hadron-server#2072) is verified
	// deployed: a wake carrying a MENTION, or naming channels, may then be
	// acknowledged once all its TICK and TASK reasons are typed. Off, C1
	// acknowledges only a proof with no MENTION reason and no channels.
	AckMixed bool
	// contains filtered or unexported fields
}

type Event struct {
	Time     time.Time
	Worker   string
	WorkerID string
	Span     string
	Kind     Kind
	Reason   string
	Terminal string
	// ResolvedBy says where the recipient terminal's agent family came
	// from: "identity" (Orca's agent identity) or "screen" (Orca reported
	// none, and the screen showed one). Empty before a terminal is found. A
	// diagnostic code only (cli#906): it grants nothing.
	ResolvedBy string
	// Wake: the event is a tick or task wake's (cli#906 row 1), not a
	// batch's. Span is then reason counts.
	Wake bool
	// Unreported: a hold the server was not told about (cli#940).
	Unreported bool
}

type Kind string

type Outcome struct {
	Kind     Kind
	Reason   string
	Terminal string
	// AckPending: delivered and recorded, but the ack did not land; the
	// record reconciles it next time without typing.
	AckPending bool
	// Unreported: Held, but the server was not told (ErrHoldUnavailable).
	// No server hold, episode, alarm or escalation exists for it.
	Unreported bool
}

type Range struct {
	ChannelID   string `json:"channelId"`
	Incarnation int    `json:"incarnation"`
	FromSeq     int    `json:"fromSeq"`
	ThroughSeq  int    `json:"throughSeq"`
	Seqs        []int  `json:"seqs"`
}

type Recipient struct {
	WorkerID string
	Name     string
	// TUI is the agent interface its terminal must show ("claude" or
	// "codex"), when the host knows it. Empty means the screen's own family
	// and Orca's agent identity must agree instead.
	TUI string
	// Worktrees are its registered worktrees, absolute.
	Worktrees []string
	// contains filtered or unexported fields
}

type Record struct {
	State       string    `json:"state"`
	WorkerID    string    `json:"workerId"`
	BatchKey    string    `json:"batchKey,omitempty"`
	Ranges      []Range   `json:"ranges"`
	ConfirmedAt time.Time `json:"confirmedAt"`
}

type Records struct {
	Dir string
}

type Server interface {
	Ack(ctx context.Context, batchID string, through []Through) (AckResult, error)
	Hold(ctx context.Context, batchID, reason, terminalID string) error
}

type Status struct {
	Version    int                     `json:"version"`
	LastStepAt time.Time               `json:"lastStepAt"`
	LastRead   string                  `json:"lastRead"`
	Workers    map[string]WorkerStatus `json:"workers"`
	// The newest wake read (cli#906 row 1): its code, and dueWakes' counts.
	WakeRead          string     `json:"wakeRead,omitempty"`
	BudgetExhaustedAt *time.Time `json:"budgetExhaustedAt,omitempty"`
	Dormant           int        `json:"dormant"`
	Withheld          int        `json:"withheld"`
}

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

type TaskReason struct {
	EventID    string
	ChainIndex int
	// Event is the line's wording: "assigned", "child finished", "alarm" or
	// "end session".
	Event string
	// ID and Title are the task's. A task-less alarm (S5 #2021
	// comment-6259060238: taskId null) has neither, and none is invented.
	ID    string
	Title string
	// AlarmType is a task-less alarm's closed type code from the server
	// (e.g. delivery.stuck), shown as given.
	AlarmType string
}

type Terminals interface {
	List(ctx context.Context) ([]orcaterm.Terminal, error)
	ReadScreen(ctx context.Context, handle string) *orcaterm.Screen
	Send(ctx context.Context, handle, text string, o orcaterm.SendOptions) orcaterm.Receipt
}

type Through struct {
	ChannelID string `json:"channelId"`
	Seq       int    `json:"seq"`
}

type Wake struct {
	// Proof is the signed proof handed back to acknowledgeWakes. Never
	// logged, stored or put in argv.
	Proof    string
	WorkerID string
	Reasons  []WakeReason
	// NamesChannels: the proof carries channel ranges (DueWake.channels is
	// non-empty). Before A′ is deployed, acknowledging such a proof could
	// mark unseen text delivered, so C1 never does.
	NamesChannels bool
	// DeliverAfter and BusyDeadline are S1 slice (c)'s timing (R63): the
	// busy deadline counts from the oldest waiting reason's due time. A zero
	// one means the server did not say, and C1 invents none: no
	// DeliverAfter holds the wake as timing-unavailable even for an idle
	// agent, and no BusyDeadline holds it so for a busy or unproven one.
	DeliverAfter time.Time
	BusyDeadline time.Time
}

type WakeKind string

type WakeRead struct {
	At       time.Time
	Read     string
	Dormant  int
	Withheld int
}

type WakeReason struct {
	Kind       WakeKind
	TickerID   string
	TickerName string
	// LastTickAt names the tick (k) a TICK reason is for: it changes per
	// tick, so with the ticker it is the reason's stable identity.
	LastTickAt time.Time
	Task       *TaskReason
}

type WakeRecord struct {
	State    string    `json:"state"`
	WorkerID string    `json:"workerId"`
	Key      string    `json:"key"`
	TickerID string    `json:"tickerId,omitempty"`
	TickAt   time.Time `json:"tickAt,omitzero"`
	At       time.Time `json:"at"`
}

type WakeRecords struct {
	Dir string
}

type WakeServer interface {
	AckWake(ctx context.Context, proof string) (AckResult, error)
}

type WorkerStatus struct {
	Name       string    `json:"name"`
	Kind       Kind      `json:"kind"`
	Reason     string    `json:"reason,omitempty"`
	At         time.Time `json:"at"`
	ResolvedBy string    `json:"resolvedBy,omitempty"`
	// Wake: the event was a tick or task wake's, not a batch's.
	Wake bool `json:"wake,omitempty"`
	// Unreported: the newest event was a hold the server was not told about.
	Unreported bool `json:"unreported,omitempty"`
}