multica/server/pkg/db/generated/autopilot.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: autopilot.sql

package db

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const addAutopilotCollaborator = `-- name: AddAutopilotCollaborator :one
INSERT INTO autopilot_collaborator (autopilot_id, user_type, user_id, granted_by)
VALUES ($1, $2, $3, $4)
ON CONFLICT (autopilot_id, user_type, user_id)
    DO UPDATE SET granted_by = EXCLUDED.granted_by
RETURNING autopilot_id, user_type, user_id, granted_by, created_at
`

type AddAutopilotCollaboratorParams struct {
	AutopilotID pgtype.UUID `json:"autopilot_id"`
	UserType    string      `json:"user_type"`
	UserID      pgtype.UUID `json:"user_id"`
	GrantedBy   pgtype.UUID `json:"granted_by"`
}

// Re-granting an existing collaborator is a no-op that refreshes granted_by,
// so the call is idempotent from the API boundary.
func (q *Queries) AddAutopilotCollaborator(ctx context.Context, arg AddAutopilotCollaboratorParams) (AutopilotCollaborator, error) {
	row := q.db.QueryRow(ctx, addAutopilotCollaborator,
		arg.AutopilotID,
		arg.UserType,
		arg.UserID,
		arg.GrantedBy,
	)
	var i AutopilotCollaborator
	err := row.Scan(
		&i.AutopilotID,
		&i.UserType,
		&i.UserID,
		&i.GrantedBy,
		&i.CreatedAt,
	)
	return i, err
}

const addAutopilotSubscriber = `-- name: AddAutopilotSubscriber :exec
INSERT INTO autopilot_subscriber (autopilot_id, user_type, user_id)
VALUES ($1, $2, $3)
ON CONFLICT (autopilot_id, user_type, user_id) DO NOTHING
`

type AddAutopilotSubscriberParams struct {
	AutopilotID pgtype.UUID `json:"autopilot_id"`
	UserType    string      `json:"user_type"`
	UserID      pgtype.UUID `json:"user_id"`
}

func (q *Queries) AddAutopilotSubscriber(ctx context.Context, arg AddAutopilotSubscriberParams) error {
	_, err := q.db.Exec(ctx, addAutopilotSubscriber, arg.AutopilotID, arg.UserType, arg.UserID)
	return err
}

const advanceTriggerNextRun = `-- name: AdvanceTriggerNextRun :exec
UPDATE autopilot_trigger
SET next_run_at = $2,
    last_fired_at = now(),
    updated_at = now()
WHERE id = $1
`

type AdvanceTriggerNextRunParams struct {
	ID        pgtype.UUID        `json:"id"`
	NextRunAt pgtype.Timestamptz `json:"next_run_at"`
}

func (q *Queries) AdvanceTriggerNextRun(ctx context.Context, arg AdvanceTriggerNextRunParams) error {
	_, err := q.db.Exec(ctx, advanceTriggerNextRun, arg.ID, arg.NextRunAt)
	return err
}

const createAutopilot = `-- name: CreateAutopilot :one
INSERT INTO autopilot (
    workspace_id, title, description, assignee_type, assignee_id,
    status, execution_mode, issue_title_template, project_id,
    created_by_type, created_by_id
) VALUES (
    $1, $2, $9, $3, $4,
    $5, $6, $10, $11,
    $7, $8
) RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id
`

type CreateAutopilotParams struct {
	WorkspaceID        pgtype.UUID `json:"workspace_id"`
	Title              string      `json:"title"`
	AssigneeType       string      `json:"assignee_type"`
	AssigneeID         pgtype.UUID `json:"assignee_id"`
	Status             string      `json:"status"`
	ExecutionMode      string      `json:"execution_mode"`
	CreatedByType      string      `json:"created_by_type"`
	CreatedByID        pgtype.UUID `json:"created_by_id"`
	Description        pgtype.Text `json:"description"`
	IssueTitleTemplate pgtype.Text `json:"issue_title_template"`
	ProjectID          pgtype.UUID `json:"project_id"`
}

func (q *Queries) CreateAutopilot(ctx context.Context, arg CreateAutopilotParams) (Autopilot, error) {
	row := q.db.QueryRow(ctx, createAutopilot,
		arg.WorkspaceID,
		arg.Title,
		arg.AssigneeType,
		arg.AssigneeID,
		arg.Status,
		arg.ExecutionMode,
		arg.CreatedByType,
		arg.CreatedByID,
		arg.Description,
		arg.IssueTitleTemplate,
		arg.ProjectID,
	)
	var i Autopilot
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Title,
		&i.Description,
		&i.AssigneeID,
		&i.Status,
		&i.ExecutionMode,
		&i.IssueTitleTemplate,
		&i.CreatedByType,
		&i.CreatedByID,
		&i.LastRunAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.AssigneeType,
		&i.ProjectID,
	)
	return i, err
}

const createAutopilotRun = `-- name: CreateAutopilotRun :one

INSERT INTO autopilot_run (
    autopilot_id, trigger_id, source, status, trigger_payload, squad_id, planned_at
) VALUES (
    $1, $4, $2, $3, $5,
    $6, $7
) RETURNING id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at
`

type CreateAutopilotRunParams struct {
	AutopilotID    pgtype.UUID        `json:"autopilot_id"`
	Source         string             `json:"source"`
	Status         string             `json:"status"`
	TriggerID      pgtype.UUID        `json:"trigger_id"`
	TriggerPayload []byte             `json:"trigger_payload"`
	SquadID        pgtype.UUID        `json:"squad_id"`
	PlannedAt      pgtype.Timestamptz `json:"planned_at"`
}

