feat: add /btw, /fast, /insights, /steer, /queue commands and auxiliary model config (#926)

Author: penso

Cargo.lock

@@ -22,6 +22,12 @@ pub use {
     tool_result::{ExtractedImage, sanitize_tool_result, tool_result_to_content},
 };
 
+/// Shared inbox for mid-flight steering text (populated by `/steer` command).
+///
+/// The agent loop drains this between iterations and injects the text as a
+/// system notice so the LLM sees the guidance on its next call.
+pub type SteerInbox = std::sync::Arc<tokio::sync::Mutex<Vec<String>>>;
+
 // Re-export helpers at the module level so that sibling submodules
 // (`non_streaming`, `streaming`) can continue to import via `super::item_name`.
 pub(crate) use helpers::{

crates/agents/src/runner/mod.rs

@@ -61,6 +61,7 @@ pub async fn run_agent_loop_streaming(
     tool_context: Option<serde_json::Value>,
     hook_registry: Option<Arc<HookRegistry>>,
     sender_name: Option<String>,
+    steer_inbox: Option<super::SteerInbox>,
 ) -> Result<AgentRunResult, AgentRunError> {
     let native_tools = provider.supports_tools();
     let config = moltis_config::discover_and_load();
@@ -866,5 +867,19 @@ pub async fn run_agent_loop_streaming(
             &mut strip_tools_next_iter,
             on_event,
         );
+
+        // Drain any pending /steer text and inject as a system note.
+        // Uses system role to avoid consecutive-user-message violations
+        // with strict providers that enforce role alternation.
+        if let Some(ref inbox) = steer_inbox {
+            let mut guard = inbox.lock().await;
+            if !guard.is_empty() {
+                let combined = guard.drain(..).collect::<Vec<_>>().join("\n");
+                debug!(steer_text = %combined, "injecting /steer guidance");
+                messages.push(ChatMessage::system(format!(
+                    "[Steering note from the user — adjust your approach accordingly]: {combined}"
+                )));
+            }
+        }
     }
 }

crates/agents/src/runner/streaming.rs

@@ -198,6 +198,7 @@ async fn test_streaming_runner_preserves_cache_usage() {
         None,
         None,
         None,
+        None,
     )
     .await
     .unwrap();

crates/agents/src/runner/tests/basic.rs

@@ -34,6 +34,10 @@ pub fn all_commands() -> &'static [CommandDef] {
             name: "attach",
             description: "Attach an existing session here",
         },
+        CommandDef {
+            name: "fork",
+            description: "Fork this session into a new branch",
+        },
         CommandDef {
             name: "clear",
             description: "Clear session history",
@@ -91,6 +95,31 @@ pub fn all_commands() -> &'static [CommandDef] {
             name: "update",
             description: "Update moltis to latest or specified version",
         },
