tui

func (*App) ActiveStore ¶

func (a *App) ActiveStore() *sessions.Store

ActiveStore returns the session store the app is currently recording into, reflecting any /clear swap. It may be nil before SetActiveStore is called.

func (*App) AddBlockedPathForTest ¶

func (a *App) AddBlockedPathForTest(path string) bool

func (*App) AnswerQuestionCustomForTest ¶

func (a *App) AnswerQuestionCustomForTest(question int, text string) bool

func (*App) AnswerQuestionForTest ¶

func (a *App) AnswerQuestionForTest(question, option int) bool

func (*App) Append ¶

func (a *App) Append(line string)

Append adds one line to the transcript pane, escaping it so any "[...]" in the text renders literally rather than being parsed as a tview style tag now that the transcript has dynamic colors enabled. All ordinary callers (command output, model-picker disclosure) go through here; the launch banner is the one intentional styled producer and uses AppendBanner instead.

func (*App) AppendBanner ¶

func (a *App) AppendBanner(lines ...string)

AppendBanner adds the launch banner as one multi-line transcript block through the raw styled-append seam (AppendStyled): the banner's intentional tags are parsed by dynamic colors — the teal-filled name bar's "[fg:bg:b]…[-:-:-]" fill (LaunchBannerBar) and any styling on the remaining lines. The banner's display lines are joined with a single newline and committed as one entry so they stay adjacent — the transcript's block separator (one blank line) is inserted only between entries, never inside this one, keeping the banner a tight header. Used by the bootstrap banner (StartTUI and /clear's transcript reset).

func (*App) AppendCompletionFooter ¶

func (a *App) AppendCompletionFooter(records []sessions.Record)

AppendCompletionFooter appends the "provider - model - duration" footer for the most recently completed successful turn in records, taking provider/model from the turn's model_turn event and the duration from its final turn_latency event. It is a no-op when the latest turn produced no visible assistant reply or is missing either durable record — interrupted, failed, and tool-call-only turns show no footer. The turn controller calls it off the tview event-loop goroutine after a natural completion, so it marshals through the tview queue like the other stream-surface methods; the FinalizeStream that committed the reply is queued first, so the footer lands directly after it. The footer is a transcript-only metadata block: it is never recorded, so it cannot become model input or a durable user/assistant message.

func (*App) AppendEditPatch ¶

func (a *App) AppendEditPatch(patch string)

func (*App) AppendStreamDelta ¶

func (a *App) AppendStreamDelta(delta string)

AppendStreamDelta accumulates one incremental chunk of the in-progress assistant reply. While Run is active the mutation is marshaled through the tview queue without a draw and a single timer renders the accumulated text; before Run it renders on arrival. It returns once the delta has been applied but, unlike the per-delta render it replaces, not once it has been drawn. Like PromptUser it must not be called from a tview event-loop callback while the loop is running.

func (*App) AppendStyled ¶

func (a *App) AppendStyled(line string)

AppendStyled adds one pre-styled line to the transcript without escaping, so intentional tview style/color tags are parsed by dynamic colors — e.g. the launch banner's "[::b]…[::-]" bold. (Mode switches no longer append here: their colored hint renders into the persistent mode-hint row instead.) It is the single raw append seam: callers must pass only controlled, non-user text (a closed set of literals), since nothing here escapes "[...]" against style-tag injection; every other transcript string is escaped via Append.

func (*App) AppendToolActivity ¶

func (a *App) AppendToolActivity(lines []string)

AppendToolActivity renders one tool-call round's about-to-run calls inline in the transcript, just before the calls are dispatched, so a multi-step turn shows what is about to run (e.g. "Edit path", "Run: go build") instead of going silent. It first finalizes any in-progress assistant reply so the model's pre-tool text commits above the activity block, then appends the escaped lines as one transcript entry. Like the other stream-surface methods it is the cross-package entry point the provider-turn runtime calls off the tview event-loop goroutine, so it marshals through streamUpdate while Run is active and mutates directly before Run. Tool activity is display-only and never recorded.

func (*App) ApplyInputAccent ¶

func (a *App) ApplyInputAccent(color tcell.Color)

ApplyInputAccent recolors the input's prompt glyph and both horizontal rules to a run-scoped accent and requests a redraw so the change is visible immediately. The accent lives only on the input field for the running session — nothing is persisted and it is not carried across --resume. Global tview.Styles and every surface outside the input area are left untouched. The /color command drives this after resolving a palette name to color.

func (*App) AskClarificationForTest ¶

func (a *App) AskClarificationForTest(text string) bool

func (*App) AskQuestions ¶

func (a *App) AskQuestions(ctx context.Context, req QuestionRequest) (QuestionResult, error)

Must not be called from a tview event-loop callback.

func (*App) AwaitQuestionFormForTest ¶

func (a *App) AwaitQuestionFormForTest(timeout time.Duration) bool

func (*App) BeginShutdown ¶

func (a *App) BeginShutdown()

BeginShutdown latches the discard-pending-renders state Stop latches, without ending the event loop. The exit sequence calls it before it cancels and drains the in-flight turn: that drain runs on the event-loop goroutine, so the surface calls a cancelled turn makes on its way out (the held-partial flush and interrupt seal) have to be dropped rather than queued, or the drain and the turn deadlock on each other. The dropped mutations are view-only — the turn's durable records still land on the store, which is what the drain exists to order before the final flush.

func (*App) BlockedOverlayText ¶

func (a *App) BlockedOverlayText() string

func (*App) ChildAgentCalls ¶

func (a *App) ChildAgentCalls(invocation string, lines []string)

func (*App) ChildAgentEnded ¶

func (a *App) ChildAgentEnded(end events.ChildAgentEnd)

func (*App) ChildAgentStarted ¶

func (a *App) ChildAgentStarted(start events.ChildAgentStart)

ChildAgentStarted, ChildAgentCalls, and ChildAgentEnded are the live child-agent surface the delegate tool drives from the child's own goroutine, so — like AppendToolActivity — they marshal through streamUpdate while Run is active and mutate directly before it. The block is display-only: the durable record is the child_agent_start/end pair the delegate already appends.

func (*App) ChooseBlockedDestinationForTest ¶

func (a *App) ChooseBlockedDestinationForTest(dest BlockedDestination) bool

func (*App) ClearIndicator ¶

func (a *App) ClearIndicator()

ClearIndicator hides the in-flight line and stops its elapsed ticker. The turn controller calls it off the event-loop goroutine when the loop returns — covering natural completion, a mid-stream drop, a user interrupt, and a background failure alike — so the teardown marshals through the tview queue. It is idempotent: a second call (or one with no indicator showing) is a no-op, so the stop channel is closed at most once and a stale ticker tick that lost the generation race cannot redraw.

func (*App) ClearNotice ¶

func (a *App) ClearNotice()

ClearNotice clears the one-line transient notice without touching committed transcript history. submitCurrent calls it as a new submission is accepted, and the model-change paths (the CTRL-M/picker confirm and /model) call it on a successful apply, so a prior turn's notice cannot linger pinned below later output. It is for callers on the tview event-loop goroutine (like Notice); it never affects committed lines (t.lines).

func (*App) CommitProviderError ¶

func (a *App) CommitProviderError(text string)

CommitProviderError commits a provider/turn request failure as a permanent in-place transcript line (escaped) tied to the turn that produced it, so the error scrolls with history rather than re-pinning below later turns the way the single bottom notice did. The provider-turn runtime calls it off the tview event-loop goroutine, so it marshals through the tview queue while Run is active and mutates directly before Run — exactly like AppendStreamDelta, FinalizeStream, and NoticeFromBackground. Ordering is preserved automatically: committing appends after whatever finalize/markInterrupted already sealed (a pre-stream failure lands after the submitted prompt; a post-seal failure after the sealed turn output).

func (*App) CommitRetryRecovered ¶

func (a *App) CommitRetryRecovered(retries int)

CommitRetryRecovered commits a faint transcript breadcrumb after an auto-retry succeeds, so the user can see that a transient provider hiccup recovered without reading provider_request_retry events. It is called off the event-loop goroutine.

func (*App) ConfirmModelRowForTest ¶

func (a *App) ConfirmModelRowForTest(row ProviderModel, effort string)

ConfirmModelRowForTest runs Enter-on-a-row for row without the overlay, so a cross-package test can drive the CTRL-M confirm path over production deps the way SelectConnectProviderForTest drives /connect. Production reaches confirmModelSelection through the key path.

func (*App) ConnectPickerOpen ¶

func (a *App) ConnectPickerOpen() bool

ConnectPickerOpen reports whether the connect provider picker is currently mounted. It is a cross-package test seam for production /connect wiring.

func (*App) ConnectPickerRows ¶

func (a *App) ConnectPickerRows() []ConnectProviderOption

ConnectPickerRows returns the currently mounted connect picker rows, or nil when the picker is closed. It is a cross-package test seam for production /connect wiring.

func (*App) DiscardHeldPrompts ¶

func (a *App) DiscardHeldPrompts()

func (*App) EffortPickerOpen ¶

func (a *App) EffortPickerOpen() bool

EffortPickerOpen reports whether the effort picker overlay is currently mounted. It mirrors ModelPickerOpen as the observable bootstrap's StartTUI assembly test reads to prove a bare /effort opened the picker through the wired EffortDeps.OpenPicker; production code drives the picker through the key/command paths and never needs to poll this.

func (*App) EnqueuePrompt ¶

func (a *App) EnqueuePrompt(text string, parts ...sessions.ContentPart)

func (*App) FilePickerOpen ¶

func (a *App) FilePickerOpen() bool

FilePickerOpen reports whether the file-reference picker overlay is currently mounted. It mirrors EffortPickerOpen/ModelPickerOpen as the observable a simulation test reads to prove a typed '@' opened (or a paste did not open) the picker; production drives it through the change hook and key paths and never polls this.

func (*App) FinalizeStream ¶

func (a *App) FinalizeStream()

FinalizeStream closes a naturally completed streamed assistant reply, committing the in-progress line into the transcript (a no-op when no reply is streaming) so the next streamed reply starts a fresh buffer instead of merging onto the completed one. It is the cross-package finalizer the provider-turn runtime calls when a turn ends without cancellation, and like AppendStreamDelta it marshals through the tview queue while Run is active and so must be driven off the event-loop goroutine.

func (*App) FlushActive ¶

func (a *App) FlushActive() error

FlushActive satisfies CommandHost: it runs the injected command-event flush hook so a /status, /help, or placeholder command makes its slash_command record durable. With no hook installed (unit tests) it is a no-op.

func (*App) HandleCtrlC ¶

func (a *App) HandleCtrlC()

HandleCtrlC applies the priority order, top to bottom:

1. If a stream is in flight, stop it via the ESC handler's source-parameterized path with source "ctrl-c" (retained content marked interrupted, stream_interrupted

appended, flush). It does not clear input or exit.

