harness-sdk

use harness_sdk;

pub mod adapter;

pub mod backtrack;

pub mod clipboard;

pub mod composer;

pub mod error;

pub mod external_editor;

pub mod harness;

pub mod keymap;

pub mod onboarding;

pub mod session;

pub mod settings;

pub mod types;

pub mod workspace;

pub mod interjection;

pub mod validation;

pub mod commands;

pub mod modes;

pub mod runtime;

pub mod screens;

pub mod adapters;

#[cfg(feature = "plugins")]
pub mod plugins;

pub use error::{AdapterError, ParseError, PluginError, SdkError};

pub use session::{
    JsonlSessionStore, SessionMetadata, SessionRecord, SessionRecordKind, SessionStore,
    SessionStoreError,
};

pub use keymap::{
    parse_key_spec, parse_key_spec_chord, Action, ContextualKeymap, KeyBinding, KeySpecError,
    Keymap, KeymapContext, KeymapError,
};

pub use backtrack::{list_backtrack_targets, rewind_to, BacktrackTarget};

pub use composer::{HistorySearch, MessageQueue, MessageQueueError, MESSAGE_QUEUE_CAPACITY};

pub use settings::{
    FlocksCli, ModeInfo, ModelInfo, ProviderInfo, ProviderKind, ProviderSettingField,
    ProviderSettingKind, ProviderSettingOption, SettingsAction, SettingsApplyResult,
    SettingsSnapshot,
};

pub use clipboard::{Clipboard, ClipboardError, MemoryClipboard, SystemClipboard};

pub use external_editor::{
    open_in_editor, open_with_command, resolve_editor_command, ExternalEditorError,
};

pub use onboarding::{OnboardingError, OnboardingFlow, OnboardingSelection, OnboardingStep};

pub use workspace::complete_workspace_paths;

pub use harness::{
    attribute, attribute_entry, AttributionDecision, AttributionVerdict, ChangeManifest,
    EvidenceCorpus, EvidenceCorpusError, HarnessComponentEdit, HarnessComponentEditKind,
    HarnessComponentKind, HarnessLoopError, HarnessLoopPhase, HarnessWorkspace,
    HarnessWorkspaceError, IterationRecord, ManifestEntry, OverviewReport, PredictedImpact,
    StandardHarnessLoop, TaskAnalysis, TaskDelta, TaskOutcome, TaskOutcomeMap,
    HARNESS_COMPONENT_KINDS,
};

pub use types::{
    ActivityLevel, AdapterCapabilities, AutonomyEvent, HumanInterjection, InterjectionAck,
    InterjectionKind, InterjectionPriority, Mode, ResponseChunk, SdkAgentInfo, SdkAgentStatus,
    SdkApprovalAction, SdkApprovalRequest, SdkRiskLevel, SdkRole, SessionInfo,
};

pub use types::{
    DEFAULT_MAX_MESSAGES, DEFAULT_STREAM_TIMEOUT, MAX_AGENT_ID_LEN, MAX_AGENT_NAME_LEN,
    MAX_CHUNK_SIZE, MAX_INTERJECTION_LEN, MAX_TOOL_INPUT_SIZE,
};

pub use adapter::AgentAdapter;

pub use runtime::app::{AgentApp, AgentAppBuilder};

pub use runtime::terminal_control::{
    clear_title, hyperlink, ring_bell, set_title, write_hyperlink, MAX_HYPERLINK_URL_LEN,
    MAX_TITLE_LEN,
};

pub use runtime::notifications::{
    KindMask, NotificationKind, Notifier, NotifierConfig, MAX_NOTIFICATION_LEN,
};

pub use screens::custom::{CustomScreen, ScreenEvent, ScreenResult};

pub use adapters::stdio::StdioAdapter;

#[cfg(feature = "http")]
pub use adapters::http::HttpAdapter;

