ui

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

type ConnectAction uint8

type ConnectController interface {
	ListConnectTargets(context.Context) ([]ConnectTarget, error)
}

type ConnectRestartIntent struct {
	Target string
	Action ConnectAction
	// ResumeSessionID is retained only for same-target recovery actions. Main
	// re-checks ownership through GetSession before adopting it.
	ResumeSessionID string
}

type ConnectTarget struct {
	Target   string
	Issuer   string
	ClientID string
	Audience string
}

type Converser interface {
	OpenConverse(ctx context.Context) (*client.Stream, error)
}

type Deps struct {
	Session SessionCreator
	Conv    Converser
	MCP     client.MCP       // MCP/ToolHive inventory + resources/prompts; nil disables the overlay
	Cmds    client.Commander // slash-command discovery for the input palette; nil disables it
	// ServerInfo reads the safe build and composition identities when /diagnostics is invoked against a remote server.
	ServerInfo ServerInfoGetter
	// ServerImpl is the locally-known embedded server family. It is used without
	// an RPC when Embedded is true.
	ServerImpl  string
	Skills      client.SkillLister      // skills-inventory discovery for the /skills panel; nil disables it
	Agents      client.AgentLister      // agent-definition discovery for the /agents panel; nil disables it
	Soul        client.SoulFetcher      // soul (persona) inspection for the /soul panel; nil disables it
	UserModel   client.UserModelLister  // user-model inspection for the /usermodel panel; nil disables it
	Reflections client.ReflectionClient // proposal review and explicit reflection; nil disables it
	Dream       client.DreamClient      // manual memory consolidation review; nil disables /dream
	Compactor   client.SessionCompactor // out-of-band session compaction; nil disables /compact
	Models      client.ModelLister      // selectable-model discovery for the /models picker; nil disables it
	Worktrees   client.WorktreeLister   // worktree discovery for the /worktrees overlay (issue #102); nil disables it
	// Sched is the schedule discovery + management surface for the /schedule overlay
	// (issue #234); nil disables it (the overlay is honestly absent). The overlay can
	// create/inspect/pause/resume/fire-now on any store-backed server; auto-firing on
	// a cadence is the server's tick loop (ON by default on a schedule-capable store,
	// ADR 0073 — `mecated --no-scheduler` opts out).
	Sched client.ScheduleLister
	// Sessions is the stored-session inventory surface for the /sessions picker
	// (issue #245 Phase 2); nil disables it (the overlay is honestly absent). It is
	// the lister the picker calls to enumerate stored sessions. Unlike the
	// caps-gated overlays it is NOT gated on a ServerCapabilities bit — the picker
	// is available whenever a lister + authoritative transcript loader are wired
	// (a no-FS/cloud server with a durable SessionStore still has stored sessions).
	Sessions client.SessionPager
	// StorageHealth is the authenticated aggregate health surface. The capability
	// bit controls whether the Sessions panel advertises its maintenance tab.
	StorageHealth client.StorageHealthFetcher
	// Migration and Cleanup are deliberately distinct management seams. Their
	// server capability bits independently gate the semantics-preserving and
	// destructive workflows.
	Migration client.SessionMigrator
	Cleanup   client.SessionCleaner
	// SessionManagement mutates stored main-chat metadata. nil leaves rename/delete
	// undiscoverable even if a custom lister advertises those capabilities.
	SessionManagement client.SessionManager
	// Adoption is the authenticated legacy-copy surface. Eligibility is always
	// taken from its source-correlated preflight, never inferred from row IDs.
	Adoption client.SessionAdopter
	// Transcript is the authoritative snapshot-derived conversation surface used
	// by /sessions for both continuation and read-only inspection. Event replay is
	// optional activity and never substitutes for this seam.
	Transcript client.SessionTranscripter
	// Replayer is the optional durable-event-log activity surface used by live
	// delivery catch-up. It never attests conversation completeness.
	Replayer client.SessionReplayer
	// LiveStream is the LIVE per-session event feed (ADR 0075 Scenario 5): the server
	// pushes fire-result delivery notes for the active session as they occur. The ui
	// holds the interface (not a *Client) so it is injectable with a fake for offline
	// tests. nil disables the live bridge (the ui still renders deliveries via the
	// replay on a session switch/reload, just not live). *Client satisfies it.
	LiveStream client.LiveStreamer
	// SelectionStore persists the picked model (last-used). nil disables persistence
	// (the pick still applies to the next create this run, just isn't remembered).
	SelectionStore SelectionStore
	Learning       LearningSettings // operator mecatl settings.yaml; nil disables /learning
	// Connect lists public saved remote-target metadata. It cannot authenticate,
	// launch a browser, or expose credentials; selection exits via ConnectRestartIntent.
	Connect ConnectController
	// ConnectOpen reopens /connect after a host-side login/dial failure. ConnectError
	// is host-sanitized display text only.
	ConnectOpen  bool
	ConnectError string
	// ConnectReason controls the auth-recovery affordance without exposing a
	// transport error or credential to the renderer.
	ConnectReason          client.AuthReason
	ConnectTarget          string
	ConnectResumeSessionID string
	// BearerBacked records credential provenance for classifying server auth
	// responses. It contains no credential material.
	BearerBacked bool
	// InitialModel is the persisted selection loaded at launch (composition-side,
	// from the state file). The picker seeds its active selection from it (the ●
	// marker) and the startup CreateSession carries it — AFTER the connect-time
	// ListModels reconcile clears it if its PROVIDER is no longer available. The
	// reconcile is provider-level only (issue #41): a model absent from the (possibly
	// embedded-floor) snapshot is still carried verbatim — the server validates it,
	// and a rejection falls back to the default loudly (connectFallbackMsg).
	InitialModel client.ModelSelection
	// WorkspaceDefault / GlobalDefault are the SEPARATE raw state-file values loaded at
	// launch (composition-side): the per-workspace entry (zero when none — see
	// WorkspaceDefaultSet) and the global `default:` block. They are display-only
	// provenance inputs for the /models picker's "current: <model> (<provenance>)"
	// line and the ★ global-default row marker — the ui derives a best-effort label
	// from client-held state, never a server round-trip. (InitialModel is the RESOLVED
	// Load result = workspace-or-global; these are the un-collapsed pieces.)
	WorkspaceDefault    client.ModelSelection
	WorkspaceDefaultSet bool
	GlobalDefault       client.ModelSelection
	// Clipboard reads the OS clipboard for ctrl+v paste (image-first, text-fallback).
	// nil cleanly disables ctrl+v image paste (same convention as nil MCP/Cmds);
	// main.go populates it with client.NewClipboard().
	Clipboard client.Clipboard
	Theme     theme.Theme
	// ThemeAutoDetect enables the terminal-background light/dark auto-detect
	// (ADR 0280): composition sets it true only when no explicit --theme/
	// MECATUI_THEME was supplied AND stdout is a real TTY (never on redirected
	// output, which must never see the OSC background-colour query). When true,
	// Init requests the terminal's background color (tea.RequestBackgroundColor)
	// and a light response switches the active theme to the built-in "solar"
	// theme; a dark or absent response keeps Theme as given. Explicit theme
	// selection always wins — this field is simply never set true then.
	ThemeAutoDetect bool
	// StatusSource is composed outside ui. The UI only submits display facts and
	// consumes semantic snapshots through one Bubble Tea listener.
	StatusSource statusline.Source

	// ClientBuild is the local mecatui build identity and Embedded selects the
	// local server identity path for /diagnostics.
	ClientBuild string
	Embedded    bool

	// Display-only context for the header bar.
	Server         string
	ConnectionMode string
	Workspace      string
	Mode           string
	Model          string
	// Resume is a statically validated existing chat selected before Bubble Tea
	// starts. Its authoritative transcript is adopted without CreateSession; nil
	// preserves the new-session default.
	Resume *client.ResumeSelection
	// BrowseSessions launches into the same inventory used by /sessions without
	// creating a throwaway session. New-chat creation remains gated on the startup
	// model-list reconcile.
	BrowseSessions bool
	// InitialPrompt is a CLI-supplied seed prompt auto-submitted once the first
	// session is ready (the equivalent of typing the prompt and pressing enter).
	// Empty = today's behavior (no seed). Cleared after the first use so a
	// /models restart or /clear never re-submits it. Populated by main.go from
	// -p/--prompt + --prompt-file.
	InitialPrompt string
	// DebugTarget is immutable launch metadata for a dedicated analysis session.
	// It is presentation/control state only; the client adapter owns wire projection.
	DebugTarget string

	// Version is the mecatui build identity, shown on the first-run welcome splash
	// (e.g. "v0.3.1", "dev+0123456789ab", or "dev"). Threaded from the shared
	// internal/buildinfo.BuildID; "" omits the version line.
	// Display-only.
	Version string

	// NoBanner suppresses the rich first-run welcome splash (mascot + gradient
	// wordmark): the zero-state then renders the LEGACY plain card (title + prompt
	// hint + affordances). Set by --no-banner, --quiet, or a non-interactive stdin
	// (composed in main). Default false (full splash).
	NoBanner bool

	// Ctx is the program-level context; per-run stream contexts derive from it.
	Ctx context.Context //nolint:containedctx // stored to parent per-run stream cancels

	// NoAltScreen disables the alternate screen buffer, rendering inline in the
	// terminal's normal buffer. Default false (full-screen TUI on the alt screen).
	// Set true by the --no-alt-screen/--inline flag — a first-class user opt-out
	// for streaming the session into native scrollback (so it stays
	// searchable/scrollable after exit) — and by golden tests so the final frame
	// persists in the captured output instead of being cleared on exit.
	NoAltScreen bool

	// NoMouse disables mouse capture on the alt screen (View leaves MouseMode at
	// MouseModeNone), so the terminal's OWN click-drag selection works again — at
	// the cost of in-app mouse-wheel scroll and the in-app drag-select/copy layer
	// (selectable() returns false). Keyboard scroll is unaffected. Default false
	// (mouse captured). Set true by --no-mouse / MECATUI_NO_MOUSE=1. Inert under
	// NoAltScreen (mouse is already off inline). The escape hatch for terminals
	// that strip OSC52 or users who prefer native selection.
	NoMouse bool

	// NoWindowTitle suppresses the dynamic terminal window/tab title, leaving the
	// title at the bare "mecatui" (no phase word, no session title). Default
	// false (the title is dynamic: "<title> — <status word> mecatui"). Set true by
	// --terminal-title=off / MECATUI_NO_TERMINAL_TITLE=1 — the escape hatch for
	// terminals/multiplexers where a set title does more harm than good (or where
	// the per-phase churn is unwanted).
	NoWindowTitle bool

	// DebugMouse turns on a footer diagnostic overlay (env MECATUI_DEBUG_MOUSE=1):
	// on every mouse press/motion the footer-left is overridden with the raw mouse
	// coordinates and their content mapping (top=convTopRow, yoff, viewport height,
	// and the screenToContent result) — the durable instrument for diagnosing
	// selection/coordinate issues (it is what surfaced the highlight-on-wrong-line
	// bug). Default OFF (zero cost when unset); main.go reads the env var.
	DebugMouse bool

	// DebugSteer turns on a steer correlation trace in the status line (env
	// MECATUI_DEBUG_STEER=1): each steer ack/echo logs the incoming message_id,
	// the live bundle's id, and the match/burn/drop decision, so a stuck or
	// mis-correlated steer lifecycle is visible in the TUI rather than opaque.
	// Default OFF (zero cost when unset); main.go reads the env var.
	DebugSteer bool

	// DebugAsk registers the /debug-ask built-in (env MECATUI_DEBUG_ASK=1): it
	// injects a fake permission ask with long Bash args through the REAL ask
	// reducer, so the modal's wrap/scroll/full-screen-args behaviour (issue #488)
	// can be exercised by hand without driving a live run. Default OFF (the
	// built-in is absent); main.go reads the env var — deliberately never a flag,
	// so it stays out of --help.
	DebugAsk bool

	// KeyOverrides maps a keyMap field name (e.g. "Agents") to its replacement chord(s).
	// nil = no overrides, byte-identical to today. Resolved+validated in composition.
	KeyOverrides map[string][]string
	// contains filtered or unexported fields
}