2. Else if the input buffer is non-empty, clear it (and any pending exit hint).
3. Else if a prior empty-buffer CTRL-C was within ctrlCExitWindow, exit via the /exit clean-shutdown path (the bare "exit" synonym through the submit hook),

so the canonical slash_command{name:"exit"} record, the flush, the hint / exit-0, and the second-failure exit-1 all come from

   /exit rather than being duplicated here.
4. Else show the "press Ctrl-C again to exit" hint and arm the window.

"Empty" is the literal buffer (GetText() == ""); a whitespace-only buffer counts as non-empty and takes step 2, so CTRL-C never exits over text the user can see.

func (*App) HandleCtrlD ¶

func (a *App) HandleCtrlD()

HandleCtrlD applies the CTRL-D shortcut. On an empty input buffer it exits via the clean-shutdown path by dispatching the bare `exit` synonym through the installed submit hook, so the canonical slash_command{name:"exit", args:[], outcome:"success"} record and the rest of the /exit sequence (clean-shutdown flush, resume hint on success, second-failure exit-1) come from the /exit handler rather than being duplicated here. On a non-empty buffer it does nothing: the typed text is left untouched and no event, flush, notice, or shutdown request occurs.

"Empty" is the literal buffer (GetText() == ""); a whitespace-only buffer counts as non-empty and is a no-op, so CTRL-D never exits over text the user can still see. With no submit hook installed (New(nil) and unit tests before SetSubmit) the empty-buffer path is inert — there is nothing to dispatch through.