#[async_trait::async_trait]
pub trait AgentAdapter: Send + Sync + 'static {
    /// Returns the adapter's name (used in logs and UI).
    ///
    /// Must be non-empty and stable across calls.
    fn name(&self) -> &str;

    /// Returns the adapter's capability flags.
    ///
    /// The SDK checks these flags before calling optional methods.
    /// Returning `false` for a capability means the SDK will never call
    /// the corresponding methods and will disable related UI features.
    fn capabilities(&self) -> AdapterCapabilities;

    /// Discover available agents.
    ///
    /// Called during initialization and when the user requests a refresh.
    /// The SDK validates every returned `SdkAgentInfo` before use.
    async fn list_agents(&self) -> Result<Vec<SdkAgentInfo>, AdapterError>;

    /// Send a chat message to an agent and receive a streaming response.
    ///
    /// The returned stream must eventually yield [`ResponseChunk::Done`]
    /// or [`ResponseChunk::Error`]. The SDK enforces a timeout if neither
    /// arrives within the configured duration.
    ///
    /// # Arguments
    ///
    /// * `agent_id` — Target agent identifier (from `list_agents`)
    /// * `message` — User's message text (already sanitized)
    async fn send_message(
        &self,
        agent_id: &str,
        message: &str,
    ) -> Result<BoxStream<'static, ResponseChunk>, AdapterError>;

    /// Cancel an in-progress response stream.
    ///
    /// Called when the user presses Escape or Ctrl+C during streaming.
    /// Default implementation returns `Ok(())` (no-op).
    async fn cancel_response(&self, _agent_id: &str) -> Result<(), AdapterError> ;

    // ── Autonomy Mode ──

    /// Start an autonomous execution session.
    ///
    /// Returns a stream of [`AutonomyEvent`]s that the SDK displays
    /// in the activity feed.
    ///
    /// Only called if `capabilities().autonomy` is `true`.
    async fn start_autonomy(
        &self,
        _agent_id: &str,
        _instructions: &str,
    ) -> Result<BoxStream<'static, AutonomyEvent>, AdapterError> ;

    /// Stop the current autonomous execution session.
    ///
    /// Called when the user presses Ctrl+S or `/stop`.
    async fn stop_autonomy(&self, _agent_id: &str) -> Result<(), AdapterError> ;

    /// Send a human interjection during autonomous execution.
    ///
    /// The adapter should acknowledge receipt via [`InterjectionAck`].
    async fn send_interjection(
        &self,
        _interjection: &HumanInterjection,
    ) -> Result<InterjectionAck, AdapterError> ;

    // ── Approval Management ──

    /// Submit an approval decision for a pending request.
    ///
    /// Called when the user approves, denies, or edits an approval request
    /// from the approval queue.
    async fn submit_approval(
        &self,
        _request_id: &str,
        _action: SdkApprovalAction,
    ) -> Result<(), AdapterError> ;

    // ── UI Rendering Hooks ──

    /// Optional hook to render custom content in the sidebar area.
    ///
    /// Called during each frame render. The `area` is the sidebar region
    /// from `AppShellState::sidebar_area()`. Default is a no-op.
    ///
    /// This is intentionally **sync** because rendering happens on the
    /// main thread inside `terminal.draw()`.
    fn render_sidebar(
        &self,
        _frame: &mut ratatui::Frame,
        _area: ratatui::layout::Rect,
        _theme: &Theme,
    ) ;

    /// Optional hook to render custom content in the header area.
    ///
    /// Called during each frame render. The `area` is the header region
    /// from `AppShellState::header_area()`. Default is a no-op.
    fn render_header(
        &self,
        _frame: &mut ratatui::Frame,
        _area: ratatui::layout::Rect,
        _theme: &Theme,
    ) ;

    /// Optional hook to request a taller header from the chat screen.
    ///
    /// The default `AppShell` reserves only 1 row for the header. An
    /// adapter that wants to paint a banner / mascot / multi-line
    /// status returns its desired height here. The chat screen passes
    /// `sidebar_collapsed` so the adapter can ask for a tall header
    /// only when the sidebar is hidden (and otherwise paint into the
    /// sidebar).
    fn desired_header_height(&self, _sidebar_collapsed: bool) -> u16 ;

    /// Optional hook to request a wider sidebar from the chat screen.
    /// Defaults to the SDK's `AppShell` default (25 columns).
    fn desired_sidebar_width(&self) -> Option<u16> ;

    /// Optional hook to provide live file-mention completions when the
    /// user types `@<prefix>` in the input bar.
    ///
    /// `prefix` is everything after the `@` up to the cursor. The
    /// adapter returns up to ~50 matching paths (relative to its
    /// workspace root). Default: no completions, dropdown stays
    /// hidden.
    ///
    /// Path conventions adapters should honour:
    /// - `@foo`           → fuzzy match anywhere in the workspace
    /// - `@./foo`         → match relative to the workspace root
    /// - `@../foo`        → walk up one directory
    /// - `@/abs/path`     → absolute path on the filesystem
    ///
    /// This is intentionally **sync**: the SDK calls it on every
    /// keystroke, so adapters MUST keep it cheap (cache the walk,
    /// limit results, never block on I/O).
    fn complete_file_mention(&self, _prefix: &str) -> Vec<String> ;

    // ── Lifecycle ──

    /// Called once when the TUI application starts.
    ///
    /// Use this for any one-time initialization (connecting to backends,
    /// spawning background tasks, etc.).
    async fn on_startup(&self) -> Result<(), AdapterError> ;

    /// Called once when the TUI application is shutting down.
    ///
    /// Use this for cleanup (closing connections, saving state, etc.).
    /// The SDK waits up to 5 seconds for this to complete before forcing exit.
    async fn on_shutdown(&self) -> Result<(), AdapterError> ;

    // ── Settings palette (Ctrl+P) ──

    /// Return the current settings snapshot — providers, modes,
    /// Flocks CLIs — that the runtime should render in the Ctrl+P
    /// palette. The default returns an empty snapshot, which causes
    /// the palette to show only the built-in pages.
    async fn settings_snapshot(&self) -> Result<SettingsSnapshot, AdapterError> ;

    /// Apply a [`SettingsAction`] picked by the user in the
    /// settings palette. The default returns
    /// `Ok(SettingsApplyResult::fail(...))`, signaling the runtime
    /// to display a "not supported" flash.
    async fn apply_settings_action(
        &self,
        _action: SettingsAction,
    ) -> Result<SettingsApplyResult, AdapterError> ;
}

pub struct HttpAdapter {

}

#[must_use]
pub fn new(base_url: impl Into<String>) -> Self;

#[must_use]
pub fn with_bearer_token(mut self, token: impl Into<String>) -> Self;

#[must_use]
pub fn with_capabilities(mut self, caps: AdapterCapabilities) -> Self;

pub mod stdio;

#[cfg(feature = "http")]
pub mod http;

pub struct StdioAdapter {

}

#[must_use]
pub fn new(program: impl Into<String>, args: &[impl AsRef<str>]) -> Self;

#[must_use]
pub fn with_name(mut self, name: impl Into<String>) -> Self;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BacktrackTarget {
/// Index into `AppState::messages()` (0-based).

pub message_index: usize,
/// User turn ordinal (1, 2, 3 …) — useful as a label.

pub turn_ordinal: usize,
/// Snippet of the user prompt (truncated to ~80 chars) for

/// display.

pub preview: String
}

#[must_use]
pub fn list_backtrack_targets(state: &AppState) -> Vec<BacktrackTarget>;

pub fn rewind_to(state: &mut AppState, target: &BacktrackTarget) -> Result<String, SdkError>;

#[derive(Debug, Error)]
pub enum ClipboardError {
    /// The platform clipboard is unavailable (no display server,
    /// permission denied, etc.).
    #[error("clipboard unavailable: {0}")]
    Unavailable(String),

    /// Underlying clipboard backend error (`arboard::Error`).
    #[error("clipboard backend: {0}")]
    Backend(String),
}

pub trait Clipboard: Send {
    /// Copy `text` to the platform clipboard, replacing prior contents.
    fn copy(&mut self, text: &str) -> Result<(), ClipboardError>;

    /// Read the current clipboard contents as UTF-8 text. Returns
    /// [`ClipboardError::Unavailable`] when the clipboard is empty or
    /// holds non-text content.
    fn paste(&mut self) -> Result<String, ClipboardError>;
}

pub struct SystemClipboard {

}

pub fn new() -> Result<Self, ClipboardError>;

#[derive(Debug, Default)]
pub struct MemoryClipboard {

}

pub mod slash;

#[derive(Debug, Clone)]
pub enum SlashResult {
    /// Command executed, display message to user.
    Message(String),
    /// Switch to the specified mode.
    SwitchMode(Mode),
    /// Stop the current autonomy session.
    StopAutonomy,
    /// Clear the chat history.
    ClearHistory,
    /// Show help text.
    ShowHelp(String),
    /// Quit the application.
    Quit,
    /// Command not found.
    NotFound(String),
    /// Toggle the command palette.
    TogglePalette,
    /// List available agents.
    ListAgents,
    /// Show session status.
    ShowStatus,
    /// Send expanded text as a chat message to the active agent.
    SendAsChat(String),
}

