tui

type AgentEventMsg struct {
	Event agentcore.Event
}

type AskUserMsg struct {
	Questions []tools.Question
	RespCh    chan<- *tools.AskUserResponse
}

type BtwResultMsg struct {
	Answer string
	Err    error
}

type CommandResultMsg struct {
	Text string
	// Inline prints the result flush against the previous scrollback block
	// (no leading blank line). Use for output that should feel like a direct
	// continuation — e.g. shell command output under its echoed prompt.
	Inline           bool
	Quit             bool   // true for /exit
	Clear            bool   // true for /clear
	NewProvider      string // non-empty if provider was switched
	NewModel         string // non-empty if model was switched
	NewContextWindow int    // non-zero if context window changed
}

type CompletionItem struct {
	Name        string // command name without "/" (e.g. "model")
	Description string
	Usage       string
	Kind        string
	Category    string
	NeedsIdle   bool
	Source      string
	Aliases     []string
	AutoExecute bool
}

type Config struct {
	Placeholder          string
	Version              string
	Provider             string
	ContextWindow        int
	Cwd                  string
	PlansDir             string // absolute path to the plan files directory; enables hidden rendering for write/edit on plan files
	GitBranch            string
	EnvHint              string                   // shown below welcome when using env var credentials
	History              *storage.History         // input history (Up/Down navigation)
	InitialTasks         *storage.TaskSnapshot    // initial task snapshot restored before first render
	RestoredMessages     []agentcore.AgentMessage // messages restored from a previous session (rendered on Init)
	OnKey                func(m *Model, msg tea.KeyMsg) (handled bool, cmd tea.Cmd)
	OnEvent              func(m *Model, ev agentcore.Event) tea.Cmd
	OnPaste              func(m *Model) tea.Cmd              // Ctrl+V: read clipboard image, return ImageAttachedMsg
	OnDrop               func(m *Model, text string) tea.Cmd // Drag-drop: if text is image path, return cmd; else nil
	OnMCPReady           func(msg MCPReadyMsg)               // called when MCP servers finish connecting
	OnHideCompletedTasks func(snap storage.TaskSnapshot) tea.Cmd
	StatusRight          func(m *Model) string
	StatusMode           func(m *Model) string                // mode indicator for context bar (e.g. "⏵⏵ trust")
	StatusTeam           func(m *Model) string                // active-team indicator for context bar (e.g. "△ alpha · 2 idle")
	Overlay              func(m *Model) *OverlayState         // interactive command overlay
	Completions          func(prefix string) []CompletionItem // slash command completions
	OnBtwResult          func(msg BtwResultMsg)               // called when /btw side question completes

	// TeammateEvents is the optional fan-out hub for teammate AgentLoop
	// events. When non-nil the Ctrl+T modal subscribes to it to render a
	// teammate's live transcript. nil disables the modal entirely.
	TeammateEvents *agent.TeammateEventHub
}

type Deps struct {
	Driver        Driver
	ModelName     string
	ContextWindow int
	Provider      string
	Version       string
	// contains filtered or unexported fields
}

type Driver interface {
	Prompt(text string) error
	PromptWithBlocks(blocks []agentcore.ContentBlock) error
	Steer(text string)
	Abort()
}

type HideCompletedTasksMsg struct {
	Version uint64
}

type ImageAttachedMsg struct {
	Block agentcore.ContentBlock // pre-built ImageBlock (base64 + mime)
}

type InfoOverlayFrame struct {
	Title    string
	Subtitle string
	Tabs     []InfoOverlayTab
	Active   int
	Hint     string
	Width    int
	// Height is the terminal viewport height. When > 0, every tab body is
	// normalised to the same number of rows: long bodies are clipped so the
	// header stays on screen, short bodies are padded so switching tabs does
	// not change the overlay's total height (which would scroll the header
	// up/down in inline render mode).
	Height int
}

type InfoOverlayTab struct {
	Name string
	Body func(width int) string
}

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

type MCPReadyMsg struct {
	Tools        int      // total number of tools loaded across all servers
	Errors       []string // connection errors (server: reason)
	Instructions string   // MCP server instructions to set as system suffix
}

type Model struct {
	Deps
	State
}

type OverlayState struct {
	HandleKey     func(msg tea.KeyMsg) (handled bool, cmd tea.Cmd)
	View          func(width, height int) string
	ReplacesInput bool // when true, overlay replaces the input area instead of appearing below it
}

type PasteErrorMsg struct {
	Text string
}

type PasteTextMsg struct{}

type PermissionDismissMsg struct{}

type PermissionMsg struct {
	Tool         string
	Command      string
	Reason       string
	Preview      string
	Warning      string // UI-only destructive-action hint; "" suppresses the row
	OutsideRoots bool   // when true, only AllowOnce and Deny are shown
	RespCh       chan<- PermitChoice
}

type PermitChoice int

type PromptMsg struct {
	Text string
}