func (*App) HandleEsc ¶

func (a *App) HandleEsc()

An open overlay owns ESC ahead of stream interruption: it is the modal the user is looking at, and it blocks the very turn ESC would otherwise cancel.

func (*App) HasQueuedPrompt ¶

func (a *App) HasQueuedPrompt() bool

func (*App) IndicatorTokens ¶

func (a *App) IndicatorTokens() (input, output int64)

IndicatorTokens returns the running uploaded (input) and downloaded (output) token figures the indicator is tracking. It is a cross-package test seam (like IndicatorVisible): bootstrap's production-path turn test reads it mid-turn to prove the figures advance from each round's exact Usage (not streamed deltas) and settle on the totals /status reports. Production updates them through SetIndicatorTokens off the live event loop; this is never called at runtime.

func (*App) IndicatorVisible ¶

func (a *App) IndicatorVisible() bool

IndicatorVisible reports whether the in-flight indicator is currently showing. The before-draw chrome-row budget (chromeRows) reads it to subtract the indicator row from the transcript height only while a turn streams. It is also a cross-package test seam (like StatusText): bootstrap's production-path turn test asserts the indicator appears during a real turn and is cleared after it, which the durable events alone cannot show. The read is guarded by indicatorMu because the elapsed-refresh ticker goroutine also touches the indicator state.

func (*App) InputText ¶

func (a *App) InputText() string

InputText returns the current input-buffer text. It is a cross-package test seam (like SubmitInput) that lets bootstrap's StartTUI integration test read the buffer back — e.g. to confirm CTRL-C cleared a non-empty buffer (step 2). Production reads the buffer through the focused input field off the live event loop; this is never called at runtime.

func (*App) MarkStreamInterrupted ¶

func (a *App) MarkStreamInterrupted()

MarkStreamInterrupted closes the in-progress assistant reply with the interrupted marker (a no-op when no reply is streaming), so a cancelled stream is sealed as interrupted. It is the cross-package finalizer the provider-turn runtime calls when it observes the cancellation, and like AppendStreamDelta it marshals through the tview queue while Run is active and so must be driven off the event-loop goroutine. It also hides the in-flight indicator on the same off-loop path (idempotent with the turnController.run backstop) so the indicator never outlives the sealed stream.

func (*App) MarkStreamInterruptedFromCommand ¶

func (a *App) MarkStreamInterruptedFromCommand()

MarkStreamInterruptedFromCommand seals a slash-command-cancelled stream from a command handler that is already running on the tview event-loop goroutine, and hides the in-flight indicator on that same loop path so /clear and /resume drop the indicator as soon as they record the interruption.

func (*App) ModeHintText ¶

func (a *App) ModeHintText() string

ModeHintText returns the footer's second-row text (the filled "• <mode>" pill plus the shift+tab hint), with tview color tags stripped (GetText(true)). It is a cross-package read-only test seam (like StatusLineText): bootstrap's StartTUI assembly test reads it back after driving a mode switch through the production Notify path, proving the pill reflects the active mode rather than the transcript carrying the confirmation. It is the second footer row, distinct from StatusLineText's segments. Production renders the row through the view off the live event loop; this is never called at runtime.

func (*App) ModelPickerOpen ¶

func (a *App) ModelPickerOpen() bool

ModelPickerOpen reports whether the model picker overlay is currently mounted. It is the observable bootstrap's StartTUI assembly test reads to prove the launch picker-required outcome opened the picker through OpenModelPicker; production code drives the picker through the key path and never needs to poll this.

func (*App) ModelPickerRows ¶

func (a *App) ModelPickerRows() []ProviderModel

ModelPickerRows returns the provider×model rows the CTRL-M picker is currently displaying. While the overlay is open it reads the live session rows — the same slice rebuildModelPickerFromCatalog refreshes — so a test observes the visible overlay state, not just the underlying cache; a refresh that reloads the cache without rebuilding the session leaves this stale, which is the assertion the StartTUI refresh test relies on. When no picker session is open it falls back to the live selectable catalog (the list openModelPicker would build from). It returns nil when the provider-aware deps are not yet wired. Production drives the picker through the key path and never polls this.

func (*App) ModelPickerStatusText ¶

func (a *App) ModelPickerStatusText() string

ModelPickerStatusText returns the open picker's in-box refresh status row, or "" when no picker is open. Like ModelPickerRows it is a read-only cross-package test seam; production writes the row and never polls it.

func (*App) Notice ¶

func (a *App) Notice(text string)

Notice shows a one-line user-facing notice beneath the transcript. It is for callers already running on the tview event-loop goroutine; off-loop callers must use NoticeFromBackground.

func (*App) NoticeFromBackground ¶

func (a *App) NoticeFromBackground(text string)

