Struct ReloadContext 

pub struct ReloadContext {

    pub extension_session: ExtensionSessionCell,
    pub tool_context: ToolCallContext,
    pub action_bridge: ActionBridgeCell,
    pub ext_status: ExtensionStatusMailbox,
    pub editor_text: EditorTextMailbox,
    pub catalog: Vec<Model>,
    pub providers: Vec<Arc<dyn Provider>>,
    pub runtime: Handle,
    pub cwd: PathBuf,
    pub project_trusted: bool,
    pub args: Args,
    pub resolved_model: Model,
    pub broadcast: Arc<dyn AgentEmitter>,
    pub mailbox: ReloadMailbox,
    pub ui_dialog: UiDialogMailbox,
    pub dev_extension: Option<Arc<DevExtension>>,
}

Everything /reload needs to rebuild extension + resource state into a live harness. Built once in build (alongside the harness) and held by the TUI (cloned into the reload callback the bridge carries + the /reload command handler). The harness itself is NOT held here — the TUI already owns a &AgentHarness / a clone; passing it at the call site keeps this struct free of a harness back-reference (so it can be Clone and moved into the reload callback without borrowing the harness).

Fields

extension_session: ExtensionSessionCell

The live extension-session cell (swapped on reload).

tool_context: ToolCallContext

The session’s plugin-tool context (cwd + session id), reused — not rebuilt — on reload so the rebuilt adapters keep serving the SAME session. A reload that made a fresh context would leave every plugin tool without a session id until the next launch.

action_bridge: ActionBridgeCell

The live action-bridge cell (swapped + old invalidated on reload).

ext_status: ExtensionStatusMailbox

The extension status registry the TUI renders in its footer (SetStatus). Lives in the context (not the cell) so it survives a bridge swap.

editor_text: EditorTextMailbox

The extension editor-text queue the TUI drains into the prompt editor (SetEditorText, runtime action 19). Lives in the context (not the cell) so it survives a bridge swap — exactly like ext_status. A voice plugin writes a transcription here as a draft; the TUI applies it, starts the optional auto-send countdown, and submits through the normal path so the user bubble renders as usual.

catalog: Vec<Model>

The model catalog (read-only) the host uses to resolve set_model(id). available_catalog(resolved) is captured once — reload does not re-resolve the provider (auth/provider resolution is a startup concern; reloading extensions does not re-open auth).

providers: Vec<Arc<dyn Provider>>

The resolved provider runtimes (for rebuilding models = providers + PluggableProvider::from_session). Cheap to clone (Arc).

runtime: Handle

The ambient runtime handle (captured in build) — PluggableProvider

• the fresh ActionBridge need a captured Handle to spawn from any thread.

cwd: PathBuf

The cwd (for static resource-dir resolution + context-file walk).

project_trusted: bool

The project-trust decision captured before provider and session setup. Startup consumers reuse this value so extension code cannot change the effective policy by mutating the process cwd while it is loading.

args: Args

The parsed args (cloned) — --no-*/--tools/--exclude-tools/ --extensions-dir/--no-extensions/--system-prompt/etc all apply on reload exactly as at startup (a reload re-reads the same flags; it does not pick up argv changes mid-session, which is the right contract — pi’s /reload re-runs discovery with the same config).

resolved_model: Model

The resolved model + thinking level (the harness’s active model stays unless set_model changed it; reload does not touch the model).

broadcast: Arc<dyn AgentEmitter>

The broadcast emitter the harness was built with. Reload rebuilds the TeeEmitter over the fresh ExtensionEmitter (the old tee’s extension child is dropped, unsubscribing from the old registry). The broadcast half stays live the whole session (the TUI’s drain task holds the receiver), so we keep a handle to re-wrap.

mailbox: ReloadMailbox

The session-long reload mailbox (B5d). Build creates one, installs it on the initial ActionBridge via [reload_callback_from_mailbox], and hands a clone to the TUI. The TUI installs its TuiMessage sender so a plugin’s runtime_action(Reload) signals the main loop — the reload routine reuses THIS mailbox (not a fresh default) when building the fresh bridge, so the bridge always carries the mailbox the TUI installed across reloads.

ui_dialog: UiDialogMailbox

Session-long UI-dialog mailbox (runtime action 17). The initial bridge carries it; the TUI attaches itself and polls take_pending from its key loop, and /reload reuses THIS mailbox when it builds the fresh bridge. A detached mailbox makes ask_user fail with “requires an interactive UI” (headless contract).

dev_extension: Option<Arc<DevExtension>>

Active rpi dev extension builder. /reload rebuilds it before swapping plugin sessions; its watcher signals mailbox after a successful background build.

Trait Implementations

impl Clone for ReloadContext

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.