#[derive(Debug, Clone)]
pub struct SlashArg {
/// Argument name (e.g., "mode").

pub name: String,
/// Whether this argument is required.

pub required: bool,
/// Possible values (e.g., \["chat", "auto"\]).

pub options: Vec<String>,
/// Short description (e.g., "The mode to switch to").

pub description: String
}

#[derive(Debug, Clone)]
pub struct SlashCommand {
/// Command name (without the `/` prefix).

pub name: String,
/// Short description.

pub description: String,
/// Source label ("built-in" or plugin name).

pub source: String,
/// Aliases for this command.

pub aliases: Vec<String>,
/// Usage template (e.g., "/mode <chat|auto>").

pub usage: String,
/// Structured argument definitions.

pub args: Vec<SlashArg>
}

pub struct SlashCommandRegistry {

}

#[must_use]
pub fn new() -> Self;

#[must_use]
pub fn with_builtins() -> Self;

#[must_use]
pub fn lookup(&self, name: &str) -> Option<&SlashCommand>;

pub fn register(&mut self, command: SlashCommand);

#[must_use]
pub fn list_commands(&self) -> Vec<&SlashCommand>;

#[must_use]
pub fn command_hints(&self) -> Vec<harness_tui_kit::CommandHint>;

#[must_use]
pub fn dropdown_items(&self) -> Vec<harness_tui_kit::SlashDropdownItem>;

pub fn dispatch_slash(input: &str, registry: &SlashCommandRegistry) -> SlashResult;

pub const MESSAGE_QUEUE_CAPACITY: usize;

#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum MessageQueueError {
    /// The supplied message was empty after trimming.
    #[error("queued message is empty after trimming")]
    EmptyMessage,
    /// The message exceeds [`MAX_INTERJECTION_LEN`].
    #[error("queued message length {0} exceeds limit {MAX_INTERJECTION_LEN}")]
    TooLong(usize),
    /// The queue is full.
    #[error("message queue is full ({0} pending)")]
    Full(usize),
}

#[derive(Debug, Clone, Default)]
pub struct MessageQueue {

}

#[must_use]
pub fn new() -> Self;

#[must_use]
pub fn len(&self) -> usize;

#[must_use]
pub fn is_empty(&self) -> bool;

pub fn push(&mut self, message: impl Into<String>) -> Result<(), MessageQueueError>;

pub fn pop(&mut self) -> Option<String>;

pub fn drain(&mut self) -> Vec<String>;

#[must_use]
pub fn peek(&self) -> &VecDeque<String>;

pub fn clear(&mut self);

#[derive(Debug, Clone, Default)]
pub struct HistorySearch {

}

#[must_use]
pub fn new() -> Self;

#[must_use]
pub fn query(&self) -> &str;

#[must_use]
pub fn match_index(&self) -> Option<usize>;

#[must_use]
pub fn has_match(&self) -> bool;

pub fn reset(&mut self);

pub fn push_char(&mut self, ch: char, history: &[String]);

pub fn pop_char(&mut self, history: &[String]);

pub fn update(&mut self, history: &[String]);

pub fn next_match(&mut self, history: &[String]);

#[must_use]
pub fn matched<'h>(&self, history: &'h [String]) -> Option<&'h str>;