NoticeFromBackground shows a one-line notice from an off-event-loop caller, marshaling the transcript mutation through the tview queue while Run is active.

func (*App) NoticeSeq ¶

func (a *App) NoticeSeq() uint64

NoticeSeq returns the count of notices emitted so far. The model-change paths read it around their apply to tell a notice the apply emitted from a stale pre-apply one.

func (*App) NoticeText ¶

func (a *App) NoticeText() string

NoticeText returns the current one-line transient notice, or "" if none. The ESC key path reads it at runtime to tell its own interrupt hint from any other notice, and it is also the cross-package read-only seam (like TranscriptText) bootstrap's StartTUI assembly test reads.

func (*App) OpenConnectPicker ¶

func (a *App) OpenConnectPicker(options []ConnectProviderOption, onSelect func(id string))

OpenConnectPicker opens the provider picker for a bare /connect command. It is a no-op while another overlay is open or when there are no rows to show. Selecting a provider calls onSelect with the provider id after the overlay is dismissed.

func (*App) OpenEffortPicker ¶

func (a *App) OpenEffortPicker()

OpenEffortPicker opens the effort picker overlay from outside the global CTRL-E key path — the narrow seam a bare /effort drives through EffortDeps.OpenPicker so the command and the key share one picker. It delegates to openEffortPicker so the overlay-open / no-deps / no-model guards stay the single implementation, and is therefore inert until SetEffortDeps installs the deps, exactly like CTRL-E.

func (*App) OpenModelPicker ¶

func (a *App) OpenModelPicker()

OpenModelPicker opens the provider-aware model picker overlay from outside the global CTRL-M key path. It is the narrow seam bootstrap drives for the two non-keyboard routes into the picker: the path-4 launch outcome and an in-TUI /resume recovery failure. It delegates to openModelPicker so the overlay/no-deps guards stay the single implementation — it is therefore inert until the model-picker deps are installed, exactly like CTRL-M.

func (*App) OpenSecretPrompt ¶

func (a *App) OpenSecretPrompt(req SecretPromptRequest)

OpenSecretPrompt mounts the masked secret prompt as a modal overlay and moves focus to its field so typing, Enter (submit), and ESC/Ctrl-C (cancel) drive it. It is a no-op while another overlay is open, so a caller cannot stack it over an existing modal. The typed text lands only in the overlay's own masked field; the app's main input buffer, notices, transcript, history, and session events are never touched.

func (*App) PressCtrlE ¶

func (a *App) PressCtrlE() bool

PressCtrlE drives the app-level CTRL-E global-key capture as if the key were pressed and reports whether the effort picker overlay opened. It is a cross-package test seam (like SubmitInput): bootstrap's StartTUI assembly test uses it to prove the production wiring installed the effort picker deps via SetEffortDeps — without them effortDeps.Model is nil and CTRL-E stays inert, so this returns false. Production CTRL-E always flows through handleGlobalKey off the live event loop; this is never called at runtime.

func (*App) PressCtrlM ¶

func (a *App) PressCtrlM() bool

PressCtrlM drives the app-level CTRL-M global-key capture as if the key were pressed and reports whether the model picker overlay opened. It mirrors PressCtrlE: without the provider-aware deps wired, modelPickerDeps.Catalog is nil and CTRL-M stays inert, so this returns false. Production CTRL-M always flows through handleGlobalKey off the live event loop; this is never called at runtime.

func (*App) PressCtrlV ¶

func (a *App) PressCtrlV() bool

PressCtrlV drives the app-level CTRL-V global-key capture as if the key were pressed and reports whether a pending image attachment resulted. It is a cross-package test seam (like PressCtrlE): bootstrap's StartTUI assembly test uses it to prove the production wiring reads the injected clipboard reader and stages an attachment. Production CTRL-V always flows through handleGlobalKey off the live event loop; this is never called at runtime.

func (*App) PressTab ¶

func (a *App) PressTab(input string) (text, notice string)

PressTab sets input as the buffer (cursor parked at the end, as SetText does) and drives a Tab keypress through the input field's real handler — the same SetInputCapture → handleInputKey → completeName path the live event loop runs — then returns the resulting buffer text and the one-line notice (the multi-match candidate list, when Tab listed rather than completed). It is a cross-package test seam (like SubmitInput): bootstrap's StartTUI assembly test uses it to prove the production wiring installed the command registry via SetRegistry — without it App.registry is nil and Tab completion is inert, so the buffer comes back unchanged. Production Tab always flows through handleInputKey off the live event loop; this is never called at runtime.

func (*App) PromptIndependent ¶

func (a *App) PromptIndependent(reqs []PromptRequest) ([]PromptDecision, error)

PromptIndependent walks one authorization group's approval questions and returns one decision per request, index-aligned with reqs. The window opens once and closes once — each question replaces the previous one in place — so the group has one visible prompt owner while every question still gets its own attributable choice. Each screen shows only the question it is deciding. A group of one question is the ordinary single prompt.

func (*App) PromptUser ¶

func (a *App) PromptUser(req PromptRequest) (PromptDecision, error)

PromptUser presents the permission prompt as a modal overlay on the running app shell and blocks until the user picks an option, then dismisses the overlay and restores the prior focus, leaving the transcript and input buffer untouched. It is invoked from permission orchestration off the tview event-loop goroutine, so it drives the UI through QueueUpdateDraw and must not be called from a tview callback.

func (*App) QuestionContextForTest ¶

func (a *App) QuestionContextForTest() string

func (*App) QuestionFormOpen ¶

func (a *App) QuestionFormOpen() bool

func (*App) RefreshModeHint ¶

func (a *App) RefreshModeHint(modeKey string)