// =====================
// Autopilot Run Management
// =====================
// squad_id is an attribution hook: set to the assignee squad when the
// parent autopilot has assignee_type='squad', NULL otherwise. The executing
// agent_id on agent_task_queue still records who actually ran the work
// (the squad leader); squad_id lets reports group by squad without a join.
//
// planned_at carries the canonical UTC fire time for scheduled triggers
// (source='schedule'); it stays NULL for manual / webhook / api sources
// which have no canonical occurrence. Combined with the partial unique
// index uq_autopilot_run_trigger_planned, this gives dispatch-layer
// idempotency: a stale-steal retry at the same plan_time cannot create
// a second run for the same (trigger_id, planned_at) pair (MUL-3551).
func (q *Queries) CreateAutopilotRun(ctx context.Context, arg CreateAutopilotRunParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, createAutopilotRun,
		arg.AutopilotID,
		arg.Source,
		arg.Status,
		arg.TriggerID,
		arg.TriggerPayload,
		arg.SquadID,
		arg.PlannedAt,
	)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const createAutopilotTask = `-- name: CreateAutopilotTask :one

INSERT INTO agent_task_queue (agent_id, runtime_id, issue_id, status, priority, autopilot_run_id, trigger_summary)
VALUES ($1, $2, NULL, 'queued', $3, $4, $5)
RETURNING id, agent_id, issue_id, status, priority, dispatched_at, started_at, completed_at, result, error, created_at, context, runtime_id, session_id, work_dir, trigger_comment_id, chat_session_id, autopilot_run_id, attempt, max_attempts, parent_task_id, failure_reason, trigger_summary, force_fresh_session, is_leader_task, wait_reason, initiator_user_id, handoff_note, prepare_lease_expires_at, squad_id, escalation_for_task_id, fire_at
`

type CreateAutopilotTaskParams struct {
	AgentID        pgtype.UUID `json:"agent_id"`
	RuntimeID      pgtype.UUID `json:"runtime_id"`
	Priority       int32       `json:"priority"`
	AutopilotRunID pgtype.UUID `json:"autopilot_run_id"`
	TriggerSummary pgtype.Text `json:"trigger_summary"`
}

// =====================
// Task Queue (run_only mode)
// =====================
func (q *Queries) CreateAutopilotTask(ctx context.Context, arg CreateAutopilotTaskParams) (AgentTaskQueue, error) {
	row := q.db.QueryRow(ctx, createAutopilotTask,
		arg.AgentID,
		arg.RuntimeID,
		arg.Priority,
		arg.AutopilotRunID,
		arg.TriggerSummary,
	)
	var i AgentTaskQueue
	err := row.Scan(
		&i.ID,
		&i.AgentID,
		&i.IssueID,
		&i.Status,
		&i.Priority,
		&i.DispatchedAt,
		&i.StartedAt,
		&i.CompletedAt,
		&i.Result,
		&i.Error,
		&i.CreatedAt,
		&i.Context,
		&i.RuntimeID,
		&i.SessionID,
		&i.WorkDir,
		&i.TriggerCommentID,
		&i.ChatSessionID,
		&i.AutopilotRunID,
		&i.Attempt,
		&i.MaxAttempts,
		&i.ParentTaskID,
		&i.FailureReason,
		&i.TriggerSummary,
		&i.ForceFreshSession,
		&i.IsLeaderTask,
		&i.WaitReason,
		&i.InitiatorUserID,
		&i.HandoffNote,
		&i.PrepareLeaseExpiresAt,
		&i.SquadID,
		&i.EscalationForTaskID,
		&i.FireAt,
	)
	return i, err
}

const createAutopilotTrigger = `-- name: CreateAutopilotTrigger :one
INSERT INTO autopilot_trigger (
    autopilot_id, kind, enabled, cron_expression, timezone,
    next_run_at, webhook_token, label, provider, event_filters
) VALUES (
    $1, $2, $3, $4, $5,
    $6, $7, $8,
    COALESCE($9::text, 'generic'),
    $10
) RETURNING id, autopilot_id, kind, enabled, cron_expression, timezone, next_run_at, webhook_token, label, last_fired_at, created_at, updated_at, provider, signing_secret, event_filters
`

type CreateAutopilotTriggerParams struct {
	AutopilotID    pgtype.UUID        `json:"autopilot_id"`
	Kind           string             `json:"kind"`
	Enabled        bool               `json:"enabled"`
	CronExpression pgtype.Text        `json:"cron_expression"`
	Timezone       pgtype.Text        `json:"timezone"`
	NextRunAt      pgtype.Timestamptz `json:"next_run_at"`
	WebhookToken   pgtype.Text        `json:"webhook_token"`
	Label          pgtype.Text        `json:"label"`
	Provider       pgtype.Text        `json:"provider"`
	EventFilters   []byte             `json:"event_filters"`
}

func (q *Queries) CreateAutopilotTrigger(ctx context.Context, arg CreateAutopilotTriggerParams) (AutopilotTrigger, error) {
	row := q.db.QueryRow(ctx, createAutopilotTrigger,
		arg.AutopilotID,
		arg.Kind,
		arg.Enabled,
		arg.CronExpression,
		arg.Timezone,
		arg.NextRunAt,
		arg.WebhookToken,
		arg.Label,
		arg.Provider,
		arg.EventFilters,
	)
	var i AutopilotTrigger
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.Kind,
		&i.Enabled,
		&i.CronExpression,
		&i.Timezone,
		&i.NextRunAt,
		&i.WebhookToken,
		&i.Label,
		&i.LastFiredAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Provider,
		&i.SigningSecret,
		&i.EventFilters,
	)
	return i, err
}

const deleteAutopilot = `-- name: DeleteAutopilot :exec
DELETE FROM autopilot WHERE id = $1
`

func (q *Queries) DeleteAutopilot(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteAutopilot, id)
	return err
}

const deleteAutopilotCollaborator = `-- name: DeleteAutopilotCollaborator :exec
DELETE FROM autopilot_collaborator
WHERE autopilot_id = $1 AND user_type = $2 AND user_id = $3
`

type DeleteAutopilotCollaboratorParams struct {
	AutopilotID pgtype.UUID `json:"autopilot_id"`
	UserType    string      `json:"user_type"`
	UserID      pgtype.UUID `json:"user_id"`
}

func (q *Queries) DeleteAutopilotCollaborator(ctx context.Context, arg DeleteAutopilotCollaboratorParams) error {
	_, err := q.db.Exec(ctx, deleteAutopilotCollaborator, arg.AutopilotID, arg.UserType, arg.UserID)
	return err
}

const deleteAutopilotCollaboratorsForAutopilot = `-- name: DeleteAutopilotCollaboratorsForAutopilot :exec
DELETE FROM autopilot_collaborator
WHERE autopilot_id = $1
`

// Application-layer cleanup run inside the autopilot delete transaction.
func (q *Queries) DeleteAutopilotCollaboratorsForAutopilot(ctx context.Context, autopilotID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteAutopilotCollaboratorsForAutopilot, autopilotID)
	return err
}

const deleteAutopilotSubscribersForAutopilot = `-- name: DeleteAutopilotSubscribersForAutopilot :exec
DELETE FROM autopilot_subscriber
WHERE autopilot_id = $1
`

