effects

type Class int

type Config struct {
	// Predicate classifies tools; required.
	Predicate Predicate

	// SubAgentNames is the set of agent names composed under the
	// runner's root (see SubAgentNames). ADK's coordinator emits task
	// delegations as FunctionCalls NAMED AFTER THE SUB-AGENT, and
	// deliberately leaves them unresolved across user turns (a
	// specialist asking a clarifying question, a HITL pause inside a
	// node) — engine control flow, not effects. Without this exclusion
	// the scan wedges mast's default composition on its happy path.
	SubAgentNames map[string]bool

	// AckedAt returns the operator's effects-acknowledgement watermark
	// for a session, if one exists (pkg/transcript reads it from the
	// companion ops row). Dangling intents at or before the watermark
	// are considered operator-acknowledged and do not trip
	// ambiguous-effect mode. Optional; nil means no acks.
	AckedAt func(ctx context.Context, sessionID string) (time.Time, bool)

	// Logger for refusals, replays, and mode transitions. Optional.
	Logger *slog.Logger
}

type DanglingIntent struct {
	ToolName     string
	CallID       string
	InvocationID string
	Timestamp    time.Time
	// EventIndex is the 0-based position of the carrying event among log
	// events with non-nil Content, in log order. It lets a consumer group
	// dangling calls by the event that raised them — the auto-resume
	// repair path (cmd/mast, #41) answers only the calls of a single
	// (the last) function-call event, ADK's single-call-event validation
	// constraint. The outbox itself ignores it.
	EventIndex int
}

type DanglingScan struct {
	// Mutating are unpaired mutating- or spawning-class calls: their
	// effect may or may not have committed, so a session with ANY of them
	// is ineligible for auto-resume and is left for an operator ack
	// (regardless of the effects ack watermark — an ack suppresses the
	// outbox refusal but does not pair the call, and synthesizing a
	// response would falsely assert the effect did not happen).
	Mutating []DanglingIntent
	// Repairable are unpaired ordinary read-only calls (a read-only tool
	// cut off mid-execution). They carry no external effect, so the
	// daemon may answer them with a synthetic error FunctionResponse to
	// make the history provider-valid before re-running.
	Repairable []DanglingIntent
	// Deferred are unpaired excluded calls (sub-agent task delegations,
	// and defensively any control/long-running call): engine-reconstruct
	// or operator territory. The daemon must not synthesize responses for
	// these; a candidate carrying any is skipped in slice-1.
	Deferred []DanglingIntent
	// LastCallEventIndex is the EventIndex of the last event carrying any
	// FunctionCall (paired or not), or -1 if none. Repair is only clean
	// when every Repairable call sits in this event (ADK validates a
	// repair message against the latest function-call event).
	LastCallEventIndex int
}

type Predicate func(toolName string) Class

type ToolPolicy struct {
	Name     string
	Mutating *bool
}