RefreshModeHint records modeKey as the active interaction mode and re-renders the footer's second row (statusModeRow) so its filled "• <mode>" pill — followed by the shift+tab hint — reflects it (the pill has its own row, folding in the mode-hint row). It is seeded at launch from the active mode and called on every switch through the shared ModeDeps.Notify seam, so the row always shows the current mode and a switch no longer appends a confirmation line to the transcript. Callers run on the tview event-loop goroutine (the pre-Run seed and the Notify callback the key/command paths drive), so the text is set directly without marshaling through the event queue.

func (*App) RefreshSessionBadge ¶

func (a *App) RefreshSessionBadge(store *sessions.Store)

RefreshSessionBadge shows store's title in the badge only while store is the active store, and is safe to call off the event loop.

func (*App) RefreshStatusLine ¶

func (a *App) RefreshStatusLine()

RefreshStatusLine re-renders the footer's first row (statusBar) from the current active selection: the filled two-tone provider/model/effort/dir segments (RenderStatusLine), so the segments live-update after a model or effort change. The mode pill lives on the second row and is refreshed separately by RefreshModeHint, so this never touches it. With no StatusState installed (unit tests) it renders the row empty. Callers run on the tview event-loop goroutine (the model/effort apply paths and the pre-Run seed), so the text is set directly without marshaling through the event queue.

func (*App) RefreshStatusLineFromBackground ¶

func (a *App) RefreshStatusLineFromBackground()

func (*App) RemoveBlockedPathForTest ¶

func (a *App) RemoveBlockedPathForTest(path string) bool

func (*App) ReplaySessionRecords ¶

func (a *App) ReplaySessionRecords(records []sessions.Record)

ReplaySessionRecords re-renders a resumed session's prior conversation into the transcript so /resume does not land on an empty-looking pane. Both entry points call it on the tview event-loop goroutine (cold-start before Run, or the in-TUI /resume continuation), so it mutates the pane directly rather than marshaling through the event queue; the projection and bounding rules live on replaySessionBlocks.

func (*App) ResetTranscript ¶

func (a *App) ResetTranscript()

ResetTranscript wipes the transcript pane — committed lines, any in-progress streamed line, and the notice — re-renders it empty, and suppresses the single accepted-submit echo submitCurrent would otherwise append for the command that triggered the reset. /clear calls it (through the injected ClearDeps.Transcript capability) after the session swap commits, so the fresh same-folder session opens on a blank pane instead of the prior conversation and without a leftover "> /clear" line (visible-screen reset). It is called from the command handler, which runs on the tview event-loop goroutine, so it mutates the view directly like MarkStreamInterruptedFromCommand rather than marshaling through QueueUpdateDraw (which would deadlock the loop from inside a handler).

func (*App) ResumeRetry ¶

func (a *App) ResumeRetry()

ResumeRetry returns the in-flight indicator to the normal Working state after a retry backoff completes and before the provider round is re-issued. It clears any idle state stored during the failed attempt rather than restoring it, so resume lands on clean Working copy.

func (*App) RevokeHighlightedPermissionForTest ¶

func (a *App) RevokeHighlightedPermissionForTest() bool

RevokeHighlightedPermissionForTest revokes the highlighted grant exactly as the confirm's Revoke button does — a seam for bootstrap tests that drive the real revoke without a terminal. It returns false when the overlay is closed or the highlighted row backs no grant.

func (*App) RollbackPartial ¶

func (a *App) RollbackPartial()

RollbackPartial removes the un-sealed in-progress reply before a discard-and-restart retry of a partial stream_drop, so the regenerated answer does not stack on the discarded partial. It is the cross-package surface seam the provider-turn runtime calls off the tview event-loop goroutine before re-issuing (turndeps.go binds it onto turn.Deps).

func (*App) Run ¶

func (a *App) Run() error

Run starts the tview event loop and blocks until the application stops. It is the bootstrap handoff entrypoint a later task wires into the fresh-launch flow. While it runs, the streaming surface marshals off-loop transcript mutations through the tview queue; running tracks that window so the same methods mutate directly before Run and in unit tests.

func (*App) RunBackgroundAfterDraw ¶

func (a *App) RunBackgroundAfterDraw(work func() error, complete func(error))

func (*App) RunOnEventLoopForTest ¶

func (a *App) RunOnEventLoopForTest(fn func())

RunOnEventLoopForTest runs fn on the tview event-loop goroutine and waits for the redraw, so a test driving a running app can touch shared tview state without racing the draw loop. Test-only; it deadlocks if called from the loop goroutine.

func (*App) SecretPromptOpen ¶

func (a *App) SecretPromptOpen() bool

SecretPromptOpen reports whether the masked secret prompt is currently mounted. It lets an out-of-package test assert a command opened the prompt (rather than completing synchronously) without reaching the unexported overlay state.

func (*App) SecurityHalt ¶

func (a *App) SecurityHalt(records []events.SecurityStateHalted)

SecurityHalt seals any partial reply as interrupted output and pins the persistent protected-settings halt element beneath the transcript. Like MarkStreamInterrupted it must be driven off the event-loop goroutine; unlike it, the seal records nothing, so a security halt never writes a stream_interrupted event.

func (*App) SeedInput ¶

func (a *App) SeedInput(text string)

SeedInput sets the input buffer to text without submitting it, the way typing (without Enter) would leave the field. It is a cross-package test seam (like SubmitInput): bootstrap's StartTUI integration test seeds a non-empty buffer to prove the production CTRL-C path clears it (step 2) — no existing seam can set the buffer without also submitting. Production input is always typed into the field off the live event loop; this is never called at runtime.

func (*App) SeedNextIndicatorStart ¶

func (a *App) SeedNextIndicatorStart(start time.Time)