type RestoreMsg struct{ Msgs []agentcore.AgentMessage }

type RetryStatusMsg struct {
	Prefix   string
	Deadline time.Time
}

type State struct {
	Input   textarea.Model
	Spinner spinner.Model

	ToolSpinner spinner.Model // breathing-dot spinner for tool execution

	Streaming *strings.Builder
	Thinking  *strings.Builder
	IsStream  bool
	// SuppressNextAssistantText avoids double-printing when an in-flight
	// assistant stream is flushed manually before a terminal tool aborts the
	// run, but a late MessageEnd still arrives with the same content.
	SuppressNextAssistantText string

	Running         bool
	TurnCount       int
	PendingTools    map[string]string           // toolID -> display label (== "Plan" marks a plan-file write/edit)
	HiddenToolCalls map[string]struct{}         // toolID -> internal call hidden from UI
	ToolHeaders     map[string]string           // toolID -> formatted header (printed at end)
	ToolOutputBuf   map[string]*strings.Builder // toolID -> streaming output
	ToolDeltaBuf    map[string]*strings.Builder // toolID -> accumulated subagent delta text
	ToolThinkingBuf map[string]*strings.Builder // toolID -> accumulated subagent thinking text

	Width  int
	Height int
	Ready  bool

	Cwd         string
	PlansDir    string
	GitBranch   string
	ShowWelcome bool
	EnvHint     string // env var hint shown below welcome
	RunStats    runStats
	Images      []agentcore.ContentBlock // attached images (from Ctrl+V clipboard paste)
	ImageCursor int                      // -1 = not selecting; 0+ = selected image index
	Pasting     int                      // number of async image reads in progress (clipboard paste or drag-drop)

	Markdown *markdown.Renderer

	AskUser    *askUserState    // non-nil when ask-user UI is active
	Permission *permissionState // non-nil when permission prompt is active

	Tasks *storage.TaskSnapshot // non-nil when task items exist; displayed above input

	QueuedMsgs []string // messages queued while agent is running (display only)

	// Retry countdown shown in the live area while auto-retrying.
	// RetryPrefix is the static text (e.g. "Request failed, retrying (1/3)");
	// RetryDeadline is when the retry will fire — View() computes remaining seconds.
	RetryPrefix   string
	RetryDeadline time.Time

	MCPLoading bool // true while MCP servers are connecting in background

	// Scrollback mirrors the stream of pre-formatted bodies sent to
	// tea.Println. It exists solely to cure the terminal-resize ghost /
	// reflow duplication problem.
	//
	// Precise cause: Println content, once written, is inert — bubbletea
	// never redraws it, so reflow at worst re-wraps it in place without
	// duplicating. The ghosts come exclusively from the live View()
	// (status bar, input panel borders, streaming area). On resize the
	// terminal pushes those rows up into OS scrollback to make room for
	// the new viewport, but bubbletea's `linesRendered` cursor tracking
	// still points at the old position — its next frame's "erase previous
	// frame" sequence misses, and the pushed-up copy is marooned in
	// scrollback as a ghost.
	//
	// Fix: on WindowSizeMsg we wipe viewport + OS scrollback (`\x1b[2J`
	// + `\x1b[3J` + `\x1b[H`) to evict the ghosts, then replay this cache
	// so legitimate Println history survives the nuke. Without the cache
	// we'd be trading ghosts for lost conversation history. See
	// handleResize for the replay path, Emit for the write path,
	// handleCommandResult (msg.Clear) for the reset path.
	//
	// Entries are the exact string passed to tea.Println (as returned by
	// formatScrollbackBlock), so joining them with "\n" and Println'ing
	// once is byte-for-byte equivalent to the original per-block Println
	// sequence — tea.Println splits on "\n" internally. Bounded by
	// scrollbackCacheLimit; entries beyond the cap are dropped FIFO,
	// which only materialises as lost history after a resize (the live
	// terminal scrollback remains complete until the next resize clears
	// it).
	Scrollback []string

	Suggestion string // prompt suggestion shown as placeholder after agent completes

	QuitPending bool // true after first Ctrl+C, waiting for second to quit

	// TranscriptModal renders the live transcript of a teammate when the
	// user opens the popup (Ctrl+T). nil = closed; non-nil = open and
	// full-screen, taking over all keyboard input except Esc / Ctrl+T /
	// Ctrl+C and the scroll keys.
	TranscriptModal *TranscriptView
	// TranscriptAgent is the teammate currently shown in the modal.
	TranscriptAgent string
	// contains filtered or unexported fields
}

type SuggestionMsg struct {
	Text string
}

type TaskListUpdateMsg struct {
	Snapshot storage.TaskSnapshot
}

type TasksRefreshMsg struct{}

type TranscriptChannelClosedMsg struct {
	Agent string
}

type TranscriptEventMsg struct {
	Agent string
	Event agentcore.Event
}

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