event

const (
	TypeJobCreated             Type = "job_created"
	TypeJobDeleted             Type = "job_deleted"
	TypeRunStarted             Type = "run_started"
	TypeRunCompleted           Type = "run_completed"
	TypeRunFailed              Type = "run_failed"
	TypeRunCancelled           Type = "run_cancelled"
	TypeRunTerminal            Type = "run_terminal"
	TypeTaskStarted            Type = "task_started"
	TypeTaskSucceeded          Type = "task_succeeded"
	TypeTaskFailed             Type = "task_failed"
	TypeTaskSkipped            Type = "task_skipped"
	TypeTaskRetrying           Type = "task_retrying"
	TypeTaskReady              Type = "task_ready"
	TypeTaskCached             Type = "task_cached"
	TypeTaskClaimed            Type = "task_claimed"
	TypeTaskLeaseExpired       Type = "task_lease_expired"
	TypeLogChunk               Type = "log_chunk"
	TypeJobPaused              Type = "job_paused"
	TypeJobUnpaused            Type = "job_unpaused"
	TypeBackfillStarted        Type = "backfill_started"
	TypeBackfillComplete       Type = "backfill_completed"
	TypeBackfillFailed         Type = "backfill_failed"
	TypeBackfillCancelled      Type = "backfill_cancelled"
	TypeRunRetried             Type = "run_retried"
	TypeRunTimedOut            Type = "run_timed_out"
	TypeSLAMissed              Type = "sla_missed"
	TypeFreshnessViolated      Type = "freshness_violated"
	TypeDatasetFreshnessAtRisk Type = "dataset_freshness_at_risk"
	// TypeDatasetAdvanced fires after a dataset's watermark is advanced or
	// verify-refreshed — by the run-completion capturer or the arrival observer —
	// carrying {namespace, name} in its payload. The freshness evaluator
	// subscribes to it to reactively re-derive downstream consumers off
	// POST-advance state. Reacting to run_completed instead would race the
	// capturer's own Advance (the bus fans out to subscribers unordered), so the
	// evaluator could read pre-advance state and derive a redundant producer run.
	TypeDatasetAdvanced Type = "dataset_advanced"
	// TypeSchemaViolationRecorded is emitted when a task's output violates its
	// declared schema in "warn" mode — the task does NOT fail, so the incident
	// manager would otherwise never see the violation. In "fail" mode the task
	// failure already carries the violations, so no separate event is emitted.
	TypeSchemaViolationRecorded Type = "schema_violation_recorded"
	// TypeContractBreakDeclared is emitted when an operator intentionally
	// acknowledges a breaking cross-job data contract for a bounded
	// deprecation window.
	TypeContractBreakDeclared Type = "contract_break_declared"

	// Incident lifecycle events (agent-in-the-loop D2). Emitted on the existing
	// /events stream so the Console incidents surface (Stream U) can live-update
	// the feed, timeline, and approval inbox without polling.
	TypeIncidentOpened        Type = "incident_opened"
	TypeIncidentStatusChanged Type = "incident_status_changed"
	TypeAgentActionRecorded   Type = "agent_action_recorded"
	TypeApprovalRequested     Type = "approval_requested"
	// TypeAgentActionExecuted is emitted when an approved tier-3 action actually
	// RUNS (trust-the-substrate C8). It is deliberately distinct from
	// TypeAgentActionRecorded, which the approvals controller emits at DECISION
	// time and which therefore says nothing about whether the action executed or
	// what it did. This one carries the decider, the action type/tier, and the
	// result summary, so "approved by X at T, executed at T'" is reconstructable
	// from the event stream alone.
	TypeAgentActionExecuted Type = "agent_action_executed"
	// TypeIncidentEscalated is emitted when a remediation ESCALATES — an agent or
	// a deterministic rule handed the incident to a human, either directly
	// (the `escalate` action) or because an approved change could not be applied
	// where it was approved (a git-synced job's jobdef patch, which degrades to an
	// escalation carrying the rendered diff).
	//
	// It exists because escalation must be DELIVERED, not merely recorded. An
	// escalation that only writes an AgentAction row and a log line contacts
	// nobody, which is the one outcome an escalation cannot have. Routing it as an
	// event puts it through the ordinary NotificationPolicy → channel machinery,
	// so a team pages or Slacks on it with no new plumbing, and it stays queryable
	// from /v1/events afterwards. The payload carries the incident, the requested
	// channel, and the rendered summary/diff.
	TypeIncidentEscalated Type = "incident_escalated"
)