SeedNextIndicatorStart seeds the elapsed clock the next ShowIndicator uses with a production turn's submit-start — the instant the user's input was accepted — so the indicator's final visible elapsed matches the turn-latency measured from the same instant. A zero start leaves ShowIndicator on its default dispatch-start basis. The seed is consumed by the next ShowIndicator and applies to that turn only. The turn controller calls it on the tview event-loop goroutine at dispatch, so it sets the field directly under indicatorMu like the other indicator mutators.

func (*App) SelectConnectProviderForTest ¶

func (a *App) SelectConnectProviderForTest(id string) bool

SelectConnectProviderForTest confirms the currently mounted provider row with id. It is a cross-package test seam for production /connect wiring.

func (*App) SelectPermissionForTest ¶

func (a *App) SelectPermissionForTest(entry permissions.PermissionEntry) bool

func (*App) SendingPrompt ¶

func (a *App) SendingPrompt(text string, parts ...sessions.ContentPart)

func (*App) SessionBadgeText ¶

func (a *App) SessionBadgeText() string

func (*App) SetActiveStore ¶

func (a *App) SetActiveStore(s *sessions.Store)

SetActiveStore installs s as the session the app records into. The production bootstrap sets it once before Run, and /clear's session swap (SessionSwapper) replaces it with the fresh same-folder store so subsequent commands and the exit hint observe the new session.

func (*App) SetClipboardReader ¶

func (a *App) SetClipboardReader(r clipboardReader)

SetClipboardReader installs the OS-clipboard image reader the CTRL-V action reads through, replacing the default platform-helper reader New installs. It is a cross-package test seam: bootstrap's StartTUI integration test injects a fake that returns fixed image bytes so the real CTRL-V → attach → submit → persist → provider path can run without an OS clipboard or a helper binary. Production installs the default reader in New; this is never called at runtime.

func (*App) SetCommandFlush ¶

func (a *App) SetCommandFlush(fn func() error)

SetCommandFlush installs the command-event flush hook bootstrap builds over the active session + sessionfailures. It is set once before Run, alongside SetActiveStore and SetSubmit.

func (*App) SetEffortDeps ¶

func (a *App) SetEffortDeps(d EffortDeps)

SetEffortDeps installs the effort surface the CTRL-E picker reads and applies through. The production wiring supplies the implementations bound to the running app + bootstrap result; with none set the picker stays inert. It is set once before Run, alongside the other injected hooks.

func (*App) SetFollowupDebugContext ¶

func (a *App) SetFollowupDebugContext(provider, model, mode string)

SetFollowupDebugContext arms the development-only suggest_followup trace for the next turn, stamping provider/model/mode onto the TUI-side debug events. The turn controller calls it at dispatch — only when the dev-debug gate is on, on the event-loop goroutine — so the surface/ghost/accept/clear seams can record which selection produced a suggestion. Until armed the seams emit nothing.

func (*App) SetHome ¶

func (a *App) SetHome(home string)

SetHome installs the bootstrap-resolved home directory the file-reference picker uses to locate the global ~/.codemeld/global/codemeldignore file. Production wiring (StartTUI) passes BootstrapResult.Home; with none installed the '@' trigger stays inert, so App can be constructed in unit tests without bootstrap state. Set once before Run.

func (*App) SetIndicatorTokens ¶

func (a *App) SetIndicatorTokens(input, output int64)

