model

type Action struct {
	ID             int64
	CaseID         int64 // Required: Action must be associated with a Case (1:n relationship)
	Title          string
	Description    string
	AssigneeID     string // Slack User ID; empty string means unassigned
	SlackMessageTS string // Optional: Slack message ID (timestamp)
	Status         types.ActionStatus
	DueDate        *time.Time // Optional: deadline for the action
	ArchivedAt     *time.Time // nil = active; non-nil = archived at the given time
	CreatedAt      time.Time
	UpdatedAt      time.Time
}

type ActionEvent struct {
	ID        string                // unique within the action
	ActionID  int64                 // parent action id
	Kind      types.ActionEventKind // CREATED / TITLE_CHANGED / STATUS_CHANGED / ASSIGNEE_CHANGED
	ActorID   string                // Slack user id of the person who triggered the change ("" = system)
	OldValue  string                // old field value rendered as a string (empty for CREATED)
	NewValue  string                // new field value rendered as a string
	CreatedAt time.Time
}

type ActionStatusColorPreset string

type ActionStatusDefinition struct {
	ID          string
	Name        string
	Description string
	Color       string // either a preset name (lowercase) or "#RRGGBB" / "#RGB"
	Emoji       string
}

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

type ActionStep struct {
	ID        string
	ActionID  int64
	Title     string
	DoneAt    *time.Time
	DoneBy    string
	CreatedBy string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type AssistLog struct {
	ID        AssistLogID
	CaseID    int64
	Summary   string // One-line summary of this session
	Actions   string // What was done in this session (may be empty if nothing was done)
	Reasoning string // Rationale behind decisions made
	NextSteps string // Items to address in future sessions
	CreatedAt time.Time
}

type AssistLogID string

type Case struct {
	ID             int64
	Title          string
	Description    string
	Status         types.CaseStatus
	ReporterID     string   // Slack User ID of the case reporter (immutable after creation)
	AssigneeIDs    []string // Slack User IDs
	SlackChannelID string

	// SlackThreadTS binds a thread-mode Case to its Slack thread. Empty for
	// channel-mode Cases (SlackChannelID is then a dedicated channel). For
	// thread-mode Cases SlackChannelID is the monitored channel and
	// SlackThreadTS is the thread parent timestamp. See CaseMode.
	SlackThreadTS string

	// BoardStatus is the configurable workflow status id (the Kanban column)
	// for thread-mode Cases, validated against the workspace's CaseStatusSet.
	// Empty for channel-mode Cases, where the configurable status attaches to
	// Actions instead. The lifecycle Status is kept in sync with BoardStatus
	// via SyncLifecycleFromBoardStatus (closed status id => CLOSED).
	BoardStatus string

	IsPrivate      bool                  // Private mode flag
	IsTest         bool                  // Marks a case filed for testing/verification, distinguished from production cases
	ChannelUserIDs []string              // Slack User IDs of channel members (synced for all cases)
	AccessDenied   bool                  // Runtime-only: set by UseCase when access is restricted (not persisted)
	FieldValues    map[string]FieldValue // key = FieldID
	RequestKey     string                // UUID for preventing duplicate case creation from Slack modals

	// AgentAdditionalPrompt is a Case-specific Markdown snippet that the
	// Job runner appends to the TOML-defined Job prompt at agent execution
	// time. Empty by default; capped at AgentAdditionalPromptMaxLen bytes
	// and enforced by Validate().
	AgentAdditionalPrompt string

	// AgentSourceIDs restricts which Sources the agent uses when running
	// against this Case. Empty (nil or len==0) means "use every Source
	// the agent would normally consider" — i.e. preserves the existing
	// default of all enabled Workspace Sources. Non-empty narrows the
	// set to exactly the listed IDs (unknown / disabled IDs are dropped
	// at use time, not at write time, so a Source toggled off later does
	// not invalidate the stored selection).
	AgentSourceIDs []SourceID

	CreatedAt time.Time
	UpdatedAt time.Time
}

type CaseEventConfig struct {
	// On lists the lifecycle events the Job is subscribed to. Always a
	// normalised, non-empty slice produced by the config loader from the
	// TOML "on" field. The domain layer never accepts a single-string form
	// — see config/job.go for the parsing rules.
	On []CaseLifecycle
}

type CaseLifecycle string

type CaseMode string

type CaseProposal struct {
	ID        CaseProposalID
	CreatedBy string // Slack user ID who triggered the mention
	CreatedAt time.Time
	ExpiresAt time.Time

	// (a) Source — workspace-agnostic, immutable after creation
	RawMessages []ProposalMessage
	MentionText string
	Source      ProposalSource

	// (b) Current AI materialization (overwritten on workspace switch)
	SelectedWorkspaceID string
	Materialization     *WorkspaceMaterialization

	// InferenceInProgress is the server-side guard against concurrent
	// Submit/Edit/WS-switch interactions while a Materializer call is running.
	InferenceInProgress bool

	// EphemeralChannelID and EphemeralMessageTS identify the originally posted
	// ephemeral message. Used by interaction handlers that lack a response_url
	// (e.g., view_submission flows) to update the ephemeral via chat APIs.
	EphemeralChannelID string
	EphemeralMessageTS string
}

type CaseProposalID string

type CaseRef struct {
	ID          int64
	Title       string
	Status      types.CaseStatus
	WorkspaceID string
}

type CaseTrigger string

type FieldInput struct {
	// FieldID references FieldDefinition.ID from the workspace schema.
	FieldID string
	// Value carries the scalar form (text / number / url / date / single
	// select option id / single user id).
	Value string
	// Values carries the multi form (multi-select option ids / multi-user ids).
	Values []string
}

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

type FieldValue struct {
	FieldID types.FieldID   // References FieldDefinition.ID from configuration
	Type    types.FieldType // Field type (self-descriptive)
	Value   any             // Actual value (Go type depends on field type)
}

type GitHubConfig struct {
	Repositories []GitHubRepository
}

type GitHubRepository struct {
	Owner string
	Repo  string
}

type HomeMessage struct {
	ID        HomeMessageID
	UserID    string // Slack User ID (auth token Sub). Required.
	Message   string // Generated one-liner. Required.
	Lang      string // Language at generation ("en"/"ja"); used for reuse matching.
	CreatedAt time.Time
}

type HomeMessageID string

type ImportActionResult struct {
	Status          ImportItemResultStatus
	CreatedActionID *int64
	Error           *ImportIssue
}

type ImportCaseResult struct {
	Status        ImportItemResultStatus
	CreatedCaseID *int64
	Error         *ImportIssue
}

type ImportIssue struct {
	Path     string
	Message  string
	Severity ImportIssueSeverity
}

type ImportIssueSeverity string

type ImportItemResultStatus string

type ImportSession struct {
	ID            ImportSessionID
	WorkspaceID   string
	CreatorUserID string // Slack User ID of the creator (immutable)
	Status        ImportSessionStatus

	Source   ImportSource   // Original file metadata
	Snapshot ImportSnapshot // Normalized payload (per-Case result is stored here)
	Issues   []ImportIssue  // Session-level issues (parse failure, version, schema stale, etc.)

	// FieldSchemaHash is a digest of the workspace field schema captured at
	// createCaseImport time. executeCaseImport compares against the current
	// hash and refuses to run if it differs (callers must create a new import).
	FieldSchemaHash string

	CreatedAt time.Time
	UpdatedAt time.Time

	// ExecutedAt is set when status transitions to applied or failed.
	ExecutedAt *time.Time

	// Aggregate counts over Snapshot.Cases[*].Result.Status. Recomputed
	// by the usecase on every Update so they stay consistent.
	CreatedCount int
	FailedCount  int
	SkippedCount int
}

type ImportSessionID string

type ImportSessionStatus string

type ImportSnapshot struct {
	Version int
	Cases   []ImportSnapshotCase
}

type ImportSnapshotAction struct {
	Index       int
	Title       string
	Description string
	AssigneeID  string
	DueDate     *time.Time
	Issues      []ImportIssue
	Result      ImportActionResult
}

type ImportSnapshotCase struct {
	Index       int
	Title       string
	Description string
	IsPrivate   bool
	AssigneeIDs []string
	FieldValues map[string]FieldValue
	Actions     []ImportSnapshotAction
	Issues      []ImportIssue
	Result      ImportCaseResult
}

type ImportSource struct {
	OriginalFileName string
	ContentDigest    string // sha256 of the raw YAML, hex-encoded
	SizeBytes        int
}

type Job struct {
	// ID is the workspace-unique identifier (kebab-case).
	ID string

	// Name and Description are human-facing labels used in logs and
	// system prompts.
	Name        string
	Description string

	// Prompt is the user prompt template (Go text/template). Job-specific
	// behaviour is fully expressed here; runtime context (Case / Workspace
	// / Event) is injected as template data.
	Prompt string

	// Disabled defaults to false (= active). Setting it true silently
	// excludes the Job from event matching without removing the TOML
	// entry.
	Disabled bool

	// Quiet defaults to false. When true, the Job runs without emitting
	// operational Slack notifications (the "starting..." marker, the
	// per-run session-log thread, and the completion/failure markers).
	// It does NOT silence the agent's own slack__post_message tool — that
	// is a deliberate agent action, not an operational log.
	Quiet bool

	// Strategy selects which execution runtime drives this Job. Empty
	// (the zero value) is equivalent to JobStrategySimple; the config
	// loader normalises before Validate runs.
	Strategy JobStrategy

	// Interactive enables mid-run user interaction. When true, the Job may
	// suspend a run to ask the user a question (planexec Question), persist
	// the pending interaction on its run state, post a Slack form, and
	// resume when the user answers. Defaults to false (= the run is fully
	// unattended). Only meaningful for JobStrategyPlanexec: the simple
	// single-loop runtime has no Question mechanism, so Validate rejects
	// interactive simple Jobs. Independent of Quiet — the question form is a
	// deliberate agent interaction, not an operational log, so Quiet does
	// not suppress it.
	Interactive bool

	// Reflection, when true, runs a post-execution reflection pass after a
	// successful run: a knowledge-only agent reviews the run's conversation
	// history and curates the workspace's shared Knowledge / Tags. Defaults
	// to false. Skipped for private cases and for failed runs.
	Reflection bool

	// Events maps the event domains this Job subscribes to. Validate
	// guarantees at least one non-nil entry.
	Events JobEvents
}

type JobEventDomain string

type JobEvents struct {
	Case      *CaseEventConfig
	Scheduled *ScheduledEventConfig
}

type JobRun struct {
	WorkspaceID string
	CaseID      int64
	JobID       string

	LastRunAt   time.Time
	LastStatus  JobRunStatus
	LastError   string
	LastRunID   string
	LastTraceID string

	// LeaseUntil is the wall-clock time at which the current run lock
	// expires. Zero value means no live lease (= idle). A lease may be
	// reclaimed by another acquirer once LeaseUntil < now (clock
	// agreement is assumed; lease durations are large enough to absorb
	// minor skew).
	LeaseUntil time.Time

	// SuspendedRunID, when non-empty, names a Run that is currently
	// suspended awaiting user input (Stage=AWAITING_INPUT in its
	// JobRunLog). While set, the scheduler/dispatcher MUST NOT start a new
	// Run for this (workspace, case, job) — the in-flight interactive Run
	// owns the slot until the user answers (resume clears it) or the
	// unanswered-run sweep expires it. The lease is released while
	// suspended (a human wait can outlast any lease), so SuspendedRunID is
	// the durable "do not double-start" signal, not the lease.
	SuspendedRunID string

	// SuspendedAt is when the current suspension began; the unanswered-run
	// sweep uses it to expire stale AWAITING_INPUT runs. Zero when not
	// suspended.
	SuspendedAt time.Time
}

type JobRunEvent struct {
	// Identifiers (flat, all populated on every write).
	WorkspaceID string
	CaseID      int64
	JobID       string
	RunID       string
	TraceID     string

	// EventID is the doc ID of this event. It is a UUIDv7 string,
	// chosen for Firestore-console readability (the doc ID surfaces a
	// millisecond timestamp prefix) and global uniqueness. doc IDs are
	// NOT relied on for strict ordering — `Sequence` is the
	// authoritative monotonic order.
	EventID string

	// Position.
	// Sequence is the authoritative monotonic order within a Run. It is
	// int64 (not uint64) because the Firestore SDK rejects uint64. The
	// value space is still effectively unbounded for this workload
	// (max int64 = 9.2e18 events per Run). List queries MUST OrderBy
	// "Sequence" — doc ID order may diverge under clock skew.
	Sequence   int64
	OccurredAt time.Time
	Kind       JobRunEventKind

	// ParentSequence links a child event to its parent. Currently used
	// by ToolCall events to point back at the LLMResponse whose tool_use
	// they implement. Zero means top-level (LLMRequest / LLMResponse /
	// RunError are always top-level).
	ParentSequence int64

	// Forward-compatible runtime tagging. v1 SingleLoopJobExecutor emits
	// Phase="execute" and AgentLabel="" for every event. A future
	// plan-execute runtime may emit Phase="plan" / "execute" / "review"
	// and AgentLabel="planner" / "executor" / etc.
	Phase      string
	AgentLabel string

	// Payload (exactly one is non-nil and matches Kind).
	LLMRequest  *LLMRequestPayload
	LLMResponse *LLMResponsePayload
	ToolCall    *ToolCallPayload
	RunError    *RunErrorPayload
}

type JobRunEventKind string

type JobRunKey struct {
	WorkspaceID string
	CaseID      int64
	JobID       string
}

type JobRunLog struct {
	// Identifiers (all flat, all required, all populated on every write).
	WorkspaceID string
	CaseID      int64
	JobID       string
	RunID       string
	TraceID     string

	// Lifecycle.
	Stage     JobRunStage
	StartedAt time.Time
	EndedAt   time.Time // zero while RUNNING
	Error     string    // empty unless Stage == FAILED

	// Runtime identification (forward-compatible with plan-execute).
	// v1 always writes ExecutorKind="single_loop".
	ExecutorKind    string
	ExecutorVersion string

	// Provenance — copied from the triggering Event so a single Get tells
	// you why this Run happened.
	EventType      string
	EventTriggerAt time.Time

	// SystemPrompt is held once per Run, here, rather than inside every
	// LLMRequest event (it doesn't change turn-to-turn within a Run).
	// Truncated from the tail to MaxInlineBytes if longer.
	SystemPrompt string

	// PendingInteraction is set ONLY while Stage == AWAITING_INPUT: it holds
	// the question put to the user and the Slack message coordinates needed
	// to update the form in place on resume. It MUST be nil in every other
	// stage (the resume path clears it). It is the entire persisted state a
	// suspend needs — no planexec plan snapshot is stored, because the
	// gollem conversation history (keyed by RunID) already carries the
	// sub-agent observations and the resume re-enters planexec at the
	// replan branch with a fresh budget.
	PendingInteraction *PendingInteraction
}

type JobRunStage string

type JobRunStatus string

type JobStrategy string

type Knowledge struct {
	ID          KnowledgeID
	WorkspaceID string
	Title       string
	// Claim is a single Markdown text body (not an array). It is stored verbatim
	// and rendered as Markdown by the consumer (Web UI). The agent write tools
	// produce it directly.
	Claim string
	// TagIDs reference first-class Tag entities for classification and filtering.
	// At least one tag is required. Tags must be created (create_tag / GraphQL
	// createTag) before they can be referenced here; the usecase verifies every
	// ID exists in the workspace before persistence. The slice is de-duplicated
	// (order preserved) by the usecase.
	TagIDs []TagID
	// Embedding is the vector embedding of Title + Claim used for in-memory
	// cosine semantic search. It is empty when no embedding client is configured
	// (fail-open). It is never exposed through the GraphQL surface.
	Embedding []float64
	// CreatorID is the Slack user id of the human author. It is empty when the
	// entry was authored by an agent (system actor).
	CreatorID string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type KnowledgeID string

type LLMContentBlock struct {
	Type string // "text" / "tool_call" / "tool_response" / "reasoning" / "image" / etc.

	Text string // text / reasoning

	// tool_call
	ID            string
	Name          string
	ArgumentsJSON string

	// tool_response
	ToolCallID string
	ResultJSON string

	// image / pdf / document / file
	MediaType string
	URL       string
	Title     string
}

type LLMFunctionCall struct {
	ID            string // provider-issued id
	Name          string
	ArgumentsJSON string // raw JSON of trace.FunctionCall.Arguments
}

type LLMMessage struct {
	Role     string
	Contents []LLMContentBlock
}

type LLMRequestPayload struct {
	Model    string        // LLMCallData.Model
	Messages []LLMMessage  // LLMRequest.Messages
	Tools    []LLMToolSpec // LLMRequest.Tools (name + description only)
}

type LLMResponsePayload struct {
	Model         string            // echoed back (LLMCallData.Model)
	Texts         []string          // LLMResponse.Texts
	FunctionCalls []LLMFunctionCall // LLMResponse.FunctionCalls
	InputTokens   int64             // LLMCallData.InputTokens
	OutputTokens  int64             // LLMCallData.OutputTokens
	DurationMs    int64             // wall-clock time between Start/End hook
}

type LLMToolSpec struct {
	Name        string
	Description string
}

type MaterializationValidationIssue struct {
	FieldID types.FieldID // empty for issues on Title/Description
	Code    string        // machine-readable category, e.g. "missing_required"
	Message string
	Fatal   bool
}

type Memo struct {
	ID          MemoID
	WorkspaceID string
	CaseID      int64
	Title       string
	// FieldValues holds the custom field values keyed by field id, using the
	// same representation as Case (model.FieldValue, validated by the shared
	// FieldValidator against the workspace's memo field schema).
	FieldValues map[string]FieldValue
	// CreatorID is the Slack user id of the human author. It is empty when the
	// memo was authored by an agent (system actor).
	CreatorID string
	// ArchivedAt is nil for an active memo and non-nil once archived (soft
	// delete). Archive state is expressed by this single field; there is no
	// derived boolean.
	ArchivedAt *time.Time
	CreatedAt  time.Time
	UpdatedAt  time.Time
}

type MemoID string

type MyDueAction struct {
	WorkspaceID   string
	WorkspaceName string
	Action        *Action
	CaseID        int64
	CaseTitle     string
}

type MyOpenCase struct {
	WorkspaceID   string
	WorkspaceName string
	Case          *Case
	// Stalled is true when the Case is open but has not been updated within the
	// configured stale window. Always false when the window is disabled.
	Stalled bool
}

type NotificationSlot struct {
	ChannelID string                  // Slack channel id (primary key)
	MessageTS string                  // Timestamp of the aggregated channel message
	Entries   []NotificationSlotEntry // Recorded change events (oldest first)
	SlotStart time.Time               // UTC time when the slot's channel message was first posted
	ExpiresAt time.Time               // SlotStart + slotDuration
	UpdatedAt time.Time
}

type NotificationSlotEntry struct {
	ActionMessageTS string    // Parent Action card timestamp — used as the grouping key
	ActionTitle     string    // Action title as of the event (most recent wins per group)
	ActionPermalink string    // Slack permalink to the Action card; empty when lookup failed
	Body            string    // Pre-rendered change line ("@user changed status: A → B")
	EventTime       time.Time // UTC time the event was recorded
}

type NotionDBConfig struct {
	DatabaseID    string
	DatabaseTitle string
	DatabaseURL   string
}

type NotionPageConfig struct {
	PageID    string
	PageTitle string
	PageURL   string
	Recursive bool
	MaxDepth  int
}

type PendingInteraction struct {
	// PostedChannelID / PostedMessageTS locate the Slack question form so
	// the resume path can update it in place to an "answered" view.
	PostedChannelID string
	PostedMessageTS string

	// Reason is the shared rationale rendered once above the items.
	Reason string

	// Items is the ordered list of questions (1..5).
	Items []PendingInteractionItem
}

type PendingInteractionItem struct {
	ID      string
	Text    string
	Type    string // select | multi_select | free_text
	Options []string
}

type PendingQuestion struct {
	// PostedChannelID / PostedMessageTS locate the Slack message hosting the
	// question form so the submit handler can update it in place into the
	// read-only "answered" view.
	PostedChannelID string
	PostedMessageTS string
	// Reason is the planner's single-rationale text shared across all items.
	Reason string
	// Items mirrors proposal.QuestionPayload.Items at the time the question was
	// posted. Stored here so the submit handler can label each answer back
	// against the original question text and option list, even after the
	// planner advances and the Slack message blocks have been rebuilt.
	Items []PendingQuestionItem
}

type PendingQuestionItem struct {
	ID      string
	Text    string
	Type    string // "select" | "multi_select"
	Options []string
}

type ProposalMessage struct {
	UserID    string
	Text      string
	TS        string
	Permalink string
}

type ProposalSource struct {
	TeamID    string
	ChannelID string
	ThreadTS  string // empty when the mention was not in a thread
	MentionTS string
}

type RunErrorPayload struct {
	Stage   string // "prepare" / "execute" / "finish"
	Message string
}

type ScheduledEventConfig struct {
	// Every is the duration since the last run after which the Job becomes
	// due. Mutually exclusive with Cron.
	Every time.Duration

	// Cron is the parsed schedule for cron-style triggers. Mutually
	// exclusive with Every. Parsed at config load time so a malformed
	// expression fails loud before any Job dispatch.
	Cron cron.Schedule

	// CronExpr is the original cron expression preserved for display and
	// system-prompt rendering. Empty when Every is in use.
	CronExpr string
}

type Session struct {
	ID            string
	ChannelID     string
	ThreadTS      string
	LastMentionTS string
	LastAction    SessionEndReason

	// Kind discriminates the conversation that owns this thread. It is set when
	// the Session is created and never changed afterwards: the Slack dispatcher
	// reads it to decide whether an @mention in a case-less thread starts a Case
	// (SessionKindCase) or continues the workspace agent
	// (SessionKindWorkspaceAgent).
	Kind SessionKind

	// Case binding — zero values when the thread is not in a case-bound channel.
	WorkspaceID string
	CaseID      int64
	ActionID    int64

	// Open-mode metadata — zero values when case-bound.
	CreatorUserID string
	ProposalID    CaseProposalID

	// Reaction-origin metadata — set only for a cross-channel reaction-triggered
	// case creation, where the case root lives in the monitored channel but the
	// flagged message lives elsewhere. Persisted so a later resume turn (after a
	// question) can still link the exact source message. Zero for every other
	// creation path.
	ReactionSourceChannelID string
	ReactionSourceMessageTS string

	// Turn lock fields. Maintained by SessionRepository.AcquireTurnLock /
	// Heartbeat / ReleaseTurnLock. Heartbeat staleness (TurnHeartbeatAt vs now)
	// is the activity signal; TurnStartedAt is recorded for traces / UX only.
	TurnState       SessionTurnState
	TurnOwnerID     string
	TurnStartedAt   time.Time
	TurnHeartbeatAt time.Time
	TurnTriggerTS   string

	// Reserved for future interrupt support. Never read or written by Phase A
	// code paths; populated by RequestInterrupt in a later spec.
	InterruptRequestedAt time.Time
	InterruptByTriggerTS string

	// PendingQuestion mirrors the planner's most recent question payload when
	// LastAction == SessionEndedWithQuestion. It is the single source of
	// truth for the Slack-side question form: rendering it, parsing the
	// submission state back into typed answers, and rebuilding the read-only
	// "answered" view after the user clicks Submit. Cleared on the next
	// terminal action.
	PendingQuestion *PendingQuestion

	CreatedAt time.Time
	UpdatedAt time.Time
}

type SessionEndReason string

type SessionKind string

type SessionTurnState string

type SlackChannel struct {
	ID   string // Slack Channel ID (e.g., C01234567)
	Name string // Fallback name for display when API is unavailable
}

type SlackConfig struct {
	Channels []SlackChannel
}

type SlackUser struct {
	ID        SlackUserID
	Name      string    // Slack username / handle (e.g., "john.doe")
	RealName  string    // User-facing display name (Profile.DisplayName, with Profile.RealName / RealName as fallback). Field is named "RealName" for legacy reasons.
	Email     string    // Email address (for future features)
	ImageURL  string    // Avatar URL (empty string = no image)
	UpdatedAt time.Time // Last synchronized from Slack
}

type SlackUserID string

type SlackUserMetadata struct {
	LastRefreshSuccess time.Time // Last successful refresh time
	LastRefreshAttempt time.Time // Last refresh attempt time (success or failure)
	UserCount          int       // Number of users at last successful refresh
}

type Source struct {
	ID               SourceID
	Name             string
	SourceType       SourceType
	Description      string
	Enabled          bool
	NotionDBConfig   *NotionDBConfig
	NotionPageConfig *NotionPageConfig
	SlackConfig      *SlackConfig
	GitHubConfig     *GitHubConfig
	CreatedAt        time.Time
	UpdatedAt        time.Time
}

type SourceID string

type SourceType string

type Tag struct {
	ID          TagID
	WorkspaceID string
	// Name is an optional, human-facing label. It is mutable (update_tag) and
	// carries no uniqueness constraint — the ID is the stable key.
	Name      string
	CreatedAt time.Time
	UpdatedAt time.Time
}

type TagID string

type ToolCallPayload struct {
	ToolName string

	ArgumentsJSON string // raw JSON of trace.ToolExecData.Args
	ResultJSON    string // raw JSON of trace.ToolExecData.Result; empty on pure error

	IsError      bool
	ErrorMessage string // trace.ToolExecData.Error when IsError

	StartedAt time.Time
	EndedAt   time.Time
}

type UserPreference struct {
	// UserID is the Slack User ID (auth token Sub). Document key. Required.
	UserID string
	// FavoriteWorkspaceIDs are the workspace IDs the user starred, in the
	// order the caller supplies (deduplicated). May be empty.
	FavoriteWorkspaceIDs []string
	CreatedAt            time.Time
	UpdatedAt            time.Time
}

type Workspace struct {
	ID          string
	Name        string
	Description string // Human-readable description (e.g. for AI workspace estimation, UI tooltips)
	// Emoji is an optional display glyph for the workspace badge. Mutually
	// exclusive with Color (enforced at config load). Empty when unset.
	Emoji string
	// Color is an optional #RRGGBB hex used as the workspace badge background.
	// Mutually exclusive with Emoji (enforced at config load). Empty when unset.
	Color string
}

type WorkspaceEntry struct {
	Workspace            Workspace
	FieldSchema          *config.FieldSchema
	MemoConfig           *config.MemoConfig // Memo "strong definition" + custom field schema (nil/empty when memos disabled)
	ActionStatusSet      *ActionStatusSet
	SlackChannelPrefix   string
	SlackTeamID          string // Slack Team ID for org-level app support (empty for WS-level apps)
	SlackInviteUsers     []string
	SlackInviteGroups    []string
	SlackWelcomeMessages []string // Go text/template strings posted to the case channel after creation
	CompilePrompt        string
	AssistPrompt         string
	AssistLanguage       string
	// CaseCreatePrompt is the workspace-specific additional prompt for the
	// thread-mode case initialization (create) agent, configured via TOML
	// [case.prompts].create. Empty when unset; appended to the ModeCreate
	// planner system prompt.
	CaseCreatePrompt string
	Jobs             []*Job // Event-driven agent jobs loaded from workspace TOML

	// CaseMode selects channel-per-case (default) or thread-per-case binding.
	CaseMode CaseMode
	// CaseTrigger selects what starts a Case in thread mode: instant (default,
	// every channel-root post) or mention (only an @mention of the bot). Only
	// meaningful when CaseMode is thread.
	CaseTrigger CaseTrigger
	// SlackMonitorChannelID is the channel watched for thread-mode case
	// creation. Required (and only meaningful) when CaseMode is thread.
	SlackMonitorChannelID string
	// AcceptBot opts the thread-mode monitored channel into
	// treating bot-authored channel-root posts (e.g. an intake-form app's
	// relayed request) as case-creation triggers. Default false: only human
	// channel-root posts start a case, so the channel is not flooded with a case
	// per bot notification. When true, every bot root post (bot_message /
	// bot_id) starts a case.
	AcceptBot bool
	// CaseStatusSet is the configurable workflow status set that attaches to
	// Cases in thread mode (the Kanban columns). Non-nil only for thread-mode
	// workspaces; reuses the generic ActionStatusSet value type.
	CaseStatusSet *ActionStatusSet
	// ReactionEmoji is the Slack reaction (emoji name, without surrounding
	// colons) that triggers case creation for this workspace. Empty when the
	// reaction trigger is disabled. Only meaningful in thread mode, and unique
	// across workspaces (enforced at config load).
	ReactionEmoji string
	// SlackWorkspaceChannelID is the workspace-level shared channel where the
	// cross-case workspace agent runs (and future notifications flow). Channel
	// mode only; empty when unset. Unique across workspaces / monitor channels
	// (enforced at config load).
	SlackWorkspaceChannelID string
	// WorkspaceAgentPrompt is the operator-supplied custom instruction for the
	// workspace agent (from [slack.workspace_agent] prompt/prompt_file). It is
	// appended to the host-owned base system prompt and cannot relax it. Empty
	// when unset.
	WorkspaceAgentPrompt string
}

type WorkspaceGroup struct {
	ID          string
	Name        string
	Description string
	// MemberIDs are workspace IDs in declared order. May be empty. Existence of
	// each ID in the workspace set is verified at config load, not here.
	MemberIDs []string
}

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

type WorkspaceMaterialization struct {
	GeneratedAt       time.Time
	Title             string
	Description       string
	CustomFieldValues map[string]FieldValue // key = FieldID defined in workspace's FieldSchema
	// IsTest carries the agent's test-case suggestion through the preview so
	// the human can confirm or override it before the case is created.
	IsTest bool
}

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