// Paired with a re-insert loop to implement full-replace PATCH semantics.
func (q *Queries) DeleteAutopilotSubscribersForAutopilot(ctx context.Context, autopilotID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteAutopilotSubscribersForAutopilot, autopilotID)
	return err
}

const deleteAutopilotTrigger = `-- name: DeleteAutopilotTrigger :exec
DELETE FROM autopilot_trigger WHERE id = $1
`

func (q *Queries) DeleteAutopilotTrigger(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteAutopilotTrigger, id)
	return err
}

const failAutopilotRunsByIssue = `-- name: FailAutopilotRunsByIssue :exec
UPDATE autopilot_run
SET status = 'failed', completed_at = now(), failure_reason = 'linked issue was deleted'
WHERE issue_id = $1
  AND status IN ('issue_created', 'running')
`

// Fails active autopilot runs linked to a given issue.
// Must be called BEFORE issue deletion (ON DELETE SET NULL clears issue_id).
func (q *Queries) FailAutopilotRunsByIssue(ctx context.Context, issueID pgtype.UUID) error {
	_, err := q.db.Exec(ctx, failAutopilotRunsByIssue, issueID)
	return err
}

const getAutopilot = `-- name: GetAutopilot :one
SELECT id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id FROM autopilot
WHERE id = $1
`

func (q *Queries) GetAutopilot(ctx context.Context, id pgtype.UUID) (Autopilot, error) {
	row := q.db.QueryRow(ctx, getAutopilot, id)
	var i Autopilot
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Title,
		&i.Description,
		&i.AssigneeID,
		&i.Status,
		&i.ExecutionMode,
		&i.IssueTitleTemplate,
		&i.CreatedByType,
		&i.CreatedByID,
		&i.LastRunAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.AssigneeType,
		&i.ProjectID,
	)
	return i, err
}

const getAutopilotInWorkspace = `-- name: GetAutopilotInWorkspace :one
SELECT id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id FROM autopilot
WHERE id = $1 AND workspace_id = $2
`

type GetAutopilotInWorkspaceParams struct {
	ID          pgtype.UUID `json:"id"`
	WorkspaceID pgtype.UUID `json:"workspace_id"`
}

func (q *Queries) GetAutopilotInWorkspace(ctx context.Context, arg GetAutopilotInWorkspaceParams) (Autopilot, error) {
	row := q.db.QueryRow(ctx, getAutopilotInWorkspace, arg.ID, arg.WorkspaceID)
	var i Autopilot
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Title,
		&i.Description,
		&i.AssigneeID,
		&i.Status,
		&i.ExecutionMode,
		&i.IssueTitleTemplate,
		&i.CreatedByType,
		&i.CreatedByID,
		&i.LastRunAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.AssigneeType,
		&i.ProjectID,
	)
	return i, err
}

const getAutopilotRun = `-- name: GetAutopilotRun :one
SELECT id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at FROM autopilot_run
WHERE id = $1
`

func (q *Queries) GetAutopilotRun(ctx context.Context, id pgtype.UUID) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, getAutopilotRun, id)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const getAutopilotRunByIssue = `-- name: GetAutopilotRunByIssue :one

SELECT id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at FROM autopilot_run
WHERE issue_id = $1 AND status IN ('issue_created', 'running')
LIMIT 1
`

// =====================
// Run lookup by linked entities
// =====================
func (q *Queries) GetAutopilotRunByIssue(ctx context.Context, issueID pgtype.UUID) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, getAutopilotRunByIssue, issueID)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const getAutopilotRunByTriggerAndPlanned = `-- name: GetAutopilotRunByTriggerAndPlanned :one
SELECT id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at FROM autopilot_run
WHERE trigger_id = $1
  AND planned_at = $2
LIMIT 1
`

type GetAutopilotRunByTriggerAndPlannedParams struct {
	TriggerID pgtype.UUID        `json:"trigger_id"`
	PlannedAt pgtype.Timestamptz `json:"planned_at"`
}

// Idempotent lookup used by DispatchAutopilotForPlan to detect a
// crash-during-dispatch retry: if a row already exists for this
// (trigger_id, planned_at), the caller reuses it instead of creating a
// duplicate. The partial unique index covers the same key, so a race
// between "look up then insert" still resolves to a single row — this
// query is just the fast path that lets us skip the INSERT when we
// can see the prior row clearly. Returns no rows for the (much more
// common) first-time dispatch.
func (q *Queries) GetAutopilotRunByTriggerAndPlanned(ctx context.Context, arg GetAutopilotRunByTriggerAndPlannedParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, getAutopilotRunByTriggerAndPlanned, arg.TriggerID, arg.PlannedAt)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const getAutopilotTrigger = `-- name: GetAutopilotTrigger :one
SELECT id, autopilot_id, kind, enabled, cron_expression, timezone, next_run_at, webhook_token, label, last_fired_at, created_at, updated_at, provider, signing_secret, event_filters FROM autopilot_trigger
WHERE id = $1
`

func (q *Queries) GetAutopilotTrigger(ctx context.Context, id pgtype.UUID) (AutopilotTrigger, error) {
	row := q.db.QueryRow(ctx, getAutopilotTrigger, id)
	var i AutopilotTrigger
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.Kind,
		&i.Enabled,
		&i.CronExpression,
		&i.Timezone,
		&i.NextRunAt,
		&i.WebhookToken,
		&i.Label,
		&i.LastFiredAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Provider,
		&i.SigningSecret,
		&i.EventFilters,
	)
	return i, err
}

const getWebhookTriggerByToken = `-- name: GetWebhookTriggerByToken :one
SELECT t.id, t.autopilot_id, t.kind, t.enabled, t.cron_expression, t.timezone, t.next_run_at, t.webhook_token, t.label, t.last_fired_at, t.created_at, t.updated_at, t.provider, t.signing_secret, t.event_filters, a.workspace_id AS autopilot_workspace_id
FROM autopilot_trigger t
JOIN autopilot a ON a.id = t.autopilot_id
WHERE t.kind = 'webhook'
  AND t.webhook_token = $1
`