SetIndicatorTokens updates the running uploaded (input) and downloaded (output) token figures and redraws the line. The turn controller calls it off the event-loop goroutine (from the runner's exact per-round Usage callback only; the streamed progress signal is not wired in), so the redraw marshals through the tview queue. It is a no-op once the indicator is cleared, so a late callback cannot resurrect a hidden line.

func (*App) SetMaxPriceForTest ¶

func (a *App) SetMaxPriceForTest(prompt, completion string) string

func (*App) SetModeDeps ¶

func (a *App) SetModeDeps(d ModeDeps)

SetModeDeps installs the mode-switch surface the shift+tab cycle key reads and applies through. The production wiring supplies the implementation bound to the run-scoped mode state + running app — the same ModeDeps BuildRegistry binds to the /mode command — so both surfaces switch through one seam. With none set the key stays inert. It is set once before Run, alongside the other injected hooks.

func (*App) SetModelPickerDeps ¶

func (a *App) SetModelPickerDeps(d ModelPickerDeps)

SetModelPickerDeps installs the provider-aware surface the CTRL-M model picker reads and applies through. The production wiring supplies the implementations bound to the running app + bootstrap result; with none set the picker stays inert. It is set once before Run, alongside the other injected hooks.

func (*App) SetProviderIdle ¶

func (a *App) SetProviderIdle(displayName string, idle time.Duration)

SetProviderIdle switches the in-flight indicator into the idle-waiting state, replacing the generic Working copy with provider-specific waiting text whose timer counts the provider stream's idle duration (time since its last activity), not the turn elapsed. idle is that elapsed time since the provider's last activity; the idle line starts at that value and advances from it on each redraw. Retry outranks idle, so a call during a retry backoff is stored but not rendered until the retry resumes/clears. Safe to call from off the event-loop goroutine; it is a no-op after clear so a late idle callback cannot resurrect a hidden line.

func (*App) SetRegistry ¶

func (a *App) SetRegistry(r *Registry)

SetRegistry installs the command registry Tab name-completion matches against — the same registry the submit adapter dispatches through, so Tab completes exactly the commands /help would list. The production wiring sets it once before Run, alongside SetSubmit; with none installed Tab completion is inert (unit tests, and before injection).

func (*App) SetRetentionForTest ¶

func (a *App) SetRetentionForTest(text string, confirm bool) string

func (*App) SetScreenFactoryForTest ¶

func (a *App) SetScreenFactoryForTest(factory func() (tcell.Screen, error))

SetScreenFactoryForTest replaces the screen constructor Run uses, so a test can start the real app lifecycle against a simulation screen instead of a terminal. Test-only; it must be called before Run.

func (*App) SetStatusLineState ¶

func (a *App) SetStatusLineState(s StatusState)

SetStatusLineState installs the StatusState the bottom bar's segments render from and seeds the bar immediately. The production wiring passes the same statusState object /status and the launch banner read, so the three never drift. With none installed RefreshStatusLine renders nothing, so unit tests can construct App without bootstrap state. It is set once before Run.

func (*App) SetStreamCanceller ¶

func (a *App) SetStreamCanceller(c StreamCanceller)

SetStreamCanceller installs the provider-turn cancellation handle the ESC / CTRL-C handlers reach to abort an in-flight streamed reply. The production handle is injected by the turn wiring; with none installed StreamCanceller returns nil and the surface stays inert (nothing to cancel). It is set once before Run, alongside the other injected hooks.

func (*App) SetSubmit ¶

func (a *App) SetSubmit(s SubmitFunc)

SetSubmit installs the dispatch-backed submit hook after construction. The production submit adapter is the app's own CommandHost-backed dispatcher, so it cannot be built until New has returned the app; bootstrap calls New(nil) then SetSubmit to close that construction cycle without changing New's signature.

func (*App) SettingsOverlayText ¶

func (a *App) SettingsOverlayText() string

SettingsOverlayText is a cross-package test seam for bootstrap's StartTUI assembly tests; it is never called at runtime.

func (*App) ShowIndicator ¶

func (a *App) ShowIndicator(input, output int64)

ShowIndicator reveals the in-flight activity line with input/output as its starting token figures, records the turn start for the elapsed timer, and launches the refresh ticker. It runs on the tview event-loop goroutine, so it renders the line directly — routing through QueueUpdateDraw from that loop would deadlock; ClearIndicator is the teardown.

func (*App) ShowPanel ¶

func (a *App) ShowPanel(text string)

ShowPanel opens the modal text panel over the main layout, moving focus to it so it captures input while open. It satisfies the CommandHost panel surface used by the /help handler.

func (*App) ShowRetryBackoff ¶

func (a *App) ShowRetryBackoff(nextAttempt, totalAttempts int)

ShowRetryBackoff switches the in-flight indicator into the reconnecting state while the retry loop waits before the next provider attempt. It is safe for the turn runtime to call off the event-loop goroutine and is a no-op after clear.

func (*App) ShowSettingsTabForTest ¶

func (a *App) ShowSettingsTabForTest() bool

func (*App) ShowStatus ¶

func (a *App) ShowStatus(text string)

ShowStatus opens the /status overlay with text, moving focus to it so it captures input while open. The overlay is sized to fit the rendered snapshot (one row per text line, no chrome row — the overlay draws no rule of its own) so the temporary panel below the input area is just tall enough for its content. It is the embedding-app surface the /status handler reaches via CommandHost.ShowStatus.

func (*App) SortRowForTest ¶

func (a *App) SortRowForTest() string

func (*App) StatusLineText ¶

func (a *App) StatusLineText() string

StatusLineText returns the footer's first-row text (the segments), with tview tags stripped. It is a cross-package read-only test seam (like StatusText): bootstrap's StartTUI assembly test reads it back after driving a real model/effort apply through the production path, proving the segments reflect the new selection from the installed statusState — not an in-memory-only snapshot. Production renders the row through the view off the live event loop; this is never called at runtime.

func (*App) StatusModeKey ¶

func (a *App) StatusModeKey() string

func (*App) StatusText ¶

func (a *App) StatusText() string

StatusText returns the text the /status overlay is currently displaying, or "" when the overlay is not open. It is a cross-package test seam (like SubmitInput / PressCtrlE): bootstrap's StartTUI assembly test drives /status through the installed submit hook and reads the overlay text the app's own CommandHost.ShowStatus rendered, proving the config cache StartTUI assembled — not a cache the test rebuilt — feeds the overlay. Production /status always renders through ShowStatus off the live event loop; this is never called at runtime.

func (*App) StepSortForTest ¶

func (a *App) StepSortForTest() string

func (*App) Stop ¶

func (a *App) Stop()

Stop ends the tview event loop, returning control from Run. The production exit controller calls it as part of the clean-shutdown sequence before the process exits. Pending stream renders are discarded because that process exit owns cleanup of any callback already waiting for the event loop.

func (*App) Store ¶

func (a *App) Store() *sessions.Store

Store satisfies CommandHost: dispatch appends each command's slash_command event to whichever session is active at invocation time, which is exactly the active-store reference ActiveStore returns.

func (*App) StreamCanceller ¶

func (a *App) StreamCanceller() StreamCanceller

StreamCanceller returns the installed cancellation handle so the ESC / CTRL-C key handlers can call Cancel() on it. It is nil until SetStreamCanceller is called (and in unit tests), where the caller treats the stream surface as inert and cancels nothing.

func (*App) SubmitCurrent ¶

func (a *App) SubmitCurrent() bool

SubmitCurrent drives the Enter-key submit path (submitCurrent) without mutating the input buffer, so a test can submit after staging a pending attachment via CTRL-V — unlike SubmitInput, which replaces the buffer (and clears attachments) first. It is a cross-package test seam; production submits flow through submitCurrent off the Enter key, and this is never called at runtime.

func (*App) SubmitInput ¶

func (a *App) SubmitInput(input string) bool

SubmitInput drives the installed submit hook with input as if it were typed and entered, returning whether the hook accepted it (and clearing the field on accept) — the same accept/clear contract submitCurrent runs off the Enter key, minus the terminal. It is a cross-package test seam: a test outside internal/tui (bootstrap's StartTUI assembly) can exercise the real submit adapter the app installs via SetSubmit, instead of hand-assembling its own NewSubmitFunc. Production input always flows through submitCurrent off Enter; this is never called at runtime.

func (*App) SubmitQuestionFormForTest ¶

func (a *App) SubmitQuestionFormForTest()

func (*App) SubmitSecretPromptForTest ¶

func (a *App) SubmitSecretPromptForTest(secret string)

SubmitSecretPromptForTest sets the open prompt's field to secret and submits it, driving OnSubmit exactly as Enter would. It exists so an out-of-package test (e.g. internal/bootstrap's /connect wiring) can exercise the full submit path; in-package tests set the field and call submitSecretPrompt directly.

func (*App) SuggestFollowup ¶

func (a *App) SuggestFollowup(label, prompt string)

SuggestFollowup receives an intercepted suggest_followup tool call: label is the imperative the agent proposes and prompt is the text to prefill when the user accepts with Tab. It is the cross-package surface seam the provider-turn runtime calls when the tool loop intercepts the call (turndeps.go binds it onto turn.Deps).

It stores prompt as the pending acceptance and shows label as dim ghost text in the empty input. The tool loop runs off the tview event-loop goroutine, so — like the other provider-runtime surface methods — it marshals the widget mutation through streamUpdate: QueueUpdateDraw while the loop is running (so the ghost text is drawn), or a direct mutation before Run / in unit tests where the queue is never drained. The next buffer change clears both the ghost text and the pending prompt (onInputChanged), so the suggestion never survives typing or submit.

func (*App) ToggleAttributionForTest ¶

func (a *App) ToggleAttributionForTest() string

func (*App) ToggleDataCollectionForTest ¶

func (a *App) ToggleDataCollectionForTest() string

func (*App) TranscriptText ¶

func (a *App) TranscriptText() string

TranscriptText returns the full rendered transcript pane text — the committed lines, the in-progress streamed line, and the one-line notice — exactly as the view shows them. It is a cross-package read-only test seam (like StatusText): bootstrap's StartTUI assembly test reads it to confirm the production turn sink rendered the streamed partial reply into the assembled app's transcript and that ESC sealed it with the interrupted marker — an assertion the runner's retained counter and the durable event cannot make, because they observe bytes counted, not the transcript the user sees. Production renders the transcript through the view off the live event loop; this is never called at runtime.

func (*App) TurnEndPending ¶

func (a *App) TurnEndPending() bool

func (*App) TurnEnded ¶

func (a *App) TurnEnded(outcome string)

func (*App) UserMessageAdded ¶

func (a *App) UserMessageAdded(abort <-chan struct{}, store *sessions.Store, text string, parts []sessions.ContentPart)

UserMessageAdded stops waiting for the event loop once abort closes, because the loop may be blocked in a /clear or /resume that is waiting for this turn to drain.

func (*App) UserMessagesUnsent ¶

func (a *App) UserMessagesUnsent(store *sessions.Store, n, recorded int, outcome string) func()

func (FolderOmission) Hidden ¶

func (o FolderOmission) Hidden() bool

func (*History) Append ¶

func (h *History) Append(entry string)

Append records entry as the newest submission, preserving duplicates and evicting the oldest entry once the cap is exceeded (FIFO). It resets any in-progress navigation back to the live line, so the next ↑ starts from the newest entry and re-saves the current draft.

func (*History) Down ¶

func (h *History) Down() string

Down walks one step toward newer entries and returns the text the input field should show. From the newest entry it restores the saved draft and leaves navigation; once back on the draft it stays there. When not navigating it returns the saved draft and changes nothing.

func (*History) Snapshot ¶

func (h *History) Snapshot() []string

Snapshot returns a copy of the recorded entries in submission order, oldest first. It is the read-only seam reverse-search reads through: the copy means a caller cannot mutate stored history or the navigation state.

func (*History) Up ¶

func (h *History) Up(draft string) string

Up walks one step toward older entries and returns the text the input field should show. The first ↑ of a run saves draft (the current live line) and returns the newest entry; further ↑ walk farther back and stay put at the oldest entry. With no history it is a no-op that returns draft unchanged.

func (*PromptNotifier) Stop ¶

func (n *PromptNotifier) Stop()

Stop waits for an in-flight notify to return, so no write lands after the prompt it belongs to is gone.

func (PromptRequest) IsDirectCommand ¶

func (r PromptRequest) IsDirectCommand() bool

IsDirectCommand reports whether the subject is a direct command. The subject-scope sub-choice attaches to a grant-creating selection when this is true (literal-command and structured-tool subjects are fixed and offer no sub-choice).

func (PromptRequest) IsSimpleCompound ¶

func (r PromptRequest) IsSimpleCompound() bool

IsSimpleCompound reports whether the subject is a recognized simple compound eligible for the per-stage subject-scope chooser. It is a separate gate from IsDirectCommand: simple compounds arrive as literal-command subjects, so an ordinary literal (Compound nil) keeps the byte-exact no-chooser path and only a request carrying the recognized decomposition opens the compound chooser.

func (QuestionResult) Encode ¶

func (r QuestionResult) Encode() (string, error)

A clarification marshals through its own shape because `answers` has no omitempty: this struct would pair it with an empty answer list the model reads as a question answered with nothing.

func (*Registry) Commands ¶

func (r *Registry) Commands() []Command

Commands returns the registry entries in source order, for /help listing.

func (*Registry) DispatchSlashInput ¶

func (r *Registry) DispatchSlashInput(input string, host CommandHost) DispatchResult

DispatchSlashInput parses one line via ParseSlashInput and dispatches it. A bare exit/quit is treated as /exit. Unknown commands and wrong-arity invocations render a one-line notice, retain the typed input, and append no event; valid invocations run the canonical handler, which appends the slash_command event at its own sequencing point.