type HitID uint64

type LearningSettings interface {
	Advance() (fromLabel, toLabel, restart string, err error)
	AdvanceSensitivity() (fromLabel, toLabel, restart string, err error)
}

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

type SelectionStore interface {
	Save(workspace string, sel client.ModelSelection) error
	SaveGlobalDefault(sel client.ModelSelection) error
}

type ServerInfoGetter interface {
	GetServerInfo(ctx context.Context, providerID string) (client.ServerInfo, error)
}

type SessionCreator interface {
	CreateSession(ctx context.Context, sel client.ModelSelection, mode string) (string, client.Capabilities, client.ResolvedModel, error)
	// CreateSessionInWorkspace creates a session bound to an explicit workspace
	// root (the /worktrees switch path, issue #102). CreateSession (above)
	// delegates to this with the launch workspace, so the /models restart + the
	// connect paths are byte-identical and only the /worktrees switch passes a
	// different root. The workspace becomes the session's tool root (Read/Edit/
	// Write/Grep/Glob/Bash cwd all resolve there); osfs confinement is unchanged.
	CreateSessionInWorkspace(ctx context.Context, workspace string, sel client.ModelSelection, mode string) (string, client.Capabilities, client.ResolvedModel, error)
	// CreateSessionWithCarryover is CreateSession seeded with sourceSessionID's
	// conversation history (issue #20, model-switch carryover): it restarts on a
	// picked model AND carries the current session's transcript onto the new
	// session. The server is the authority on same-vs-cross (a same-provider
	// carryover replays verbatim; a cross-provider carryover strips the prior
	// provider's replay blobs) and a turn-boundary source; the ui offers the
	// switch unconditionally when a live session exists. The caller owns closing
	// the source session AFTER the new one is ready (the server snapshotted it
	// at create time). Same return shape as CreateSession so the
	// footer/effective-model heal path is shared.
	CreateSessionWithCarryover(ctx context.Context, sourceSessionID string, sel client.ModelSelection, mode string) (string, client.Capabilities, client.ResolvedModel, error)
	// CloseSession ends a server-side session by id. The /models restart-now handoff
	// closes the OLD session before creating the new one so a model switch leaves no
	// orphaned server-side session. Best-effort: the caller proceeds with the new
	// create even if the close errors.
	CloseSession(ctx context.Context, id string) error
	// GetSession re-reads the EFFECTIVE resolved model for an existing session. The
	// footer context-meter heal (issue #66) fires it on a turn boundary while the
	// meter's denominator is still unknown — the create-time echo can carry a 0 /
	// curated-floor window for a session on a LIVE-ONLY model whose async live
	// model-list swap had not yet landed, and the server's ResolvedModel resolves to
	// the real live window once it has. SessionCreator is the canonical ui-injection
	// seam for it (the method also satisfies the narrower client.SessionGetter that
	// RefreshResolvedModelCmd consumes); *client.Client (via the sessionAdapter) and
	// the test fakes satisfy both.
	GetSession(ctx context.Context, id string) (client.SessionSnapshot, error)
	// SetMode asks the server to change the current session's permission mode and
	// returns the server-confirmed mode. Mid-turn attempts may be rejected; the ui
	// defers and retries at the next prompt boundary.
	SetMode(ctx context.Context, id, mode string) (string, error)
	// ForkSession creates a peer session from srcID's conversation-history snapshot
	// (ADR 0065) with an OPTIONAL reasoning-effort override (ADR 0068; empty
	// inherits the source's) and returns the new session id. The /effort fork-resume
	// handoff uses it: the transcript SURVIVES the effort switch because the fork
	// carries it (title is omitted — the fork inherits the source's title; provider
	// and model ALWAYS inherit). The caller owns closing the source session and the
	// GetSession refetch for the fork's resolved-model echo.
	ForkSession(ctx context.Context, srcID, reasoningEffort string) (string, error)
}