proposal

type Draft struct {
	WorkspaceID string `` /* 127-byte string literal not displayed */
	Title       string `` /* 128-byte string literal not displayed */
	Description string `` /* 162-byte string literal not displayed */
	// CustomFieldValues is keyed by the workspace's field ids. A required field the
	// agent could not determine is left out on purpose — the review UI blocks
	// submit until the human fills it, which is better than a fabricated value.
	CustomFieldValues map[string]any `` /* 162-byte string literal not displayed */
	IsTest            bool           `` /* 135-byte string literal not displayed */
}

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

type Host interface {
	// Propose renders the draft into the preview UI the human reviews and submits.
	Propose(ctx context.Context, target Target, payload MaterializePayload) error
	// Ask posts the planner's question and records it on the session; the turn has
	// ended, and the user's answer starts the next one.
	Ask(ctx context.Context, target Target, question QuestionPayload) error
	// ReportFallback tells the user the turn reached no conclusion.
	ReportFallback(ctx context.Context, target Target, reason string) error
}

type MaterializePayload struct {
	WorkspaceID       string
	Title             string
	Description       string
	CustomFieldValues map[string]any
	// IsTest marks the proposed case as a test case. Defaults to false.
	IsTest bool
}

type QuestionItem struct {
	// ID uniquely identifies the question within the payload; the host
	// uses it to correlate answers back when the user submits.
	ID string
	// Text is the prompt shown to the user.
	Text string
	// Type discriminates the answer control (select / multi_select /
	// free_text).
	Type QuestionItemType
	// Options is the allowed answer set for select / multi_select
	// (always ≥2 entries). Ignored for free_text.
	Options []string
}

type QuestionItemType string

type QuestionPayload struct {
	// Reason explains the information gap (single rationale shared across
	// all items).
	Reason string
	// Items is the ordered list of questions to ask in this turn. Always
	// non-empty (validation guarantees ≥1).
	Items []QuestionItem
}

type Result struct {
	Status Status
}

type Status int

type Target struct {
	SessionID string
	ChannelID string
	ThreadTS  string
	// ActorUserID is the person whose request this draft answers.
	ActorUserID string
	// ProcessingTS and PreviewTS name the message the result replaces, and are
	// mutually exclusive: the "working on it" placeholder a fresh mention posted,
	// or the existing preview a workspace switch updates in place.
	ProcessingTS string
	PreviewTS    string
	// ProposalID is the draft THIS run writes into, carried on the run rather than
	// read back from the Session. The Session's ProposalID is mutable — a later
	// mention repoints it while this run is still going — so reading it here would
	// let one turn's result land in another turn's draft.
	ProposalID model.CaseProposalID
	// ProcessID is the run that produced this outcome. A host that records a
	// question needs it so the turn started by the answer can inherit this run's
	// conversation.
	ProcessID string
}

type Trigger int

type TurnRequest struct {
	// Session is the per-thread Session row. Its ID is the turn's subject, so it
	// must already be persisted before a turn can be spawned.
	Session *model.Session

	// UserInput is the agent's first user message. For app_mention this is the
	// mention text; for thread_reply the reply text; for ws_switch a synthetic
	// system-event sentence.
	UserInput string

	// Trigger discriminates the entry point — it drives prompt hints.
	Trigger Trigger

	// TriggerTS is the Slack TS the turn is deduplicated on. It is empty for the
	// synthetic ws_switch trigger, which has no Slack event behind it.
	TriggerTS string

	// ActorUserID is the Slack user who initiated the turn. It is the run's access
	// actor: without it the usecase layer reads the run as a system context and
	// bypasses private-case access control.
	ActorUserID string

	// ExistingProposal is the prior draft persisted by the host (when this turn
	// resumes an existing draft, e.g. ws-switch or thread reply). The agent does
	// not consume it directly — the host uses it to keep preview state coherent
	// across turns.
	ExistingProposal *model.CaseProposal

	// ProcessingTS and PreviewTS name the Slack message this turn's result
	// replaces, and are mutually exclusive: the "working on it" placeholder a fresh
	// mention posted, or the existing preview a workspace switch updates in place.
	//
	// They are carried on the run because the call that posted them returns before
	// the result exists.
	ProcessingTS string
	PreviewTS    string

	// InheritFrom continues a finished run's conversation in this one. It is how an
	// answered question resumes: the answering turn is a NEW run — its own budget,
	// its own record — but it must see the request, the investigation and the
	// question that produced it. Empty starts a fresh conversation.
	InheritFrom string
}