#[derive(Debug, thiserror::Error)]
pub enum SdkError {
    // ── Adapter Errors ──
    /// An error from the adapter implementation.
    #[error("adapter error: {0}")]
    Adapter(#[from] AdapterError),

    /// Adapter output failed validation.
    #[error("adapter output validation failed: {0}")]
    InvalidAdapterOutput(String),

    /// Adapter stream timed out.
    #[error("adapter stream timeout after {0:?}")]
    AdapterTimeout(Duration),

    /// Adapter does not support the requested feature.
    #[error("adapter does not support {0}")]
    NotSupported(String),

    // ── Runtime Errors ──
    /// Terminal I/O error.
    #[error("terminal error: {0}")]
    Terminal(#[from] std::io::Error),

    /// Event loop error.
    #[error("event loop error: {0}")]
    EventLoop(String),

    /// Invalid mode transition.
    #[error("mode transition failed: cannot go from {from} to {to}")]
    InvalidModeTransition {
        /// The current mode.
        from: String,
        /// The requested mode.
        to: String,
    },

    // ── Input Errors ──
    /// Interjection parse error.
    #[error("interjection parse error: {0}")]
    InterjectionParse(#[from] ParseError),

    /// Slash command error.
    #[error("slash command error: {0}")]
    SlashCommand(String),

    // ── Plugin Errors ──
    /// Plugin system error.
    #[cfg(feature = "plugins")]
    #[error("plugin error: {0}")]
    Plugin(#[from] PluginError),

    // ── Configuration Errors ──
    /// Builder configuration error.
    #[error("builder error: {0}")]
    Builder(String),

    /// Serialization/deserialization error.
    #[error("serialization error: {0}")]
    Serialization(String),
}

#[derive(Debug, thiserror::Error, Clone)]
pub enum AdapterError {
    /// Connection to the agent backend failed.
    #[error("connection error: {0}")]
    Connection(String),

    /// The adapter received an invalid response from the backend.
    #[error("protocol error: {0}")]
    Protocol(String),

    /// An I/O error occurred during adapter communication.
    #[error("i/o error: {0}")]
    Io(String),

    /// The adapter operation timed out.
    #[error("timeout: {0}")]
    Timeout(String),

    /// Authentication failed.
    #[error("authentication error: {0}")]
    Authentication(String),

    /// The requested operation is not supported by this adapter.
    #[error("not supported: {0}")]
    NotSupported(String),

    /// A generic adapter error.
    #[error("{0}")]
    Other(String),
}

#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq)]
pub enum ParseError {
    /// Input was empty or whitespace-only.
    #[error("interjection input is empty")]
    EmptyInput,

    /// Input exceeded the maximum allowed length.
    #[error("interjection too long: {0} chars (max {1})")]
    TooLong(usize, usize),

    /// Targeted agent name is invalid.
    #[error("invalid agent target: {0}")]
    InvalidTarget(String),
}

#[derive(Debug, thiserror::Error, Clone)]
pub enum PluginError {
    /// WASM module failed structural validation.
    #[error("WASM module failed validation: {0}")]
    InvalidModule(String),

    /// WASM module hash does not match the expected hash.
    #[error("WASM hash mismatch: expected {expected}, got {actual}")]
    HashMismatch {
        /// Expected SHA-256 hash.
        expected: String,
        /// Actual computed SHA-256 hash.
        actual: String,
    },

    /// Plugin does not export a required function.
    #[error("plugin '{0}' missing required export: {1}")]
    MissingExport(String, String),

    /// Plugin requested a capability the host does not provide.
    #[error("plugin '{0}' requested unsupported capability: {1}")]
    UnsupportedCapability(String, String),

    /// Capability was denied by the permission manager.
    #[error("capability denied for plugin '{plugin}': {capability} -> {resource}")]
    CapabilityDenied {
        /// Plugin name.
        plugin: String,
        /// Capability kind.
        capability: String,
        /// Requested resource.
        resource: String,
    },

    /// Plugin trapped during execution.
    #[error("plugin '{0}' panicked during execution: {1}")]
    PluginPanic(String, String),

    /// Plugin not found in configured sources.
    #[error("plugin '{0}' not found in configured sources")]
    NotFound(String),

    /// Plugin is disabled.
    #[error("plugin '{0}' is disabled")]
    Disabled(String),

    /// Plugin configuration error.
    #[error("plugin config error: {0}")]
    Config(String),

    /// Host function error.
    #[error("plugin '{0}' host function error: {1}")]
    HostFunction(String, String),
}

#[derive(Debug, Error)]
pub enum ExternalEditorError {
    /// Neither `$VISUAL` nor `$EDITOR` is set.
    #[error("neither VISUAL nor EDITOR is set")]
    MissingEditor,

    /// Editor command failed to parse via `shlex` (POSIX) or
    /// produced an empty argv on Windows.
    #[error("failed to parse editor command")]
    ParseFailed,

    /// Resolved editor command was empty.
    #[error("editor command is empty")]
    EmptyCommand,

    /// I/O failure (temp file creation, child process spawn, etc.).
    #[error("editor io: {0}")]
    Io(#[from] io::Error),

    /// Editor exited with a non-zero status.
    #[error("editor exited with status {0}")]
    NonZeroExit(i32),

    /// Editor was terminated by signal.
    #[error("editor was terminated by signal")]
    Terminated,
}

pub fn resolve_editor_command() -> Result<Vec<String>, ExternalEditorError>;

pub fn open_in_editor(seed: &str) -> Result<String, ExternalEditorError>;

pub fn open_with_command(seed: &str, editor_cmd: &[String]) -> Result<String, ExternalEditorError>;

pub const HARNESS_COMPONENT_KINDS: &[HarnessComponentKind];

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum HarnessComponentKind {
    /// `systemprompt.md` — base behavioral rules and prompt scaffold.
    SystemPrompt,
    /// `tool_descriptions/*.yaml` — declarations the model sees.
    ToolDescriptions,
    /// `tools/*` — the executable tool implementations.
    ToolImplementations,
    /// `middleware/*` — pre/post-processing hooks around tool calls.
    Middleware,
    /// `skills/{name}/` — reusable cross-task playbooks.
    Skills,
    /// `sub_agents/*.yaml` — optional sub-agent workflow configs.
    SubAgents,
    /// `LongTermMEMORY.md` — persistent cross-session knowledge.
    LongTermMemory,
    /// `ShortTermMEMORY.md` — runtime-only; **not** editable by the
    /// evolve agent. Listed for exhaustiveness only.
    ShortTermMemory,
}

#[must_use]
pub fn as_key(self) -> &'static str;

#[must_use]
pub fn label(self) -> &'static str;

#[must_use]
pub fn is_editable(self) -> bool;

#[must_use]
pub fn is_single_file(self) -> bool;

#[must_use]
pub fn mount(self) -> &'static Path;

#[must_use]
pub fn from_key(key: &str) -> Option<Self>;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct HarnessComponentEdit {
/// Which component kind the edit targets.

pub kind: HarnessComponentKind,
/// File path relative to the workspace root. For single-file

/// kinds this matches `kind.mount()`; for directory-backed kinds

/// it's a path *under* the directory (e.g. `tools/grep.py`).

pub path: PathBuf,
/// What the edit does.

pub op: HarnessComponentEditKind
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "op", rename_all = "snake_case")]
pub enum HarnessComponentEditKind {
    /// Create a new file with the given UTF-8 contents.
    Create {
        /// Initial contents.
        contents: String,
    },
    /// Replace the entire file with the given UTF-8 contents.
    Update {
        /// New contents.
        contents: String,
    },
    /// Delete the file.
    Delete,
    /// Rename the file (path stays the same; the new name lives
    /// under the same component kind).
    Rename {
        /// New path relative to the workspace root.
        new_path: PathBuf,
    },
}

#[must_use]
pub fn create(
        kind: HarnessComponentKind,
        path: impl Into<PathBuf>,
        contents: impl Into<String>,
    ) -> Self;

#[must_use]
pub fn update(
        kind: HarnessComponentKind,
        path: impl Into<PathBuf>,
        contents: impl Into<String>,
    ) -> Self;

#[must_use]
pub fn delete(kind: HarnessComponentKind, path: impl Into<PathBuf>) -> Self;

#[must_use]
pub fn rename(
        kind: HarnessComponentKind,
        path: impl Into<PathBuf>,
        new_path: impl Into<PathBuf>,
    ) -> Self;

#[derive(Debug, Error)]
pub enum EvidenceCorpusError {
    /// I/O error reaching disk.
    #[error("evidence corpus io: {0}")]
    Io(#[from] io::Error),

    /// Path escapes the iteration root (e.g. `..` segment).
    #[error("path {0} escapes the iteration root")]
    PathEscape(PathBuf),
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskAnalysis {
/// Task name (matches `TaskOutcomeMap` keys).

pub task: String,
/// The per-iteration outcome being analyzed.

pub outcome: TaskOutcome,
/// One-line summary used in the overview.

pub summary: String,
/// Root cause hypothesis (free text).

pub root_cause: String,
/// Markdown body — the full evidence the Evolve Agent reads.

pub body_markdown: String
}

#[must_use]
pub fn render_markdown(&self) -> String;

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct OverviewReport {
/// Iteration number.

pub iteration: u32,
/// Total tasks run.

pub total: usize,
/// Tasks that passed.

pub passes: usize,
/// Tasks that failed.

pub fails: usize,
/// Tasks that did not run.

pub not_run: usize,
/// Optional headline finding for the iteration.

#[serde(default)]
pub headline: String,
/// Optional markdown body (themes, top failure clusters, etc.).

#[serde(default)]
pub body_markdown: String
}

#[must_use]
pub fn render_markdown(&self) -> String;

#[derive(Debug, Clone)]
pub struct EvidenceCorpus {

}

pub fn open(runs_root: impl AsRef<Path>, iteration: u32) -> Result<Self, EvidenceCorpusError>;

#[must_use]
pub fn root(&self) -> &Path;

#[must_use]
pub fn iteration(&self) -> u32;

pub fn task_analysis_path(&self, task: &str) -> Result<PathBuf, EvidenceCorpusError>;

#[must_use]
pub fn overview_path(&self) -> PathBuf;

pub fn trace_path(&self, task: &str, run_idx: u32) -> Result<PathBuf, EvidenceCorpusError>;

pub fn write_task_analysis(
        &self,
        analysis: &TaskAnalysis,
    ) -> Result<PathBuf, EvidenceCorpusError>;

pub fn write_overview(
        &self,
        overview: &OverviewReport,
    ) -> Result<PathBuf, EvidenceCorpusError>;

pub fn write_trace(
        &self,
        task: &str,
        run_idx: u32,
        contents: &str,
    ) -> Result<PathBuf, EvidenceCorpusError>;

pub fn read_task_analysis_markdown(
        &self,
        task: &str,
    ) -> Result<Option<String>, EvidenceCorpusError>;

pub fn read_overview_markdown(&self) -> Result<Option<String>, EvidenceCorpusError>;

pub fn list_analyzed_tasks(&self) -> Result<Vec<String>, EvidenceCorpusError>;

pub fn list_traces(&self) -> Result<Vec<PathBuf>, EvidenceCorpusError>;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum HarnessLoopPhase {
    /// Phase 1: run the benchmark with the current harness.
    Rollout,
    /// Phase 2: strip noise from trajectories.
    Clean,
    /// Phase 3: verify the prior iteration's manifest contracts.
    Attribute,
    /// Phase 4: AgentDebugger produces the EvidenceCorpus.
    Distill,
    /// Phase 5: Evolve Agent edits the workspace + emits manifest.
    Evolve,
    /// Phase 6: git-tag the iteration.
    Commit,
}

#[must_use]
pub fn as_key(self) -> &'static str;

#[must_use]
pub fn label(self) -> &'static str;

#[must_use]
pub const fn ordering() -> [HarnessLoopPhase; 6];

#[must_use]
pub fn next(self) -> Option<HarnessLoopPhase>;

#[derive(Debug, Error)]
pub enum HarnessLoopError {
    /// The caller invoked a phase out of order (e.g. `Distill`
    /// before `Rollout` finished).
    #[error("phase {got:?} attempted before {expected:?}")]
    PhaseOutOfOrder {
        /// Phase that should run next.
        expected: HarnessLoopPhase,
        /// Phase the caller tried to run.
        got: HarnessLoopPhase,
    },

    /// Iteration is already complete; bump the counter before
    /// attempting another phase.
    #[error("iteration {iteration} is complete; advance to next iteration")]
    IterationComplete {
        /// Completed iteration number.
        iteration: u32,
    },

    /// Workspace I/O error.
    #[error(transparent)]
    Workspace(#[from] HarnessWorkspaceError),

    /// Evidence corpus I/O error.
    #[error(transparent)]
    Evidence(#[from] EvidenceCorpusError),

    /// I/O error reaching the runs root.
    #[error("loop io: {0}")]
    Io(#[from] std::io::Error),

    /// Caller-supplied phase callback failed.
    #[error("phase {phase:?} failed: {reason}")]
    PhaseFailed {
        /// Phase whose callback returned an error.
        phase: HarnessLoopPhase,
        /// Free-form reason from the caller.
        reason: String,
    },
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct IterationRecord {
/// Iteration number (matches the directory suffix).

pub iteration: u32,
/// Phases completed so far in canonical order.

pub completed_phases: Vec<HarnessLoopPhase>,
/// Per-task outcomes from this iteration's rollout (populated

/// after Phase 1).

#[serde(default)]
pub outcomes: TaskOutcomeMap,
/// Verdicts produced by the Attribute phase against the

/// *previous* iteration's manifest. Empty on iteration 1.

#[serde(default)]
pub verdicts: Vec<AttributionVerdict>,
/// Manifest produced by the Evolve phase. `None` until phase 5

/// completes.

#[serde(default)]
pub manifest: Option<ChangeManifest>,
/// UNIX seconds the iteration was started.

pub started_at_unix_secs: u64
}

#[derive(Debug)]
pub struct StandardHarnessLoop {

}

pub fn start(
        runs_root: impl Into<PathBuf>,
        workspace: HarnessWorkspace,
        iteration: u32,
    ) -> Result<Self, HarnessLoopError>;

pub fn with_prior(mut self, manifest: ChangeManifest, outcomes: TaskOutcomeMap) -> Self;

#[must_use]
pub fn record(&self) -> &IterationRecord;

#[must_use]
pub fn iteration(&self) -> u32;

#[must_use]
pub fn next_phase(&self) -> Option<HarnessLoopPhase>;

#[must_use]
pub fn is_complete(&self) -> bool;

#[must_use]
pub fn iteration_dir(&self) -> PathBuf;

pub fn open_corpus(&self) -> Result<EvidenceCorpus, HarnessLoopError>;

#[must_use]
pub fn workspace(&self) -> &HarnessWorkspace;

pub fn run_rollout(
        &mut self,
        outcomes: TaskOutcomeMap,
    ) -> Result<HarnessLoopPhase, HarnessLoopError>;

pub fn run_clean(
        &mut self,
        cleanup: impl FnOnce(&Path) -> Result<(), String>,
    ) -> Result<HarnessLoopPhase, HarnessLoopError>;

pub fn run_attribute(&mut self) -> Result<HarnessLoopPhase, HarnessLoopError>;

pub fn run_distill(
        &mut self,
        debug: impl FnOnce(&EvidenceCorpus) -> Result<(), String>,
    ) -> Result<HarnessLoopPhase, HarnessLoopError>;

pub fn run_evolve(
        &mut self,
        evolve: impl FnOnce(&HarnessWorkspace, &EvidenceCorpus) -> Result<ChangeManifest, String>,
    ) -> Result<HarnessLoopPhase, HarnessLoopError>;

pub fn run_commit(
        &mut self,
        commit: impl FnOnce(&IterationRecord) -> Result<(), String>,
    ) -> Result<HarnessLoopPhase, HarnessLoopError>;

#[must_use]
pub fn loop_record_path(&self) -> PathBuf;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TaskOutcome {
    /// Task passed.
    Pass,
    /// Task failed.
    Fail,
    /// Task was not run (e.g. crashed, skipped).
    NotRun,
}

#[must_use]
pub fn is_pass(self) -> bool;

#[must_use]
pub fn is_fail(self) -> bool;

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(transparent)]
pub struct TaskOutcomeMap {
/// Map keyed by task name. `BTreeMap` so serialization is

/// deterministic (matters for diffing manifests across runs).

pub outcomes: BTreeMap<String, TaskOutcome>
}

#[must_use]
pub fn from_pairs<I, S>(it: I) -> Self
    where
        I: IntoIterator<Item = (S, TaskOutcome)>,
        S: Into<String>,;

#[must_use]
pub fn outcome(&self, task: &str) -> TaskOutcome;

pub fn set(&mut self, task: impl Into<String>, outcome: TaskOutcome);

pub fn iter(&self) -> impl Iterator<Item = (&str, TaskOutcome)>;

#[must_use]
pub fn len(&self) -> usize;

#[must_use]
pub fn is_empty(&self) -> bool;

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct PredictedImpact {
/// Tasks the evolve agent expects this edit to *fix* (move from

/// `Fail` → `Pass`).

#[serde(default)]
pub expected_fixes: Vec<String>,
/// Tasks the evolve agent flags as at risk of regressing

/// (currently `Pass`, may move to `Fail`).

#[serde(default)]
pub at_risk_regressions: Vec<String>
}

#[must_use]
pub fn new(
        expected_fixes: impl IntoIterator<Item = impl Into<String>>,
        at_risk_regressions: impl IntoIterator<Item = impl Into<String>>,
    ) -> Self;

#[must_use]
pub fn is_empty(&self) -> bool;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ManifestEntry {
/// Stable id (uuid string). Lets verdicts and audit trails

/// reference an entry independent of array position.

pub id: String,
/// Free-form list of task failures the edit addresses (e.g.

/// task names + one-line justification).

#[serde(default)]
pub failure_evidence: Vec<String>,
/// Diagnosed root cause behind those failures.

pub root_cause: String,
/// One-line summary of the targeted fix the edit applies.

pub targeted_fix: String,
/// Predicted impact (the falsifiable contract).

pub predicted_impact: PredictedImpact,
/// The actual edit applied to the workspace.

pub edit: HarnessComponentEdit
}

#[must_use]
pub fn new(
        failure_evidence: impl IntoIterator<Item = impl Into<String>>,
        root_cause: impl Into<String>,
        targeted_fix: impl Into<String>,
        predicted_impact: PredictedImpact,
        edit: HarnessComponentEdit,
    ) -> Self;

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ChangeManifest {
/// Iteration this manifest belongs to (e.g. `iteration_007`).

pub iteration: u32,
/// Entries in application order.

pub entries: Vec<ManifestEntry>
}

#[must_use]
pub fn new(iteration: u32) -> Self;

pub fn push(&mut self, entry: ManifestEntry) -> usize;

#[must_use]
pub fn len(&self) -> usize;

#[must_use]
pub fn is_empty(&self) -> bool;

#[must_use]
pub fn find(&self, id: &str) -> Option<&ManifestEntry>;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AttributionDecision {
    /// Every promised fix landed AND no flagged regression broke.
    /// The edit is kept.
    Confirmed,
    /// Some promised fixes landed; some flagged regressions
    /// broke. The loop driver decides whether to keep or revert.
    PartiallyConfirmed,
    /// No promised fixes landed (or every flagged regression
    /// broke). The edit is reverted.
    Refuted,
    /// The contract was silent (`PredictedImpact::is_empty()`); the
    /// edit cannot be falsified and is treated as refuted by
    /// default — the AHE paper requires a non-trivial contract.
    UnfalsifiableContract,
}

#[must_use]
pub fn is_keep(self) -> bool;

#[must_use]
pub fn is_revert(self) -> bool;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TaskDelta {
/// Task name.

pub task: String,
/// Outcome before the edit (i.e. the prior iteration's run).

pub before: TaskOutcome,
/// Outcome after the edit (this iteration's run).

pub after: TaskOutcome
}

#[must_use]
pub fn is_fix(&self) -> bool;

#[must_use]
pub fn is_regression(&self) -> bool;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AttributionVerdict {
/// Manifest entry id this verdict belongs to.

pub entry_id: String,
/// Decision (`Confirmed` / `PartiallyConfirmed` / `Refuted` /

/// `UnfalsifiableContract`).

pub decision: AttributionDecision,
/// Promised fixes that actually landed.

pub confirmed_fixes: Vec<TaskDelta>,
/// Promised fixes that did **not** land.

pub missed_fixes: Vec<TaskDelta>,
/// Regressions the contract flagged that DID happen.

pub triggered_regressions: Vec<TaskDelta>,
/// Regressions the contract flagged that did NOT happen

/// (kept stable).

pub avoided_regressions: Vec<TaskDelta>
}

#[must_use]
pub fn is_keep(&self) -> bool;

#[must_use]
pub fn is_revert(&self) -> bool;

#[must_use]
pub fn attribute(
    manifest: &ChangeManifest,
    before: &TaskOutcomeMap,
    after: &TaskOutcomeMap,
) -> Vec<AttributionVerdict>;

#[must_use]
pub fn attribute_entry(
    entry: &ManifestEntry,
    before: &TaskOutcomeMap,
    after: &TaskOutcomeMap,
) -> AttributionVerdict;

pub mod component;

pub mod evidence;

pub mod loop_driver;

pub mod manifest;

pub mod workspace;

pub use component::{
    HarnessComponentEdit, HarnessComponentEditKind, HarnessComponentKind, HARNESS_COMPONENT_KINDS,
};

pub use evidence::{EvidenceCorpus, EvidenceCorpusError, OverviewReport, TaskAnalysis};

pub use loop_driver::{HarnessLoopError, HarnessLoopPhase, IterationRecord, StandardHarnessLoop};

pub use manifest::{
    attribute, attribute_entry, AttributionDecision, AttributionVerdict, ChangeManifest,
    ManifestEntry, PredictedImpact, TaskDelta, TaskOutcome, TaskOutcomeMap,
};

pub use workspace::{HarnessWorkspace, HarnessWorkspaceError};

#[derive(Debug, Error)]
pub enum HarnessWorkspaceError {
    /// I/O error reaching the workspace.
    #[error("workspace io: {0}")]
    Io(#[from] io::Error),

    /// A path escapes the workspace root (e.g. `..`).
    #[error("path {0} escapes the workspace root")]
    PathEscape(PathBuf),

    /// An edit targeted a non-editable component (i.e.
    /// [`HarnessComponentKind::ShortTermMemory`]).
    #[error("component {0:?} is not editable")]
    NotEditable(HarnessComponentKind),

    /// Edit path does not live under the component's mount point.
    #[error("path {path:?} does not live under the {kind:?} mount {mount:?}")]
    MountMismatch {
        /// The kind whose mount the path was supposed to live under.
        kind: HarnessComponentKind,
        /// The path the caller supplied.
        path: PathBuf,
        /// The expected mount.
        mount: PathBuf,
    },
}

#[derive(Debug, Clone)]
pub struct HarnessWorkspace {

}

pub fn open(root: impl Into<PathBuf>) -> Result<Self, HarnessWorkspaceError>;

#[must_use]
pub fn root(&self) -> &Path;

#[must_use]
pub fn mount_path(&self, kind: HarnessComponentKind) -> PathBuf;

pub fn read_single_file(
        &self,
        kind: HarnessComponentKind,
    ) -> Result<Option<String>, HarnessWorkspaceError>;

pub fn write_single_file(
        &self,
        kind: HarnessComponentKind,
        contents: &str,
    ) -> Result<PathBuf, HarnessWorkspaceError>;

pub fn list_directory(
        &self,
        kind: HarnessComponentKind,
    ) -> Result<Vec<PathBuf>, HarnessWorkspaceError>;

pub fn read_directory_file(
        &self,
        kind: HarnessComponentKind,
        path: impl AsRef<Path>,
    ) -> Result<Option<String>, HarnessWorkspaceError>;

pub fn apply_edit(
        &self,
        edit: &HarnessComponentEdit,
    ) -> Result<PathBuf, HarnessWorkspaceError>;

pub fn apply_batch(
        &self,
        edits: &[HarnessComponentEdit],
    ) -> Result<Vec<PathBuf>, HarnessWorkspaceError>;

pub async fn deliver_interjection(
    adapter: &Arc<dyn AgentAdapter>,
    interjection: &HumanInterjection,
) -> Result<InterjectionAck, SdkError>;

pub mod delivery;

pub mod parser;

pub mod sanitizer;

pub fn parse_interjection(raw: &str) -> Result<HumanInterjection, ParseError>;

#[must_use]
pub fn sanitize_input(input: &str) -> String;

#[must_use]
pub fn sanitize_output(text: &str) -> String;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum Action {
    // ── Composer ──
    /// Submit the current input.
    Submit,
    /// Cancel the current operation (clears input, dismisses overlay,
    /// stops a streaming response, etc. — the handler decides).
    Cancel,
    /// Insert a literal newline in the composer.
    InsertNewline,

    // ── App lifecycle ──
    /// Quit the application.
    Quit,
    /// Clear the chat / activity log.
    ClearHistory,
    /// Clear the terminal scrollback.
    ClearTerminal,

    // ── Layout ──
    /// Toggle the sidebar between expanded and collapsed.
    ToggleSidebar,
    /// Switch between Chat and Autonomy modes.
    ToggleMode,
    /// Stop the active autonomy session.
    StopAutonomy,

    // ── Overlays ──
    /// Open the slash-command palette.
    OpenPalette,
    /// Open the transcript / pager overlay.
    OpenTranscript,
    /// Open the resume picker.
    OpenResumePicker,
    /// Open the user's `$EDITOR` for the current draft.
    OpenExternalEditor,

    // ── Scrolling ──
    /// Scroll one page up.
    ScrollPageUp,
    /// Scroll one page down.
    ScrollPageDown,
    /// Scroll one half-page up.
    ScrollHalfPageUp,
    /// Scroll one half-page down.
    ScrollHalfPageDown,
    /// Jump to the top of the chat / pager.
    ScrollHome,
    /// Jump to the bottom of the chat / pager.
    ScrollEnd,

    // ── Approvals ──
    /// Approve the current pending request once.
    ApproveOnce,
    /// Approve the current pending request and persist the suggested
    /// glob pattern.
    ApproveAlways,
    /// Deny the current pending request.
    Deny,
}

#[must_use]
pub fn key(self) -> &'static str;

#[derive(Debug, Error, PartialEq, Eq)]
pub enum KeySpecError {
    /// The spec is empty or whitespace-only.
    #[error("empty key spec")]
    Empty,
    /// A modifier token was not one of `ctrl`, `alt`, `shift`, `meta`.
    #[error("unknown modifier: {0}")]
    UnknownModifier(String),
    /// The terminal token did not name a key we know.
    #[error("unknown key: {0}")]
    UnknownKey(String),
    /// The chord referenced more than the supported two segments.
    #[error("chord too long: {0}")]
    ChordTooLong(String),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct KeyBinding {
/// Optional first half of a chord (`Ctrl+X` in `Ctrl+X Ctrl+E`).

/// `None` for non-chord bindings.

pub prefix: Option<KeyChordHalf>,
/// The terminal half (always set).

pub terminal: KeyChordHalf
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct KeyChordHalf {
/// The key code.

pub code: KeyCode,
/// Modifier mask.

pub modifiers: KeyModifiers
}

#[must_use]
pub fn single(code: KeyCode, modifiers: KeyModifiers) -> Self;

#[must_use]
pub fn chord(prefix: KeyChordHalf, terminal: KeyChordHalf) -> Self;

#[must_use]
pub fn is_chord(&self) -> bool;

#[must_use]
pub fn matches_event(&self, ev: &KeyEvent) -> bool;

#[must_use]
pub fn matches_prefix(&self, ev: &KeyEvent) -> bool;

pub fn parse_key_spec(spec: &str) -> Result<KeyBinding, KeySpecError>;

pub fn parse_key_spec_chord(spec: &str) -> Result<KeyBinding, KeySpecError>;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum KeymapContext {
    /// App-wide bindings always active (Ctrl+C quit, Ctrl+B sidebar
    /// toggle, …).
    App,
    /// Chat surface focused.
    Chat,
    /// Composer / input bar focused.
    Composer,
    /// Pager overlay open.
    Pager,
    /// Generic list picker (resume / theme / model / backtrack /
    /// component-tree).
    List,
    /// Approval modal up.
    Approval,
}

#[derive(Debug, Clone)]
pub struct ContextualKeymap {

}

#[must_use]
pub fn with_defaults() -> Self;

#[must_use]
pub fn for_context_mut(&mut self, ctx: KeymapContext) -> &mut Keymap;

#[must_use]
pub fn for_context(&self, ctx: KeymapContext) -> &Keymap;

#[must_use]
pub fn resolve(&self, ctx: KeymapContext, ev: &KeyEvent) -> Option<Action>;

pub fn apply_override(
        &mut self,
        ctx: KeymapContext,
        overrides: &std::collections::HashMap<Action, Vec<String>>,
    ) -> Result<(), KeymapError>;

pub use action::Action;

pub use binding::{parse_key_spec, parse_key_spec_chord, KeyBinding, KeySpecError};

pub use contextual::{ContextualKeymap, KeymapContext};

pub use runtime::{Keymap, KeymapError};

#[derive(Debug, Error)]
pub enum KeymapError {
    /// One of the override spec strings failed to parse.
    #[error("invalid key spec for {action:?}: {source}")]
    Spec {
        /// Which action's binding spec failed.
        action: Action,
        /// Original parse error.
        #[source]
        source: KeySpecError,
    },
}

#[derive(Debug, Clone)]
pub struct Keymap {

}

#[must_use]
pub fn with_defaults() -> Self;

#[must_use]
pub fn empty() -> Self;

pub fn from_overrides(overrides: &HashMap<Action, Vec<String>>) -> Result<Self, KeymapError>;

#[must_use]
pub fn bindings_for(&self, action: Action) -> &[KeyBinding];

#[must_use]
pub fn resolve(&self, ev: &KeyEvent) -> Option<Action>;

#[must_use]
pub fn resolve_chord_prefix(&self, ev: &KeyEvent) -> Option<Action>;

#[must_use]
pub fn resolve_chord_terminal(
        &self,
        prefix_event: &KeyEvent,
        terminal_event: &KeyEvent,
    ) -> Option<Action>;

pub mod adapter;

pub mod backtrack;

pub mod clipboard;

pub mod composer;

pub mod error;

pub mod external_editor;

pub mod harness;

pub mod keymap;

pub mod onboarding;

pub mod session;

pub mod settings;

pub mod types;

pub mod workspace;

pub mod interjection;

pub mod validation;

pub mod commands;

pub mod modes;

pub mod runtime;

pub mod screens;

pub mod adapters;

#[cfg(feature = "plugins")]
pub mod plugins;

pub use error::{AdapterError, ParseError, PluginError, SdkError};

pub use session::{
    JsonlSessionStore, SessionMetadata, SessionRecord, SessionRecordKind, SessionStore,
    SessionStoreError,
};

pub use keymap::{
    parse_key_spec, parse_key_spec_chord, Action, ContextualKeymap, KeyBinding, KeySpecError,
    Keymap, KeymapContext, KeymapError,
};

pub use backtrack::{list_backtrack_targets, rewind_to, BacktrackTarget};

pub use composer::{HistorySearch, MessageQueue, MessageQueueError, MESSAGE_QUEUE_CAPACITY};

pub use settings::{
    FlocksCli, ModeInfo, ModelInfo, ProviderInfo, ProviderKind, ProviderSettingField,
    ProviderSettingKind, ProviderSettingOption, SettingsAction, SettingsApplyResult,
    SettingsSnapshot,
};

pub use clipboard::{Clipboard, ClipboardError, MemoryClipboard, SystemClipboard};

pub use external_editor::{
    open_in_editor, open_with_command, resolve_editor_command, ExternalEditorError,
};

pub use onboarding::{OnboardingError, OnboardingFlow, OnboardingSelection, OnboardingStep};

pub use workspace::complete_workspace_paths;

pub use harness::{
    attribute, attribute_entry, AttributionDecision, AttributionVerdict, ChangeManifest,
    EvidenceCorpus, EvidenceCorpusError, HarnessComponentEdit, HarnessComponentEditKind,
    HarnessComponentKind, HarnessLoopError, HarnessLoopPhase, HarnessWorkspace,
    HarnessWorkspaceError, IterationRecord, ManifestEntry, OverviewReport, PredictedImpact,
    StandardHarnessLoop, TaskAnalysis, TaskDelta, TaskOutcome, TaskOutcomeMap,
    HARNESS_COMPONENT_KINDS,
};

pub use types::{
    ActivityLevel, AdapterCapabilities, AutonomyEvent, HumanInterjection, InterjectionAck,
    InterjectionKind, InterjectionPriority, Mode, ResponseChunk, SdkAgentInfo, SdkAgentStatus,
    SdkApprovalAction, SdkApprovalRequest, SdkRiskLevel, SdkRole, SessionInfo,
};

pub use types::{
    DEFAULT_MAX_MESSAGES, DEFAULT_STREAM_TIMEOUT, MAX_AGENT_ID_LEN, MAX_AGENT_NAME_LEN,
    MAX_CHUNK_SIZE, MAX_INTERJECTION_LEN, MAX_TOOL_INPUT_SIZE,
};

pub use adapter::AgentAdapter;

pub use runtime::app::{AgentApp, AgentAppBuilder};

pub use runtime::terminal_control::{
    clear_title, hyperlink, ring_bell, set_title, write_hyperlink, MAX_HYPERLINK_URL_LEN,
    MAX_TITLE_LEN,
};

pub use runtime::notifications::{
    KindMask, NotificationKind, Notifier, NotifierConfig, MAX_NOTIFICATION_LEN,
};

pub use screens::custom::{CustomScreen, ScreenEvent, ScreenResult};

pub use adapters::stdio::StdioAdapter;

#[cfg(feature = "http")]
pub use adapters::http::HttpAdapter;

pub async fn start_autonomy_session(
    state: &mut AppState,
    adapter: &Arc<dyn AgentAdapter>,
    instructions: &str,
) -> Result<futures::stream::BoxStream<'static, AutonomyEvent>, SdkError>;

pub async fn stop_autonomy_session(
    state: &mut AppState,
    adapter: &Arc<dyn AgentAdapter>,
) -> Result<(), SdkError>;

pub fn handle_autonomy_event(state: &mut AppState, event: AutonomyEvent) -> Result<(), SdkError>;

pub async fn submit_approval(
    state: &mut AppState,
    adapter: &Arc<dyn AgentAdapter>,
    request_id: &str,
    action: SdkApprovalAction,
) -> Result<(), SdkError>;