type GetWebhookTriggerByTokenRow struct {
	ID                   pgtype.UUID        `json:"id"`
	AutopilotID          pgtype.UUID        `json:"autopilot_id"`
	Kind                 string             `json:"kind"`
	Enabled              bool               `json:"enabled"`
	CronExpression       pgtype.Text        `json:"cron_expression"`
	Timezone             pgtype.Text        `json:"timezone"`
	NextRunAt            pgtype.Timestamptz `json:"next_run_at"`
	WebhookToken         pgtype.Text        `json:"webhook_token"`
	Label                pgtype.Text        `json:"label"`
	LastFiredAt          pgtype.Timestamptz `json:"last_fired_at"`
	CreatedAt            pgtype.Timestamptz `json:"created_at"`
	UpdatedAt            pgtype.Timestamptz `json:"updated_at"`
	Provider             string             `json:"provider"`
	SigningSecret        pgtype.Text        `json:"signing_secret"`
	EventFilters         []byte             `json:"event_filters"`
	AutopilotWorkspaceID pgtype.UUID        `json:"autopilot_workspace_id"`
}

// Look up a webhook trigger by its public bearer token. Joined to autopilot
// so the webhook handler can derive the workspace from the trigger's parent
// without trusting any request header. The handler still re-loads the
// Autopilot via GetAutopilot and cross-checks WorkspaceID matches the row's
// autopilot_workspace_id.
func (q *Queries) GetWebhookTriggerByToken(ctx context.Context, webhookToken pgtype.Text) (GetWebhookTriggerByTokenRow, error) {
	row := q.db.QueryRow(ctx, getWebhookTriggerByToken, webhookToken)
	var i GetWebhookTriggerByTokenRow
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.Kind,
		&i.Enabled,
		&i.CronExpression,
		&i.Timezone,
		&i.NextRunAt,
		&i.WebhookToken,
		&i.Label,
		&i.LastFiredAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Provider,
		&i.SigningSecret,
		&i.EventFilters,
		&i.AutopilotWorkspaceID,
	)
	return i, err
}

const isAutopilotCollaborator = `-- name: IsAutopilotCollaborator :one
SELECT EXISTS (
    SELECT 1 FROM autopilot_collaborator
    WHERE autopilot_id = $1 AND user_type = 'member' AND user_id = $2
) AS is_collaborator
`

type IsAutopilotCollaboratorParams struct {
	AutopilotID pgtype.UUID `json:"autopilot_id"`
	UserID      pgtype.UUID `json:"user_id"`
}

func (q *Queries) IsAutopilotCollaborator(ctx context.Context, arg IsAutopilotCollaboratorParams) (bool, error) {
	row := q.db.QueryRow(ctx, isAutopilotCollaborator, arg.AutopilotID, arg.UserID)
	var is_collaborator bool
	err := row.Scan(&is_collaborator)
	return is_collaborator, err
}

const listAutopilotCollaborators = `-- name: ListAutopilotCollaborators :many

SELECT autopilot_id, user_type, user_id, granted_by, created_at FROM autopilot_collaborator
WHERE autopilot_id = $1
ORDER BY created_at ASC, user_id ASC
`