+        CommandDef {
+            name: "rollback",
+            description: "List or restore file checkpoints",
+        },
+        // Quick actions
+        CommandDef {
+            name: "btw",
+            description: "Quick side question (no tools, not persisted)",
+        },
+        CommandDef {
+            name: "fast",
+            description: "Toggle fast/priority mode",
+        },
+        CommandDef {
+            name: "insights",
+            description: "Show session analytics and usage stats",
+        },
+        CommandDef {
+            name: "steer",
+            description: "Inject guidance into the current agent run",
+        },
+        CommandDef {
+            name: "queue",
+            description: "Queue a message for the next agent turn",
+        },
         // Meta
         CommandDef {
             name: "help",
@@ -189,6 +218,7 @@ mod tests {
         let names: Vec<&str> = all_commands().iter().map(|c| c.name).collect();
         for expected in [
             "new",
+            "fork",
             "clear",
             "compact",
             "context",
@@ -205,6 +235,12 @@ mod tests {
             "stop",
             "peek",
             "update",
+            "rollback",
+            "btw",
+            "fast",
+            "insights",
+            "steer",
+            "queue",
             "help",
         ] {
             assert!(

crates/channels/src/commands.rs

@@ -159,9 +159,9 @@ fn warn_if_unused_auxiliary_model_config(config: &CompactionConfig) {
     tracing::warn!(
         summary_model = ?config.summary_model,
         max_summary_tokens = config.max_summary_tokens,
-        "chat.compact: chat.compaction.summary_model / max_summary_tokens are reserved \
-         for the auxiliary-model subsystem (beads issue moltis-8me) and have no effect \
-         on the structured strategy yet — the session's primary provider will be used"
+        "chat.compact: chat.compaction.summary_model / max_summary_tokens are not wired \
+         into the structured strategy yet — the session's primary provider will be used. \
+         Use `[auxiliary] compaction = \"model-id\"` for auxiliary model routing once wired"
     );
 }
 

crates/chat/src/compaction_run/structured.rs

@@ -847,6 +847,23 @@ pub(crate) async fn run_with_tools(
         runtime_context,
     );
 
+    // Create a shared steer inbox that the gateway can push steering text into.
+    // A background task polls the ChatRuntime and forwards any `/steer` text.
+    let steer_inbox: moltis_agents::runner::SteerInbox = Arc::new(Mutex::new(Vec::new()));
+    let steer_inbox_writer = steer_inbox.clone();
+    let steer_state = state.clone();
+    let steer_session_key = session_key.to_string();
+    let steer_task = tokio::spawn(async move {
+        // Drain any stale steering text left over from a previous run.
+        let _ = steer_state.take_steer_text(&steer_session_key).await;
+        loop {
+            tokio::time::sleep(Duration::from_millis(500)).await;
+            if let Some(texts) = steer_state.take_steer_text(&steer_session_key).await {
+                steer_inbox_writer.lock().await.extend(texts);
+            }
+        }
+    });
+
     let provider_ref = provider.clone();
     let first_result = run_agent_loop_streaming(
         provider,
@@ -858,6 +875,7 @@ pub(crate) async fn run_with_tools(
         Some(tool_context.clone()),
         hook_registry.clone(),
         sender_name.clone(),
+        Some(steer_inbox.clone()),
     )
     .await;
 
@@ -956,6 +974,7 @@ pub(crate) async fn run_with_tools(
                         Some(tool_context),
                         hook_registry,
                         sender_name,
+                        Some(steer_inbox.clone()),
                     )
                     .await
                 },
@@ -981,6 +1000,7 @@ pub(crate) async fn run_with_tools(
         },
         other => other,
     };
+    steer_task.abort();
 
     // Ensure all runner events (including deltas) are broadcast in order before
     // emitting terminal final/error frames.

crates/chat/src/run_with_tools.rs

@@ -158,4 +158,16 @@ pub trait ChatRuntime: Send + Sync {
 
     /// List currently connected remote nodes.
     async fn connected_nodes(&self) -> Vec<ConnectedNodeSummary>;
+
+    // ── Mid-flight steering ──────────────────────────────────────────────
+
+    /// Take (drain) all pending `/steer` texts for a session.
+    async fn take_steer_text(&self, _session_key: &str) -> Option<Vec<String>> {
+        None
+    }
+
+    /// Check whether fast/priority mode is enabled for a session.
+    async fn is_fast_mode(&self, _session_key: &str) -> bool {
+        false
+    }
 }

crates/chat/src/runtime.rs

@@ -255,6 +255,8 @@ pub struct MoltisConfig {
     pub caldav: CalDavConfig,
     pub home_assistant: HomeAssistantConfig,
     pub webhooks: WebhooksConfig,
+    /// Auxiliary model assignments for side tasks (compaction, titles, vision).
+    pub auxiliary: AuxiliaryModelsConfig,
     /// Code-index configuration for codebase search tools.
     pub code_index: CodeIndexTomlConfig,
     /// Per-model overrides that apply across all providers.

crates/config/src/schema.rs

@@ -297,3 +297,26 @@ pub enum ToolRegistryMode {
     /// Only `tool_search` is sent; the model discovers and activates tools on demand.
     Lazy,
 }
+
+/// Auxiliary model assignments for side tasks.
+///
+/// Route compression, title generation, and vision to cheaper/faster models
+/// while keeping the main session on a more capable model. Falls back to the
+/// session's primary provider when a field is `None`.
+///
+/// ```toml
+/// [auxiliary]
+/// compaction = "openrouter/google/gemini-2.5-flash"
+/// title_generation = "openrouter/google/gemini-2.5-flash"
+/// ```
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(default)]
+pub struct AuxiliaryModelsConfig {
+    /// Model for context compaction/summarization.
+    /// Overrides `chat.compaction.summary_model` when set.
+    pub compaction: Option<String>,
+    /// Model for session title generation.
+    pub title_generation: Option<String>,
+    /// Model for vision/image analysis tasks.
+    pub vision: Option<String>,
+}