// =====================
// Autopilot Collaborators
// =====================
// ORDER BY created_at keeps row rendering stable across refreshes.
func (q *Queries) ListAutopilotCollaborators(ctx context.Context, autopilotID pgtype.UUID) ([]AutopilotCollaborator, error) {
	rows, err := q.db.Query(ctx, listAutopilotCollaborators, autopilotID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []AutopilotCollaborator{}
	for rows.Next() {
		var i AutopilotCollaborator
		if err := rows.Scan(
			&i.AutopilotID,
			&i.UserType,
			&i.UserID,
			&i.GrantedBy,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listAutopilotIDsForCollaborator = `-- name: ListAutopilotIDsForCollaborator :many
SELECT autopilot_id FROM autopilot_collaborator
WHERE user_type = 'member' AND user_id = $1
`

// Powers the per-row can_write flag on the list endpoint without an N+1.
func (q *Queries) ListAutopilotIDsForCollaborator(ctx context.Context, userID pgtype.UUID) ([]pgtype.UUID, error) {
	rows, err := q.db.Query(ctx, listAutopilotIDsForCollaborator, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []pgtype.UUID{}
	for rows.Next() {
		var autopilot_id pgtype.UUID
		if err := rows.Scan(&autopilot_id); err != nil {
			return nil, err
		}
		items = append(items, autopilot_id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listAutopilotRuns = `-- name: ListAutopilotRuns :many
SELECT id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at FROM autopilot_run
WHERE autopilot_id = $1
ORDER BY created_at DESC
LIMIT $2 OFFSET $3
`

type ListAutopilotRunsParams struct {
	AutopilotID pgtype.UUID `json:"autopilot_id"`
	Limit       int32       `json:"limit"`
	Offset      int32       `json:"offset"`
}

func (q *Queries) ListAutopilotRuns(ctx context.Context, arg ListAutopilotRunsParams) ([]AutopilotRun, error) {
	rows, err := q.db.Query(ctx, listAutopilotRuns, arg.AutopilotID, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []AutopilotRun{}
	for rows.Next() {
		var i AutopilotRun
		if err := rows.Scan(
			&i.ID,
			&i.AutopilotID,
			&i.TriggerID,
			&i.Source,
			&i.Status,
			&i.IssueID,
			&i.TaskID,
			&i.TriggeredAt,
			&i.CompletedAt,
			&i.FailureReason,
			&i.TriggerPayload,
			&i.Result,
			&i.CreatedAt,
			&i.SquadID,
			&i.PlannedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listAutopilotSubscribers = `-- name: ListAutopilotSubscribers :many

SELECT autopilot_id, user_type, user_id, created_at FROM autopilot_subscriber
WHERE autopilot_id = $1
ORDER BY created_at ASC, user_id ASC
`

// =====================
// Autopilot Subscribers
// =====================
// ORDER BY created_at keeps chip rendering stable across refreshes.
func (q *Queries) ListAutopilotSubscribers(ctx context.Context, autopilotID pgtype.UUID) ([]AutopilotSubscriber, error) {
	rows, err := q.db.Query(ctx, listAutopilotSubscribers, autopilotID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []AutopilotSubscriber{}
	for rows.Next() {
		var i AutopilotSubscriber
		if err := rows.Scan(
			&i.AutopilotID,
			&i.UserType,
			&i.UserID,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listAutopilotTriggers = `-- name: ListAutopilotTriggers :many

SELECT id, autopilot_id, kind, enabled, cron_expression, timezone, next_run_at, webhook_token, label, last_fired_at, created_at, updated_at, provider, signing_secret, event_filters FROM autopilot_trigger
WHERE autopilot_id = $1
ORDER BY created_at ASC
`

// =====================
// Autopilot Trigger CRUD
// =====================
func (q *Queries) ListAutopilotTriggers(ctx context.Context, autopilotID pgtype.UUID) ([]AutopilotTrigger, error) {
	rows, err := q.db.Query(ctx, listAutopilotTriggers, autopilotID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []AutopilotTrigger{}
	for rows.Next() {
		var i AutopilotTrigger
		if err := rows.Scan(
			&i.ID,
			&i.AutopilotID,
			&i.Kind,
			&i.Enabled,
			&i.CronExpression,
			&i.Timezone,
			&i.NextRunAt,
			&i.WebhookToken,
			&i.Label,
			&i.LastFiredAt,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.Provider,
			&i.SigningSecret,
			&i.EventFilters,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listAutopilots = `-- name: ListAutopilots :many

SELECT
  a.id, a.workspace_id, a.title, a.description, a.assignee_id, a.status, a.execution_mode, a.issue_title_template, a.created_by_type, a.created_by_id, a.last_run_at, a.created_at, a.updated_at, a.assignee_type, a.project_id,
  (
    SELECT array_agg(DISTINCT t.kind ORDER BY t.kind)
    FROM autopilot_trigger t
    WHERE t.autopilot_id = a.id AND t.enabled
  )::text[] AS trigger_kinds,
  (
    SELECT min(t.next_run_at)
    FROM autopilot_trigger t
    WHERE t.autopilot_id = a.id AND t.enabled AND t.kind = 'schedule'
  )::timestamptz AS next_run_at,
  COALESCE((
    SELECT r.status
    FROM autopilot_run r
    WHERE r.autopilot_id = a.id
    ORDER BY r.triggered_at DESC
    LIMIT 1
  ), '')::text AS last_run_status
FROM autopilot a
WHERE a.workspace_id = $1
  AND ($2::text IS NULL OR a.status = $2)
ORDER BY a.created_at DESC
`

type ListAutopilotsParams struct {
	WorkspaceID pgtype.UUID `json:"workspace_id"`
	Status      pgtype.Text `json:"status"`
}

type ListAutopilotsRow struct {
	Autopilot     Autopilot          `json:"autopilot"`
	TriggerKinds  []string           `json:"trigger_kinds"`
	NextRunAt     pgtype.Timestamptz `json:"next_run_at"`
	LastRunStatus string             `json:"last_run_status"`
}

// =====================
// Autopilot CRUD
// =====================
// List rows carry three derived columns the list UI needs (trigger badges,
// next run, last-run outcome) so the page never has to N+1 into the detail
// endpoint. trigger_kinds/next_run_at only consider ENABLED triggers — the
// columns answer "how does this fire today", not "what is configured".
// last_run_status is COALESCEd to ” (never ran) because sqlc cannot infer
// nullability through a scalar subquery; the handler maps ” back to omitted.
func (q *Queries) ListAutopilots(ctx context.Context, arg ListAutopilotsParams) ([]ListAutopilotsRow, error) {
	rows, err := q.db.Query(ctx, listAutopilots, arg.WorkspaceID, arg.Status)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAutopilotsRow{}
	for rows.Next() {
		var i ListAutopilotsRow
		if err := rows.Scan(
			&i.Autopilot.ID,
			&i.Autopilot.WorkspaceID,
			&i.Autopilot.Title,
			&i.Autopilot.Description,
			&i.Autopilot.AssigneeID,
			&i.Autopilot.Status,
			&i.Autopilot.ExecutionMode,
			&i.Autopilot.IssueTitleTemplate,
			&i.Autopilot.CreatedByType,
			&i.Autopilot.CreatedByID,
			&i.Autopilot.LastRunAt,
			&i.Autopilot.CreatedAt,
			&i.Autopilot.UpdatedAt,
			&i.Autopilot.AssigneeType,
			&i.Autopilot.ProjectID,
			&i.TriggerKinds,
			&i.NextRunAt,
			&i.LastRunStatus,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listSchedulableAutopilotTriggers = `-- name: ListSchedulableAutopilotTriggers :many

SELECT t.id, t.autopilot_id, t.cron_expression, t.timezone, t.created_at, t.last_fired_at
FROM autopilot_trigger t
JOIN autopilot a ON a.id = t.autopilot_id
WHERE t.kind = 'schedule'
  AND t.enabled = TRUE
  AND a.status = 'active'
  AND t.cron_expression IS NOT NULL
  AND t.cron_expression <> ''
ORDER BY t.id
`

type ListSchedulableAutopilotTriggersRow struct {
	ID             pgtype.UUID        `json:"id"`
	AutopilotID    pgtype.UUID        `json:"autopilot_id"`
	CronExpression pgtype.Text        `json:"cron_expression"`
	Timezone       pgtype.Text        `json:"timezone"`
	CreatedAt      pgtype.Timestamptz `json:"created_at"`
	LastFiredAt    pgtype.Timestamptz `json:"last_fired_at"`
}

// =====================
// Scheduler Queries
// =====================
// Lists every schedule trigger the autopilot_schedule_dispatch JobSpec
// should consider this tick. Returns just the columns the scheduler's
// scope provider + PlansForScope hook need; the full trigger row is
// re-loaded by the handler so a trigger update between scope-list and
// handler-run sees the latest enabled / cron values.
//
// last_fired_at is read so the planner hook can anchor cold-start
// enumeration on the most recent successful fire (set by either the
// legacy goroutine before the new scheduler took over, or the new
// scheduler's own post-dispatch advance — AdvanceTriggerNextRun, falling
// back to TouchAutopilotTriggerFiredAt on a cron parse error). Without it,
// a trigger that was created days ago and fired by the legacy code
// looks like a brand-new trigger to the new scheduler on first tick
// and the half-open `(created_at, now]` enumeration replays the most
// recent already-fired occurrence — exactly the post-deploy
// spurious-fire reported on MUL-3551 dev.
//
// Filters out webhook / api triggers, disabled triggers, paused/archived
// autopilots, and any trigger missing its cron expression. ORDER BY id
// keeps the per-tick scope list stable across replicas.
func (q *Queries) ListSchedulableAutopilotTriggers(ctx context.Context) ([]ListSchedulableAutopilotTriggersRow, error) {
	rows, err := q.db.Query(ctx, listSchedulableAutopilotTriggers)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListSchedulableAutopilotTriggersRow{}
	for rows.Next() {
		var i ListSchedulableAutopilotTriggersRow
		if err := rows.Scan(
			&i.ID,
			&i.AutopilotID,
			&i.CronExpression,
			&i.Timezone,
			&i.CreatedAt,
			&i.LastFiredAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const recoverPartialAutopilotRun = `-- name: RecoverPartialAutopilotRun :exec
UPDATE autopilot_run
SET status = 'failed',
    completed_at = now(),
    failure_reason = 'recovered partial dispatch (crashed before downstream creation)',
    planned_at = NULL
WHERE id = $1
`

// Recovers a partial-state autopilot_run from a crashed first attempt
// (the runner wrote the run row but died before creating the downstream
// issue/task) so that a subsequent DispatchAutopilotForPlan call can
// create a fresh run at the same (trigger_id, planned_at).
//
// Setting planned_at = NULL clears the partial-unique slot held by
// uq_autopilot_run_trigger_planned, letting the new INSERT proceed.
// The row stays in autopilot_run as a FAILED record (with a recovery
// reason) so ops still see the abandoned attempt in the run history —
// it is not silently deleted.
func (q *Queries) RecoverPartialAutopilotRun(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, recoverPartialAutopilotRun, id)
	return err
}

const rotateAutopilotTriggerWebhookToken = `-- name: RotateAutopilotTriggerWebhookToken :one
UPDATE autopilot_trigger
SET webhook_token = $2,
    updated_at = now()
WHERE id = $1
  AND kind = 'webhook'
RETURNING id, autopilot_id, kind, enabled, cron_expression, timezone, next_run_at, webhook_token, label, last_fired_at, created_at, updated_at, provider, signing_secret, event_filters
`

type RotateAutopilotTriggerWebhookTokenParams struct {
	ID           pgtype.UUID `json:"id"`
	WebhookToken pgtype.Text `json:"webhook_token"`
}

// Rotates the bearer token for a webhook trigger. Restricted to kind='webhook'
// so an accidental call against a schedule/api trigger is a no-op (returns no
// rows) rather than corrupting unrelated state.
func (q *Queries) RotateAutopilotTriggerWebhookToken(ctx context.Context, arg RotateAutopilotTriggerWebhookTokenParams) (AutopilotTrigger, error) {
	row := q.db.QueryRow(ctx, rotateAutopilotTriggerWebhookToken, arg.ID, arg.WebhookToken)
	var i AutopilotTrigger
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.Kind,
		&i.Enabled,
		&i.CronExpression,
		&i.Timezone,
		&i.NextRunAt,
		&i.WebhookToken,
		&i.Label,
		&i.LastFiredAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Provider,
		&i.SigningSecret,
		&i.EventFilters,
	)
	return i, err
}

const selectAutopilotsExceedingFailureThreshold = `-- name: SelectAutopilotsExceedingFailureThreshold :many

WITH stats AS (
    SELECT autopilot_id,
           count(*) FILTER (WHERE status IN ('completed', 'failed')) AS total,
           count(*) FILTER (WHERE status = 'failed') AS failed
    FROM autopilot_run
    WHERE created_at >= $3::timestamptz
    GROUP BY autopilot_id
)
SELECT a.id, a.workspace_id, a.title, a.assignee_id,
       a.created_by_type, a.created_by_id,
       s.total::bigint  AS total_runs,
       s.failed::bigint AS failed_runs
FROM autopilot a
JOIN stats s ON s.autopilot_id = a.id
WHERE a.status = 'active'
  AND s.total >= $1::bigint
  AND s.failed::float8 / NULLIF(s.total, 0)::float8 >= $2::float8
ORDER BY s.failed DESC, a.id ASC
`

type SelectAutopilotsExceedingFailureThresholdParams struct {
	MinRuns            int64              `json:"min_runs"`
	FailRatioThreshold float64            `json:"fail_ratio_threshold"`
	Since              pgtype.Timestamptz `json:"since"`
}

type SelectAutopilotsExceedingFailureThresholdRow struct {
	ID            pgtype.UUID `json:"id"`
	WorkspaceID   pgtype.UUID `json:"workspace_id"`
	Title         string      `json:"title"`
	AssigneeID    pgtype.UUID `json:"assignee_id"`
	CreatedByType string      `json:"created_by_type"`
	CreatedByID   pgtype.UUID `json:"created_by_id"`
	TotalRuns     int64       `json:"total_runs"`
	FailedRuns    int64       `json:"failed_runs"`
}

// =====================
// Failure-rate auto-pause
// =====================
// Find active autopilots whose recent run failure rate exceeds the threshold.
// Counts only "real" terminal runs (completed | failed). 'skipped' is
// excluded from BOTH numerator and denominator: an admission-skipped run
// (e.g. assignee runtime offline at dispatch time, MUL-1899) is neither a
// success nor a failure, so it must not dilute the failure ratio (which
// would let a 100%-failing autopilot mask itself behind a wall of skips)
// nor inflate it. issue_created/running are still excluded so in-flight
// work isn't penalised.
// Used by the failure monitor to auto-pause sustained-failure autopilots
// (the canonical example from MUL-1336 was an autopilot scheduled every 5 min
// that 100% failed for days, burning ~1.5k useless tasks per week).
func (q *Queries) SelectAutopilotsExceedingFailureThreshold(ctx context.Context, arg SelectAutopilotsExceedingFailureThresholdParams) ([]SelectAutopilotsExceedingFailureThresholdRow, error) {
	rows, err := q.db.Query(ctx, selectAutopilotsExceedingFailureThreshold, arg.MinRuns, arg.FailRatioThreshold, arg.Since)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []SelectAutopilotsExceedingFailureThresholdRow{}
	for rows.Next() {
		var i SelectAutopilotsExceedingFailureThresholdRow
		if err := rows.Scan(
			&i.ID,
			&i.WorkspaceID,
			&i.Title,
			&i.AssigneeID,
			&i.CreatedByType,
			&i.CreatedByID,
			&i.TotalRuns,
			&i.FailedRuns,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const setAutopilotTriggerSigningSecret = `-- name: SetAutopilotTriggerSigningSecret :one
UPDATE autopilot_trigger
SET signing_secret = $2,
    updated_at = now()
WHERE id = $1
  AND kind = 'webhook'
RETURNING id, autopilot_id, kind, enabled, cron_expression, timezone, next_run_at, webhook_token, label, last_fired_at, created_at, updated_at, provider, signing_secret, event_filters
`

type SetAutopilotTriggerSigningSecretParams struct {
	ID            pgtype.UUID `json:"id"`
	SigningSecret pgtype.Text `json:"signing_secret"`
}

// Writes the signing secret for a webhook trigger. Kept as a dedicated query
// (not a field on UpdateAutopilotTrigger) so the request body for the
// write-only endpoint only ever carries the secret value, with no risk of an
// accidental log line leaking it alongside other fields. Restricted to
// webhook triggers to avoid corrupting unrelated state.
func (q *Queries) SetAutopilotTriggerSigningSecret(ctx context.Context, arg SetAutopilotTriggerSigningSecretParams) (AutopilotTrigger, error) {
	row := q.db.QueryRow(ctx, setAutopilotTriggerSigningSecret, arg.ID, arg.SigningSecret)
	var i AutopilotTrigger
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.Kind,
		&i.Enabled,
		&i.CronExpression,
		&i.Timezone,
		&i.NextRunAt,
		&i.WebhookToken,
		&i.Label,
		&i.LastFiredAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Provider,
		&i.SigningSecret,
		&i.EventFilters,
	)
	return i, err
}

const setAutopilotTriggerWebhookToken = `-- name: SetAutopilotTriggerWebhookToken :one
UPDATE autopilot_trigger
SET webhook_token = $2,
    updated_at = now()
WHERE id = $1
RETURNING id, autopilot_id, kind, enabled, cron_expression, timezone, next_run_at, webhook_token, label, last_fired_at, created_at, updated_at, provider, signing_secret, event_filters
`

type SetAutopilotTriggerWebhookTokenParams struct {
	ID           pgtype.UUID `json:"id"`
	WebhookToken pgtype.Text `json:"webhook_token"`
}

// Sets the webhook token at creation time. CreateAutopilotTrigger inserts the
// row first (using its full 8-arg signature), then this query attaches the
// token. Splitting the create + token-set keeps the existing CreateAutopilotTrigger
// query usable by the schedule path without forcing every caller to think
// about webhook_token.
func (q *Queries) SetAutopilotTriggerWebhookToken(ctx context.Context, arg SetAutopilotTriggerWebhookTokenParams) (AutopilotTrigger, error) {
	row := q.db.QueryRow(ctx, setAutopilotTriggerWebhookToken, arg.ID, arg.WebhookToken)
	var i AutopilotTrigger
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.Kind,
		&i.Enabled,
		&i.CronExpression,
		&i.Timezone,
		&i.NextRunAt,
		&i.WebhookToken,
		&i.Label,
		&i.LastFiredAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Provider,
		&i.SigningSecret,
		&i.EventFilters,
	)
	return i, err
}

const systemPauseAutopilot = `-- name: SystemPauseAutopilot :one
UPDATE autopilot
SET status = 'paused', updated_at = now()
WHERE id = $1 AND status = 'active'
RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id
`

// Atomically pauses an autopilot only if it is currently active. Returns no
// rows when the autopilot was already paused/archived (or another worker
// raced first), letting the caller treat that as a benign no-op rather than
// an error.
func (q *Queries) SystemPauseAutopilot(ctx context.Context, id pgtype.UUID) (Autopilot, error) {
	row := q.db.QueryRow(ctx, systemPauseAutopilot, id)
	var i Autopilot
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Title,
		&i.Description,
		&i.AssigneeID,
		&i.Status,
		&i.ExecutionMode,
		&i.IssueTitleTemplate,
		&i.CreatedByType,
		&i.CreatedByID,
		&i.LastRunAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.AssigneeType,
		&i.ProjectID,
	)
	return i, err
}

const touchAutopilotTriggerFiredAt = `-- name: TouchAutopilotTriggerFiredAt :exec
UPDATE autopilot_trigger
SET last_fired_at = now(),
    updated_at = now()
WHERE id = $1
`

// Bumps last_fired_at after a webhook fires, regardless of whether the
// dispatch succeeded, was admission-skipped, or even if Autopilot status
// transitioned to paused/disabled at exactly the wrong moment. Disabled /
// paused early-return paths in the handler never call this.
func (q *Queries) TouchAutopilotTriggerFiredAt(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, touchAutopilotTriggerFiredAt, id)
	return err
}

const updateAutopilot = `-- name: UpdateAutopilot :one
UPDATE autopilot SET
    title = COALESCE($2, title),
    description = COALESCE($3, description),
    assignee_type = COALESCE($4, assignee_type),
    assignee_id = COALESCE($5::uuid, assignee_id),
    status = COALESCE($6, status),
    execution_mode = COALESCE($7, execution_mode),
    issue_title_template = $8,
    project_id = $9,
    updated_at = now()
WHERE id = $1
RETURNING id, workspace_id, title, description, assignee_id, status, execution_mode, issue_title_template, created_by_type, created_by_id, last_run_at, created_at, updated_at, assignee_type, project_id
`

type UpdateAutopilotParams struct {
	ID                 pgtype.UUID `json:"id"`
	Title              pgtype.Text `json:"title"`
	Description        pgtype.Text `json:"description"`
	AssigneeType       pgtype.Text `json:"assignee_type"`
	AssigneeID         pgtype.UUID `json:"assignee_id"`
	Status             pgtype.Text `json:"status"`
	ExecutionMode      pgtype.Text `json:"execution_mode"`
	IssueTitleTemplate pgtype.Text `json:"issue_title_template"`
	ProjectID          pgtype.UUID `json:"project_id"`
}

func (q *Queries) UpdateAutopilot(ctx context.Context, arg UpdateAutopilotParams) (Autopilot, error) {
	row := q.db.QueryRow(ctx, updateAutopilot,
		arg.ID,
		arg.Title,
		arg.Description,
		arg.AssigneeType,
		arg.AssigneeID,
		arg.Status,
		arg.ExecutionMode,
		arg.IssueTitleTemplate,
		arg.ProjectID,
	)
	var i Autopilot
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Title,
		&i.Description,
		&i.AssigneeID,
		&i.Status,
		&i.ExecutionMode,
		&i.IssueTitleTemplate,
		&i.CreatedByType,
		&i.CreatedByID,
		&i.LastRunAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.AssigneeType,
		&i.ProjectID,
	)
	return i, err
}

const updateAutopilotLastRunAt = `-- name: UpdateAutopilotLastRunAt :exec
UPDATE autopilot SET last_run_at = now(), updated_at = now()
WHERE id = $1
`

func (q *Queries) UpdateAutopilotLastRunAt(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, updateAutopilotLastRunAt, id)
	return err
}

const updateAutopilotRunCompleted = `-- name: UpdateAutopilotRunCompleted :one
UPDATE autopilot_run
SET status = 'completed', completed_at = now(), result = $2
WHERE id = $1
RETURNING id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at
`

type UpdateAutopilotRunCompletedParams struct {
	ID     pgtype.UUID `json:"id"`
	Result []byte      `json:"result"`
}

func (q *Queries) UpdateAutopilotRunCompleted(ctx context.Context, arg UpdateAutopilotRunCompletedParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, updateAutopilotRunCompleted, arg.ID, arg.Result)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const updateAutopilotRunFailed = `-- name: UpdateAutopilotRunFailed :one
UPDATE autopilot_run
SET status = 'failed', completed_at = now(), failure_reason = $2
WHERE id = $1
RETURNING id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at
`

type UpdateAutopilotRunFailedParams struct {
	ID            pgtype.UUID `json:"id"`
	FailureReason pgtype.Text `json:"failure_reason"`
}

func (q *Queries) UpdateAutopilotRunFailed(ctx context.Context, arg UpdateAutopilotRunFailedParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, updateAutopilotRunFailed, arg.ID, arg.FailureReason)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const updateAutopilotRunIssueCreated = `-- name: UpdateAutopilotRunIssueCreated :one
UPDATE autopilot_run
SET status = 'issue_created', issue_id = $2
WHERE id = $1
RETURNING id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at
`

type UpdateAutopilotRunIssueCreatedParams struct {
	ID      pgtype.UUID `json:"id"`
	IssueID pgtype.UUID `json:"issue_id"`
}

func (q *Queries) UpdateAutopilotRunIssueCreated(ctx context.Context, arg UpdateAutopilotRunIssueCreatedParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, updateAutopilotRunIssueCreated, arg.ID, arg.IssueID)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const updateAutopilotRunRunning = `-- name: UpdateAutopilotRunRunning :one
UPDATE autopilot_run
SET status = 'running', task_id = $2
WHERE id = $1
RETURNING id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at
`

type UpdateAutopilotRunRunningParams struct {
	ID     pgtype.UUID `json:"id"`
	TaskID pgtype.UUID `json:"task_id"`
}

func (q *Queries) UpdateAutopilotRunRunning(ctx context.Context, arg UpdateAutopilotRunRunningParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, updateAutopilotRunRunning, arg.ID, arg.TaskID)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const updateAutopilotRunSkipped = `-- name: UpdateAutopilotRunSkipped :one
UPDATE autopilot_run
SET status = 'skipped', completed_at = now(), failure_reason = $2
WHERE id = $1
RETURNING id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at
`

type UpdateAutopilotRunSkippedParams struct {
	ID            pgtype.UUID `json:"id"`
	FailureReason pgtype.Text `json:"failure_reason"`
}

// Marks an autopilot_run as skipped without enqueueing any task. Used by the
// pre-flight admission check when the assignee agent's runtime is offline:
// creating an issue / task in that state would just pile a doomed job onto
// agent_task_queue (the canonical "持续给离线 local agent 入队" symptom from
// MUL-1899). Recording the skip + reason gives the UI / failure monitor / ops
// a paper trail without polluting the failure ratio.
func (q *Queries) UpdateAutopilotRunSkipped(ctx context.Context, arg UpdateAutopilotRunSkippedParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, updateAutopilotRunSkipped, arg.ID, arg.FailureReason)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const updateAutopilotRunSkippedWithResult = `-- name: UpdateAutopilotRunSkippedWithResult :one
UPDATE autopilot_run
SET status = 'skipped',
    completed_at = now(),
    failure_reason = $2,
    result = $3
WHERE id = $1
RETURNING id, autopilot_id, trigger_id, source, status, issue_id, task_id, triggered_at, completed_at, failure_reason, trigger_payload, result, created_at, squad_id, planned_at
`

type UpdateAutopilotRunSkippedWithResultParams struct {
	ID            pgtype.UUID `json:"id"`
	FailureReason pgtype.Text `json:"failure_reason"`
	Result        []byte      `json:"result"`
}

func (q *Queries) UpdateAutopilotRunSkippedWithResult(ctx context.Context, arg UpdateAutopilotRunSkippedWithResultParams) (AutopilotRun, error) {
	row := q.db.QueryRow(ctx, updateAutopilotRunSkippedWithResult, arg.ID, arg.FailureReason, arg.Result)
	var i AutopilotRun
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.TriggerID,
		&i.Source,
		&i.Status,
		&i.IssueID,
		&i.TaskID,
		&i.TriggeredAt,
		&i.CompletedAt,
		&i.FailureReason,
		&i.TriggerPayload,
		&i.Result,
		&i.CreatedAt,
		&i.SquadID,
		&i.PlannedAt,
	)
	return i, err
}

const updateAutopilotTrigger = `-- name: UpdateAutopilotTrigger :one
UPDATE autopilot_trigger SET
    enabled = COALESCE($2::boolean, enabled),
    cron_expression = COALESCE($3, cron_expression),
    timezone = COALESCE($4, timezone),
    next_run_at = $5,
    label = COALESCE($6, label),
    event_filters = COALESCE($7, event_filters),
    updated_at = now()
WHERE id = $1
RETURNING id, autopilot_id, kind, enabled, cron_expression, timezone, next_run_at, webhook_token, label, last_fired_at, created_at, updated_at, provider, signing_secret, event_filters
`

type UpdateAutopilotTriggerParams struct {
	ID             pgtype.UUID        `json:"id"`
	Enabled        pgtype.Bool        `json:"enabled"`
	CronExpression pgtype.Text        `json:"cron_expression"`
	Timezone       pgtype.Text        `json:"timezone"`
	NextRunAt      pgtype.Timestamptz `json:"next_run_at"`
	Label          pgtype.Text        `json:"label"`
	EventFilters   []byte             `json:"event_filters"`
}

func (q *Queries) UpdateAutopilotTrigger(ctx context.Context, arg UpdateAutopilotTriggerParams) (AutopilotTrigger, error) {
	row := q.db.QueryRow(ctx, updateAutopilotTrigger,
		arg.ID,
		arg.Enabled,
		arg.CronExpression,
		arg.Timezone,
		arg.NextRunAt,
		arg.Label,
		arg.EventFilters,
	)
	var i AutopilotTrigger
	err := row.Scan(
		&i.ID,
		&i.AutopilotID,
		&i.Kind,
		&i.Enabled,
		&i.CronExpression,
		&i.Timezone,
		&i.NextRunAt,
		&i.WebhookToken,
		&i.Label,
		&i.LastFiredAt,
		&i.CreatedAt,
		&i.UpdatedAt,
		&i.Provider,
		&i.SigningSecret,
		&i.EventFilters,
	)
	return i, err
}