Merge branch 'staging' into feat/nearai-mcp

# Conflicts:
#	src/app.rs

src/agent/agent_loop.rs

@@ -22,7 +22,7 @@ use crate::channels::{ChannelManager, IncomingMessage, OutgoingResponse};
 use crate::config::{AgentConfig, HeartbeatConfig, RoutineConfig, SkillsConfig};
 use crate::context::ContextManager;
 use crate::db::Database;
-use crate::error::Error;
+use crate::error::{ChannelError, Error};
 use crate::extensions::ExtensionManager;
 use crate::hooks::HookRegistry;
 use crate::llm::LlmProvider;
@@ -54,10 +54,75 @@ pub(crate) fn truncate_for_preview(output: &str, max_chars: usize) -> String {
     }
 }
 
+#[cfg(test)]
+fn resolve_routine_notification_user(metadata: &serde_json::Value) -> Option<String> {
+    resolve_owner_scope_notification_user(
+        metadata.get("notify_user").and_then(|value| value.as_str()),
+        metadata.get("owner_id").and_then(|value| value.as_str()),
+    )
+}
+
+fn trimmed_option(value: Option<&str>) -> Option<String> {
+    value
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(ToOwned::to_owned)
+}
+
+fn resolve_owner_scope_notification_user(
+    explicit_user: Option<&str>,
+    owner_fallback: Option<&str>,
+) -> Option<String> {
+    trimmed_option(explicit_user).or_else(|| trimmed_option(owner_fallback))
+}
+
+async fn resolve_channel_notification_user(
+    extension_manager: Option<&Arc<ExtensionManager>>,
+    channel: Option<&str>,
+    explicit_user: Option<&str>,
+    owner_fallback: Option<&str>,
+) -> Option<String> {
+    if let Some(user) = trimmed_option(explicit_user) {
+        return Some(user);
+    }
+
+    if let Some(channel_name) = trimmed_option(channel)
+        && let Some(extension_manager) = extension_manager
+        && let Some(target) = extension_manager
+            .notification_target_for_channel(&channel_name)
+            .await
+    {
+        return Some(target);
+    }
+
+    resolve_owner_scope_notification_user(explicit_user, owner_fallback)
+}
+
+async fn resolve_routine_notification_target(
+    extension_manager: Option<&Arc<ExtensionManager>>,
+    metadata: &serde_json::Value,
+) -> Option<String> {
+    resolve_channel_notification_user(
+        extension_manager,
+        metadata
+            .get("notify_channel")
+            .and_then(|value| value.as_str()),
+        metadata.get("notify_user").and_then(|value| value.as_str()),
+        metadata.get("owner_id").and_then(|value| value.as_str()),
+    )
+    .await
+}
+
+fn should_fallback_routine_notification(error: &ChannelError) -> bool {
+    !matches!(error, ChannelError::MissingRoutingTarget { .. })
+}
+
 /// Core dependencies for the agent.
 ///
 /// Bundles the shared components to reduce argument count.
 pub struct AgentDeps {
+    /// Resolved durable owner scope for the instance.
+    pub owner_id: String,
     pub store: Option<Arc<dyn Database>>,
     pub llm: Arc<dyn LlmProvider>,
     /// Cheap/fast LLM for lightweight tasks (heartbeat, routing, evaluation).
@@ -102,6 +167,18 @@ pub struct Agent {
 }
 
 impl Agent {
+    pub(super) fn owner_id(&self) -> &str {
+        if let Some(workspace) = self.deps.workspace.as_ref() {
+            debug_assert_eq!(
+                workspace.user_id(),
+                self.deps.owner_id,
+                "workspace.user_id() must stay aligned with deps.owner_id"
+            );
+        }
+
+        &self.deps.owner_id
+    }
+
     /// Create a new agent.
     ///
     /// Optionally accepts pre-created `ContextManager` and `SessionManager` for sharing
@@ -264,6 +341,7 @@ impl Agent {
         ));
         let repair_interval = self.config.repair_check_interval;
         let repair_channels = self.channels.clone();
+        let repair_owner_id = self.owner_id().to_string();
         let repair_handle = tokio::spawn(async move {
             loop {
                 tokio::time::sleep(repair_interval).await;
@@ -311,7 +389,9 @@ impl Agent {
 
                     if let Some(msg) = notification {
                         let response = OutgoingResponse::text(format!("Self-Repair: {}", msg));
-                        let _ = repair_channels.broadcast_all("default", response).await;
+                        let _ = repair_channels
+                            .broadcast_all(&repair_owner_id, response)
+                            .await;
                     }
                 }
 
@@ -325,7 +405,9 @@ impl Agent {
                                 "Self-Repair: Tool '{}' repaired: {}",
                                 tool.name, message
                             ));
-                            let _ = repair_channels.broadcast_all("default", response).await;
+                            let _ = repair_channels
+                                .broadcast_all(&repair_owner_id, response)
+                                .await;
                         }
                         Ok(result) => {
                             tracing::info!("Tool repair result: {:?}", result);
@@ -362,8 +444,12 @@ impl Agent {
                         .timezone
                         .clone()
                         .or_else(|| Some(self.config.default_timezone.clone()));
-                    if let (Some(user), Some(channel)) =
-                        (&hb_config.notify_user, &hb_config.notify_channel)
+                    let heartbeat_notify_user = resolve_owner_scope_notification_user(
+                        hb_config.notify_user.as_deref(),
+                        Some(self.owner_id()),
+                    );
+                    if let Some(channel) = &hb_config.notify_channel
+                        && let Some(user) = heartbeat_notify_user.as_deref()
                     {
                         config = config.with_notify(user, channel);
                     }
@@ -374,15 +460,22 @@ impl Agent {
 
                     // Spawn notification forwarder that routes through channel manager
                     let notify_channel = hb_config.notify_channel.clone();
-                    let notify_user = hb_config.notify_user.clone();
+                    let notify_target = resolve_channel_notification_user(
+                        self.deps.extension_manager.as_ref(),
+                        hb_config.notify_channel.as_deref(),
+                        hb_config.notify_user.as_deref(),
+                        Some(self.owner_id()),
+                    )
+                    .await;
+                    let notify_user = heartbeat_notify_user;
                     let channels = self.channels.clone();
                     tokio::spawn(async move {
                         while let Some(response) = notify_rx.recv().await {
-                            let user = notify_user.as_deref().unwrap_or("default");
-
                             // Try the configured channel first, fall back to
                             // broadcasting on all channels.
-                            let targeted_ok = if let Some(ref channel) = notify_channel {
+                            let targeted_ok = if let Some(ref channel) = notify_channel
+                                && let Some(ref user) = notify_target
+                            {
                                 channels
                                     .broadcast(channel, user, response.clone())
                                     .await
@@ -391,7 +484,7 @@ impl Agent {
                                 false
                             };
 
-                            if !targeted_ok {
+                            if !targeted_ok && let Some(ref user) = notify_user {
                                 let results = channels.broadcast_all(user, response).await;
                                 for (ch, result) in results {
                                     if let Err(e) = result {
@@ -460,32 +553,60 @@ impl Agent {
 
                     // Spawn notification forwarder (mirrors heartbeat pattern)
                     let channels = self.channels.clone();
+                    let extension_manager = self.deps.extension_manager.clone();
                     tokio::spawn(async move {
                         while let Some(response) = notify_rx.recv().await {
-                            let user = response
-                                .metadata
-                                .get("notify_user")
-                                .and_then(|v| v.as_str())
-                                .unwrap_or("default")
-                                .to_string();
                             let notify_channel = response
                                 .metadata
                                 .get("notify_channel")
                                 .and_then(|v| v.as_str())
                                 .map(|s| s.to_string());
+                            let fallback_user = resolve_owner_scope_notification_user(
+                                response
+                                    .metadata
+                                    .get("notify_user")
+                                    .and_then(|v| v.as_str()),
+                                response.metadata.get("owner_id").and_then(|v| v.as_str()),
+                            );
+                            let Some(user) = resolve_routine_notification_target(
+                                extension_manager.as_ref(),
+                                &response.metadata,
+                            )
+                            .await
+                            else {
+                                tracing::warn!(
+                                    notify_channel = ?notify_channel,
+                                    "Skipping routine notification with no explicit target or owner scope"
+                                );
+                                continue;
+                            };
 
                             // Try the configured channel first, fall back to
                             // broadcasting on all channels.
                             let targeted_ok = if let Some(ref channel) = notify_channel {
-                                channels
-                                    .broadcast(channel, &user, response.clone())
-                                    .await
-                                    .is_ok()
+                                match channels.broadcast(channel, &user, response.clone()).await {
+                                    Ok(()) => true,
+                                    Err(e) => {
+                                        let should_fallback =
+                                            should_fallback_routine_notification(&e);
+                                        tracing::warn!(
+                                            channel = %channel,
+                                            user = %user,
+                                            error = %e,
+                                            should_fallback,
+                                            "Failed to send routine notification to configured channel"
+                                        );
+                                        if !should_fallback {
+                                            continue;
+                                        }
+                                        false
+                                    }
+                                }
                             } else {
                                 false
                             };
 
-                            if !targeted_ok {
+                            if !targeted_ok && let Some(user) = fallback_user {
                                 let results = channels.broadcast_all(&user, response).await;
                                 for (ch, result) in results {
                                     if let Err(e) = result {
@@ -572,6 +693,29 @@ impl Agent {
             // Store successfully extracted document text in workspace for indexing
             self.store_extracted_documents(&message).await;
 
+            // Event-triggered routines consume plain user input before it enters
+            // the normal chat/tool pipeline. This avoids a duplicate turn where
+            // the main agent responds and the routine also fires on the same
+            // inbound message.
+            if !message.is_internal
+                && matches!(
+                    SubmissionParser::parse(&message.content),
+                    Submission::UserInput { .. }
+                )
+                && let Some(ref engine) = routine_engine_for_loop
+            {
+                let fired = engine.check_event_triggers(&message).await;
+                if fired > 0 {
+                    tracing::debug!(
+                        channel = %message.channel,
+                        user = %message.user_id,
+                        fired,
+                        "Consumed inbound user message with matching event-triggered routine(s)"
+                    );
+                    continue;
+                }
+            }
+
             match self.handle_message(&message).await {
                 Ok(Some(response)) if !response.is_empty() => {
                     // Hook: BeforeOutbound — allow hooks to modify or suppress outbound
@@ -644,14 +788,6 @@ impl Agent {
                     }
                 }
             }
-
-            // Check event triggers (cheap in-memory regex, fires async if matched)
-            if let Some(ref engine) = routine_engine_for_loop {
-                let fired = engine.check_event_triggers(&message).await;
-                if fired > 0 {
-                    tracing::debug!("Fired {} event-triggered routines", fired);
-                }
-            }
         }
 
         // Cleanup
@@ -768,10 +904,7 @@ impl Agent {
         // For Signal, use signal_target from metadata (group:ID or phone number),
         // otherwise fall back to user_id
         let target = message
-            .metadata
-            .get("signal_target")
-            .and_then(|v| v.as_str())
-            .map(|s| s.to_string())
+            .routing_target()
             .unwrap_or_else(|| message.user_id.clone());
         self.tools()
             .set_message_tool_context(Some(message.channel.clone()), Some(target))
@@ -811,7 +944,7 @@ impl Agent {
         }
 
         // Hydrate thread from DB if it's a historical thread not in memory
-        if let Some(ref external_thread_id) = message.thread_id {
+        if let Some(external_thread_id) = message.conversation_scope() {
             tracing::trace!(
                 message_id = %message.id,
                 thread_id = %external_thread_id,
@@ -832,7 +965,7 @@ impl Agent {
             .resolve_thread(
                 &message.user_id,
                 &message.channel,
-                message.thread_id.as_deref(),
+                message.conversation_scope(),
             )
             .await;
         tracing::debug!(
@@ -985,7 +1118,11 @@ impl Agent {
 
 #[cfg(test)]
 mod tests {
-    use super::truncate_for_preview;
+    use super::{
+        resolve_routine_notification_user, should_fallback_routine_notification,
+        truncate_for_preview,
+    };
+    use crate::error::ChannelError;
 
     #[test]
     fn test_truncate_short_input() {
@@ -1048,4 +1185,55 @@ mod tests {
         // 'h','e','l','l','o',' ','世','界' = 8 chars
         assert_eq!(result, "hello 世界...");
     }
+
+    #[test]
+    fn resolve_routine_notification_user_prefers_explicit_target() {
+        let metadata = serde_json::json!({
+            "notify_user": "12345",
+            "owner_id": "owner-scope",
+        });
+
+        let resolved = resolve_routine_notification_user(&metadata);
+        assert_eq!(resolved.as_deref(), Some("12345")); // safety: test-only assertion
+    }
+
+    #[test]
+    fn resolve_routine_notification_user_falls_back_to_owner_scope() {
+        let metadata = serde_json::json!({
+            "notify_user": null,
+            "owner_id": "owner-scope",
+        });
+
+        let resolved = resolve_routine_notification_user(&metadata);
+        assert_eq!(resolved.as_deref(), Some("owner-scope")); // safety: test-only assertion
+    }
+
+    #[test]
+    fn resolve_routine_notification_user_rejects_missing_values() {
+        let metadata = serde_json::json!({
+            "notify_user": "   ",
+        });
+
+        assert_eq!(resolve_routine_notification_user(&metadata), None); // safety: test-only assertion
+    }
+
+    #[test]
+    fn targeted_routine_notifications_do_not_fallback_without_owner_route() {
+        let error = ChannelError::MissingRoutingTarget {
+            name: "telegram".to_string(),
+            reason: "No stored owner routing target for channel 'telegram'.".to_string(),
+        };
+
+        assert!(!should_fallback_routine_notification(&error)); // safety: test-only assertion
+    }
+
+    #[test]
+    fn targeted_routine_notifications_may_fallback_for_other_errors() {
+        let error = ChannelError::SendFailed {
+            name: "telegram".to_string(),
+            reason: "timeout talking to channel".to_string(),
+        };
+
+        assert!(should_fallback_routine_notification(&error)); // safety: test-only assertion
+    }
 }

src/agent/commands.rs

@@ -836,7 +836,10 @@ impl Agent {
         // 1. Persist to DB if available.
         if let Some(store) = self.store() {
             let value = serde_json::Value::String(model.to_string());
-            if let Err(e) = store.set_setting("default", "selected_model", &value).await {
+            if let Err(e) = store
+                .set_setting(self.owner_id(), "selected_model", &value)
+                .await
+            {
                 tracing::warn!("Failed to persist model to DB: {}", e);
             }
         }

src/agent/dispatcher.rs

@@ -140,13 +140,15 @@ impl Agent {
 
         // Create a JobContext for tool execution (chat doesn't have a real job)
         let mut job_ctx =
-            JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+            JobContext::with_user(&message.user_id, "chat", "Interactive chat session")
+                .with_requester_id(&message.sender_id);
         job_ctx.http_interceptor = self.deps.http_interceptor.clone();
         job_ctx.user_timezone = user_tz.name().to_string();
         job_ctx.metadata = serde_json::json!({
             "notify_channel": message.channel,
             "notify_user": message.user_id,
             "notify_thread_id": message.thread_id,
+            "notify_metadata": message.metadata,
         });
 
         // Build system prompts once for this turn. Two variants: with tools
@@ -1175,6 +1177,7 @@ mod tests {
     /// Build a minimal `Agent` for unit testing (no DB, no workspace, no extensions).
     fn make_test_agent() -> Agent {
         let deps = AgentDeps {
+            owner_id: "default".to_string(),
             store: None,
             llm: Arc::new(StaticLlmProvider),
             cheap_llm: None,
@@ -2014,6 +2017,7 @@ mod tests {
     /// `max_tool_iterations` override.
     fn make_test_agent_with_llm(llm: Arc<dyn LlmProvider>, max_tool_iterations: usize) -> Agent {
         let deps = AgentDeps {
+            owner_id: "default".to_string(),
             store: None,
             llm,
             cheap_llm: None,
@@ -2127,6 +2131,7 @@ mod tests {
         let max_iter = 3;
         let agent = {
             let deps = AgentDeps {
+                owner_id: "default".to_string(),
                 store: None,
                 llm,
                 cheap_llm: None,

src/agent/heartbeat.rs

@@ -402,7 +402,11 @@ impl HeartbeatRunner {
             return;
         };
 
-        let user_id = self.config.notify_user_id.as_deref().unwrap_or("default");
+        let user_id = self
+            .config
+            .notify_user_id
+            .as_deref()
+            .unwrap_or_else(|| self.workspace.user_id());
 
         // Persist to heartbeat conversation and get thread_id
         let thread_id = if let Some(ref store) = self.store {
@@ -431,6 +435,7 @@ impl HeartbeatRunner {
             attachments: Vec::new(),
             metadata: serde_json::json!({
                 "source": "heartbeat",
+                "owner_id": self.workspace.user_id(),
             }),
         };
 

src/agent/routine.rs

@@ -422,8 +422,8 @@ impl Default for RoutineGuardrails {
 pub struct NotifyConfig {
     /// Channel to notify on (None = default/broadcast all).
     pub channel: Option<String>,
-    /// User to notify.
-    pub user: String,
+    /// Explicit target to notify. None means "resolve the owner's last-seen target".
+    pub user: Option<String>,
     /// Notify when routine produces actionable output.
     pub on_attention: bool,
     /// Notify when routine errors.
@@ -436,7 +436,7 @@ impl Default for NotifyConfig {
     fn default() -> Self {
         Self {
             channel: None,
-            user: "default".to_string(),
+            user: None,
             on_attention: true,
             on_failure: true,
             on_success: false,

src/agent/routine_engine.rs

@@ -172,6 +172,11 @@ impl RoutineEngine {
                 EventMatcher::Message { routine, regex } => (routine, regex),
                 EventMatcher::System { .. } => continue,
             };
+
+            if routine.user_id != message.user_id {
+                continue;
+            }
+
             // Channel filter
             if let Trigger::Event {
                 channel: Some(ch), ..
@@ -650,6 +655,7 @@ async fn execute_routine(ctx: EngineContext, routine: Routine, run: RoutineRun)
     send_notification(
         &ctx.notify_tx,
         &routine.notify,
+        &routine.user_id,
         &routine.name,
         status,
         summary.as_deref(),
@@ -694,7 +700,8 @@ async fn execute_full_job(
             reason: "scheduler not available".to_string(),
         })?;
 
-    let mut metadata = serde_json::json!({ "max_iterations": max_iterations });
+    let mut metadata =
+        serde_json::json!({ "max_iterations": max_iterations, "owner_id": routine.user_id });
     // Carry the routine's notify config in job metadata so the message tool
     // can resolve channel/target per-job without global state mutation.
     if let Some(channel) = &routine.notify.channel {
@@ -1207,6 +1214,7 @@ async fn execute_routine_tool(
 async fn send_notification(
     tx: &mpsc::Sender<OutgoingResponse>,
     notify: &NotifyConfig,
+    owner_id: &str,
     routine_name: &str,
     status: RunStatus,
     summary: Option<&str>,
@@ -1243,6 +1251,7 @@ async fn send_notification(
             "source": "routine",
             "routine_name": routine_name,
             "status": status.to_string(),
+            "owner_id": owner_id,
             "notify_user": notify.user,
             "notify_channel": notify.channel,
         }),

src/agent/submission.rs

@@ -427,6 +427,14 @@ impl SubmissionResult {
             message: message.into(),
         }
     }
+
+    /// Create a non-error status message (e.g., for blocking states like approval waiting).
+    /// Uses Ok variant to avoid "Error:" prefix in rendering.
+    pub fn pending(message: impl Into<String>) -> Self {
+        Self::Ok {
+            message: Some(message.into()),
+        }
+    }
 }
 
 #[cfg(test)]

src/agent/thread_ops.rs

@@ -187,13 +187,18 @@ impl Agent {
         );
 
         // First check thread state without holding lock during I/O
-        let thread_state = {
+        let (thread_state, approval_context) = {
             let sess = session.lock().await;
             let thread = sess
                 .threads
                 .get(&thread_id)
                 .ok_or_else(|| Error::from(crate::error::JobError::NotFound { id: thread_id }))?;
-            thread.state
+            let approval_context = thread.pending_approval.as_ref().map(|a| {
+                let desc_preview =
+                    crate::agent::agent_loop::truncate_for_preview(&a.description, 80);
+                (a.tool_name.clone(), desc_preview)
+            });
+            (thread.state, approval_context)
         };
 
         tracing::debug!(
@@ -221,9 +226,13 @@ impl Agent {
                     thread_id = %thread_id,
                     "Thread awaiting approval, rejecting new input"
                 );
-                return Ok(SubmissionResult::error(
-                    "Waiting for approval. Use /interrupt to cancel.",
-                ));
+                let msg = match approval_context {
+                    Some((tool_name, desc_preview)) => format!(
+                        "Waiting for approval: {tool_name} — {desc_preview}. Use /interrupt to cancel."
+                    ),
+                    None => "Waiting for approval. Use /interrupt to cancel.".to_string(),
+                };
+                return Ok(SubmissionResult::pending(msg));
             }
             ThreadState::Completed => {
                 tracing::warn!(
@@ -924,7 +933,8 @@ impl Agent {
 
             // Execute the approved tool and continue the loop
             let mut job_ctx =
-                JobContext::with_user(&message.user_id, "chat", "Interactive chat session");
+                JobContext::with_user(&message.user_id, "chat", "Interactive chat session")
+                    .with_requester_id(&message.sender_id);
             job_ctx.http_interceptor = self.deps.http_interceptor.clone();
             // Prefer a valid timezone from the approval message, fall back to the
             // resolved timezone stored when the approval was originally requested.
@@ -1916,4 +1926,103 @@ mod tests {
             created_at: chrono::Utc::now(),
         }
     }
+
+    #[tokio::test]
+    async fn test_awaiting_approval_rejection_includes_tool_context() {
+        // Test that when a thread is in AwaitingApproval state and receives a new message,
+        // process_user_input rejects it with a non-error status that includes tool context.
+        use crate::agent::session::{PendingApproval, Session, Thread, ThreadState};
+        use uuid::Uuid;
+
+        let session_id = Uuid::new_v4();
+        let thread_id = Uuid::new_v4();
+        let mut thread = Thread::with_id(thread_id, session_id);
+
+        // Set thread to AwaitingApproval with a pending tool approval
+        let pending = PendingApproval {
+            request_id: Uuid::new_v4(),
+            tool_name: "shell".to_string(),
+            parameters: serde_json::json!({"command": "echo hello"}),
+            display_parameters: serde_json::json!({"command": "[REDACTED]"}),
+            description: "Execute: echo hello".to_string(),
+            tool_call_id: "call_0".to_string(),
+            context_messages: vec![],
+            deferred_tool_calls: vec![],
+            user_timezone: None,
+        };
+        thread.await_approval(pending);
+
+        let mut session = Session::new("test-user");
+        session.threads.insert(thread_id, thread);
+
+        // Verify thread is in AwaitingApproval state
+        assert_eq!(
+            session.threads[&thread_id].state,
+            ThreadState::AwaitingApproval
+        );
+
+        let result = extract_approval_message(&session, thread_id);
+
+        // Verify result is an Ok with a message (not an Error)
+        match result {
+            Ok(Some(msg)) => {
+                // Should NOT start with "Error:"
+                assert!(
+                    !msg.to_lowercase().starts_with("error:"),
+                    "Approval rejection should not have 'Error:' prefix. Got: {}",
+                    msg
+                );
+
+                // Should contain "waiting for approval"
+                assert!(
+                    msg.to_lowercase().contains("waiting for approval"),
+                    "Should contain 'waiting for approval'. Got: {}",
+                    msg
+                );
+
+                // Should contain the tool name
+                assert!(
+                    msg.contains("shell"),
+                    "Should contain tool name 'shell'. Got: {}",
+                    msg
+                );
+
+                // Should contain the description (or truncated version)
+                assert!(
+                    msg.contains("echo hello"),
+                    "Should contain description 'echo hello'. Got: {}",
+                    msg
+                );
+            }
+            _ => panic!("Expected approval rejection message"),
+        }
+    }
+
+    // Helper function to extract the approval message without needing a full Agent instance
+    fn extract_approval_message(
+        session: &crate::agent::session::Session,
+        thread_id: Uuid,
+    ) -> Result<Option<String>, crate::error::Error> {
+        let thread = session.threads.get(&thread_id).ok_or_else(|| {
+            crate::error::Error::from(crate::error::JobError::NotFound { id: thread_id })
+        })?;
+
+        if thread.state == ThreadState::AwaitingApproval {
+            let approval_context = thread.pending_approval.as_ref().map(|a| {
+                let desc_preview =
+                    crate::agent::agent_loop::truncate_for_preview(&a.description, 80);
+                (a.tool_name.clone(), desc_preview)
+            });
+
+            let msg = match approval_context {
+                Some((tool_name, desc_preview)) => format!(
+                    "Waiting for approval: {tool_name} — {desc_preview}. Use /interrupt to cancel."
+                ),
+                None => "Waiting for approval. Use /interrupt to cancel.".to_string(),
+            };
+            Ok(Some(msg))
+        } else {
+            Ok(None)
+        }
+    }
 }

src/app.rs

@@ -140,12 +140,14 @@ impl AppBuilder {
         self.handles = Some(handles);
 
         // Post-init: migrate disk config, reload config from DB, attach session, cleanup
-        if let Err(e) = crate::bootstrap::migrate_disk_to_db(db.as_ref(), "default").await {
+        if let Err(e) =
+            crate::bootstrap::migrate_disk_to_db(db.as_ref(), &self.config.owner_id).await
+        {
             tracing::warn!("Disk-to-DB settings migration failed: {}", e);
         }
 
         let toml_path = self.toml_path.as_deref();
-        match Config::from_db_with_toml(db.as_ref(), "default", toml_path).await {
+        match Config::from_db_with_toml(db.as_ref(), &self.config.owner_id, toml_path).await {
             Ok(db_config) => {
                 self.config = db_config;
                 tracing::debug!("Configuration reloaded from database");
@@ -158,7 +160,9 @@ impl AppBuilder {
             }
         }
 
-        self.session.attach_store(db.clone(), "default").await;
+        self.session
+            .attach_store(db.clone(), &self.config.owner_id)
+            .await;
 
         // Fire-and-forget housekeeping — no need to block startup.
         let db_cleanup = db.clone();
@@ -193,9 +197,10 @@ impl AppBuilder {
                 let store: Option<&(dyn crate::db::SettingsStore + Sync)> =
                     self.db.as_ref().map(|db| db.as_ref() as _);
                 let toml_path = self.toml_path.as_deref();
+                let owner_id = self.config.owner_id.clone();
                 if let Err(e) = self
                     .config
-                    .re_resolve_llm(store, "default", toml_path)
+                    .re_resolve_llm(store, &owner_id, toml_path)
                     .await
                 {
                     tracing::warn!(
@@ -224,15 +229,17 @@ impl AppBuilder {
 
         if let Some(ref secrets) = store {
             // Inject LLM API keys from encrypted storage
-            crate::config::inject_llm_keys_from_secrets(secrets.as_ref(), "default").await;
+            crate::config::inject_llm_keys_from_secrets(secrets.as_ref(), &self.config.owner_id)
+                .await;
 
             // Re-resolve only the LLM config with newly available keys.
             let store: Option<&(dyn crate::db::SettingsStore + Sync)> =
                 self.db.as_ref().map(|db| db.as_ref() as _);
             let toml_path = self.toml_path.as_deref();
+            let owner_id = self.config.owner_id.clone();
             if let Err(e) = self
                 .config
-                .re_resolve_llm(store, "default", toml_path)
+                .re_resolve_llm(store, &owner_id, toml_path)
                 .await
             {
                 tracing::warn!("Failed to re-resolve LLM config after secret injection: {e}");
@@ -304,7 +311,7 @@ impl AppBuilder {
 
         // Register memory tools if database is available
         let workspace = if let Some(ref db) = self.db {
-            let mut ws = Workspace::new_with_db("default", db.clone())
+            let mut ws = Workspace::new_with_db(&self.config.owner_id, db.clone())
                 .with_search_config(&self.config.search);
             if let Some(ref emb) = embeddings {
                 ws = ws.with_embeddings(emb.clone());
@@ -471,10 +478,11 @@ impl AppBuilder {
             let tools = Arc::clone(tools);
             let mcp_sm = Arc::clone(&mcp_session_manager);
             let pm = Arc::clone(&mcp_process_manager);
+            let owner_id = self.config.owner_id.clone();
             let companion_mcp_server = companion_mcp_server.clone();
             async move {
                 let servers_result = if let Some(ref d) = db {
-                    load_mcp_servers_from_db(d.as_ref(), "default").await
+                    load_mcp_servers_from_db(d.as_ref(), &owner_id).await
                 } else {
                     crate::tools::mcp::config::load_mcp_servers().await
                 };
@@ -505,6 +513,7 @@ impl AppBuilder {
                             let secrets = secrets_store.clone();
                             let tools = Arc::clone(&tools);
                             let pm = Arc::clone(&pm);
+                            let owner_id = owner_id.clone();
 
                             join_set.spawn(async move {
                                 let server_name = server.name.clone();
@@ -516,7 +525,7 @@ impl AppBuilder {
                                     nearai_api_key,
                                     &pm,
                                     secrets,
-                                    "default",
+                                    &owner_id,
                                 )
                                 .await
                                 {
@@ -660,7 +669,7 @@ impl AppBuilder {
                 self.config.wasm.tools_dir.clone(),
                 self.config.channels.wasm_channels_dir.clone(),
                 self.config.tunnel.public_url.clone(),
-                "default".to_string(),
+                self.config.owner_id.clone(),
                 self.db.clone(),
                 companion_mcp_server,
                 catalog_entries.clone(),

src/channels/channel.rs

@@ -67,14 +67,24 @@ pub struct IncomingMessage {
     pub id: Uuid,
     /// Channel this message came from.
     pub channel: String,
-    /// User identifier within the channel.
+    /// Storage/persistence scope for this interaction.
+    ///
+    /// For owner-capable channels this is the stable instance owner ID when the
+    /// configured owner is speaking; otherwise it can be a guest/sender-scoped
+    /// identifier to preserve isolation.
     pub user_id: String,
+    /// Stable instance owner scope for this IronClaw deployment.
+    pub owner_id: String,
+    /// Channel-specific sender/actor identifier.
+    pub sender_id: String,
     /// Optional display name.
     pub user_name: Option<String>,
     /// Message content.
     pub content: String,
     /// Thread/conversation ID for threaded conversations.
     pub thread_id: Option<String>,
+    /// Stable channel/chat/thread scope for this conversation.
+    pub conversation_scope_id: Option<String>,
     /// When the message was received.
     pub received_at: DateTime<Utc>,
     /// Channel-specific metadata.
@@ -84,9 +94,8 @@ pub struct IncomingMessage {
     /// File or media attachments on this message.
     pub attachments: Vec<IncomingAttachment>,
     /// Internal-only flag: message was generated inside the process (e.g. job
-    /// monitor) and must bypass the normal user-input pipeline.  This field is
-    /// **not** settable via `with_metadata()` — only trusted code paths inside
-    /// the binary can set it, preventing external channels from spoofing it.
+    /// monitor) and must bypass the normal user-input pipeline. This field is
+    /// not settable via metadata, so external channels cannot spoof it.
     pub(crate) is_internal: bool,
 }
 
@@ -97,13 +106,17 @@ impl IncomingMessage {
         user_id: impl Into<String>,
         content: impl Into<String>,
     ) -> Self {
+        let user_id = user_id.into();
         Self {
             id: Uuid::new_v4(),
             channel: channel.into(),
-            user_id: user_id.into(),
+            owner_id: user_id.clone(),
+            sender_id: user_id.clone(),
+            user_id,
             user_name: None,
             content: content.into(),
             thread_id: None,
+            conversation_scope_id: None,
             received_at: Utc::now(),
             metadata: serde_json::Value::Null,
             timezone: None,
@@ -114,7 +127,27 @@ impl IncomingMessage {
 
     /// Set the thread ID.
     pub fn with_thread(mut self, thread_id: impl Into<String>) -> Self {
-        self.thread_id = Some(thread_id.into());
+        let thread_id = thread_id.into();
+        self.conversation_scope_id = Some(thread_id.clone());
+        self.thread_id = Some(thread_id);
+        self
+    }
+
+    /// Set the stable owner scope for this message.
+    pub fn with_owner_id(mut self, owner_id: impl Into<String>) -> Self {
+        self.owner_id = owner_id.into();
+        self
+    }
+
+    /// Set the channel-specific sender/actor identifier.
+    pub fn with_sender_id(mut self, sender_id: impl Into<String>) -> Self {
+        self.sender_id = sender_id.into();
+        self
+    }
+
+    /// Set the conversation scope for this message.
+    pub fn with_conversation_scope(mut self, scope_id: impl Into<String>) -> Self {
+        self.conversation_scope_id = Some(scope_id.into());
         self
     }
 
@@ -147,6 +180,49 @@ impl IncomingMessage {
         self.is_internal = true;
         self
     }
+
+    /// Effective conversation scope, falling back to thread_id for legacy callers.
+    pub fn conversation_scope(&self) -> Option<&str> {
+        self.conversation_scope_id
+            .as_deref()
+            .or(self.thread_id.as_deref())
+    }
+
+    /// Best-effort routing target for proactive replies on the current channel.
+    pub fn routing_target(&self) -> Option<String> {
+        routing_target_from_metadata(&self.metadata).or_else(|| {
+            if self.sender_id.is_empty() {
+                None
+            } else {
+                Some(self.sender_id.clone())
+            }
+        })
+    }
+}
+
+/// Extract a channel-specific proactive routing target from message metadata.
+pub fn routing_target_from_metadata(metadata: &serde_json::Value) -> Option<String> {
+    metadata
+        .get("signal_target")
+        .and_then(|value| match value {
+            serde_json::Value::String(s) => Some(s.clone()),
+            serde_json::Value::Number(n) => Some(n.to_string()),
+            _ => None,
+        })
+        .or_else(|| {
+            metadata.get("chat_id").and_then(|value| match value {
+                serde_json::Value::String(s) => Some(s.clone()),
+                serde_json::Value::Number(n) => Some(n.to_string()),
+                _ => None,
+            })
+        })
+        .or_else(|| {
+            metadata.get("target").and_then(|value| match value {
+                serde_json::Value::String(s) => Some(s.clone()),
+                serde_json::Value::Number(n) => Some(n.to_string()),
+                _ => None,
+            })
+        })
 }
 
 /// Stream of incoming messages.

src/channels/http.rs

@@ -133,7 +133,8 @@ impl HttpChannel {
 
 #[derive(Debug, Deserialize)]
 struct WebhookRequest {
-    /// User or client identifier (ignored, user is fixed by server config).
+    /// Optional caller or client identifier for sender-scoped routing.
+    /// The channel owner/storage scope remains fixed by server config.
     #[serde(default)]
     user_id: Option<String>,
     /// Message content.
@@ -403,12 +404,38 @@ async fn process_authenticated_request(
     state: Arc<HttpChannelState>,
     req: WebhookRequest,
 ) -> axum::response::Response {
-    let _ = req.user_id.as_ref().map(|user_id| {
-        tracing::debug!(
-            provided_user_id = %user_id,
-            "HTTP webhook request provided user_id, ignoring in favor of configured user_id"
-        );
-    });
+    let normalized_user_id = req
+        .user_id
+        .as_deref()
+        .map(str::trim)
+        .filter(|user_id| !user_id.is_empty());
+
+    match (req.user_id.as_deref(), normalized_user_id) {
+        (Some(raw_user_id), Some(user_id)) if raw_user_id != user_id => {
+            tracing::debug!(
+                provided_user_id = %raw_user_id,
+                normalized_sender_id = %user_id,
+                configured_owner_id = %state.user_id,
+                "HTTP webhook request provided user_id; trimming and using it as sender_id while keeping the configured owner scope"
+            );
+        }
+        (Some(user_id), Some(_)) => {
+            tracing::debug!(
+                provided_user_id = %user_id,
+                configured_owner_id = %state.user_id,
+                "HTTP webhook request provided user_id; using it as sender_id while keeping the configured owner scope"
+            );
+        }
+        (Some(raw_user_id), None) => {
+            tracing::debug!(
+                provided_user_id = %raw_user_id,
+                configured_owner_id = %state.user_id,
+                "HTTP webhook request provided a blank user_id; falling back to the configured owner scope for sender_id"
+            );
+        }
+        (None, None) => {}
+        (None, Some(_)) => unreachable!("normalized user_id requires a raw user_id"),
+    }
 
     if req.content.len() > MAX_CONTENT_BYTES {
         return (
@@ -514,11 +541,13 @@ async fn process_authenticated_request(
         Vec::new()
     };
 
-    let mut msg = IncomingMessage::new("http", &state.user_id, &req.content).with_metadata(
-        serde_json::json!({
+    let sender_id = normalized_user_id.unwrap_or(&state.user_id).to_string();
+    let mut msg = IncomingMessage::new("http", &state.user_id, &req.content)
+        .with_owner_id(&state.user_id)
+        .with_sender_id(sender_id)
+        .with_metadata(serde_json::json!({
             "wait_for_response": wait_for_response,
-        }),
-    );
+        }));
 
     if !attachments.is_empty() {
         msg = msg.with_attachments(attachments);
@@ -682,6 +711,7 @@ mod tests {
     use axum::body::Body;
     use axum::http::{HeaderValue, Request};
     use secrecy::SecretString;
+    use tokio_stream::StreamExt;
     use tower::ServiceExt;
 
     use super::*;
@@ -820,6 +850,70 @@ mod tests {
         assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
     }
 
+    #[tokio::test]
+    async fn webhook_blank_user_id_falls_back_to_owner_scope() {
+        let secret = "test-secret-123";
+        let channel = test_channel(Some(secret));
+        let mut stream = channel.start().await.unwrap();
+        let app = channel.routes();
+
+        let body = serde_json::json!({
+            "content": "hello",
+            "user_id": "   "
+        });
+        let body_bytes = serde_json::to_vec(&body).unwrap();
+        let signature = compute_signature(secret, &body_bytes);
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook")
+            .header("content-type", "application/json")
+            .header("x-hub-signature-256", signature)
+            .body(Body::from(body_bytes))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let msg = tokio::time::timeout(std::time::Duration::from_secs(1), stream.next())
+            .await
+            .expect("timed out waiting for webhook message")
+            .expect("stream should yield a webhook message");
+        assert_eq!(msg.sender_id, "http");
+        assert_eq!(msg.owner_id, "http");
+    }
+
+    #[tokio::test]
+    async fn webhook_user_id_is_trimmed_before_becoming_sender_id() {
+        let secret = "test-secret-123";
+        let channel = test_channel(Some(secret));
+        let mut stream = channel.start().await.unwrap();
+        let app = channel.routes();
+
+        let body = serde_json::json!({
+            "content": "hello",
+            "user_id": "  alice  "
+        });
+        let body_bytes = serde_json::to_vec(&body).unwrap();
+        let signature = compute_signature(secret, &body_bytes);
+        let req = Request::builder()
+            .method("POST")
+            .uri("/webhook")
+            .header("content-type", "application/json")
+            .header("x-hub-signature-256", signature)
+            .body(Body::from(body_bytes))
+            .unwrap();
+
+        let resp = app.oneshot(req).await.unwrap();
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let msg = tokio::time::timeout(std::time::Duration::from_secs(1), stream.next())
+            .await
+            .expect("timed out waiting for webhook message")
+            .expect("stream should yield a webhook message");
+        assert_eq!(msg.sender_id, "alice");
+        assert_eq!(msg.owner_id, "http");
+    }
+
     /// Regression test for issue #869: RwLock read guard was held across
     /// tx.send(msg).await in `process_message()`, blocking shutdown() from
     /// acquiring the write lock when the channel buffer was full.

src/channels/mod.rs

@@ -39,7 +39,7 @@ mod webhook_server;
 
 pub use channel::{
     AttachmentKind, Channel, ChannelSecretUpdater, IncomingAttachment, IncomingMessage,
-    MessageStream, OutgoingResponse, StatusUpdate,
+    MessageStream, OutgoingResponse, StatusUpdate, routing_target_from_metadata,
 };
 pub use http::{HttpChannel, HttpChannelState};
 pub use manager::ChannelManager;

src/channels/repl.rs

@@ -200,6 +200,8 @@ fn format_json_params(params: &serde_json::Value, indent: &str) -> String {
 
 /// REPL channel with line editing and markdown rendering.
 pub struct ReplChannel {
+    /// Stable owner scope for this REPL instance.
+    user_id: String,
     /// Optional single message to send (for -m flag).
     single_message: Option<String>,
     /// Debug mode flag (shared with input thread).
@@ -213,7 +215,13 @@ pub struct ReplChannel {
 impl ReplChannel {
     /// Create a new REPL channel.
     pub fn new() -> Self {
+        Self::with_user_id("default")
+    }
+
+    /// Create a new REPL channel for a specific owner scope.
+    pub fn with_user_id(user_id: impl Into<String>) -> Self {
         Self {
+            user_id: user_id.into(),
             single_message: None,
             debug_mode: Arc::new(AtomicBool::new(false)),
             is_streaming: Arc::new(AtomicBool::new(false)),
@@ -223,7 +231,13 @@ impl ReplChannel {
 
     /// Create a REPL channel that sends a single message and exits.
     pub fn with_message(message: String) -> Self {
+        Self::with_message_for_user("default", message)
+    }
+
+    /// Create a REPL channel that sends a single message for a specific owner scope and exits.
+    pub fn with_message_for_user(user_id: impl Into<String>, message: String) -> Self {
         Self {
+            user_id: user_id.into(),
             single_message: Some(message),
             debug_mode: Arc::new(AtomicBool::new(false)),
             is_streaming: Arc::new(AtomicBool::new(false)),
@@ -292,6 +306,7 @@ impl Channel for ReplChannel {
     async fn start(&self) -> Result<MessageStream, ChannelError> {
         let (tx, rx) = mpsc::channel(32);
         let single_message = self.single_message.clone();
+        let user_id = self.user_id.clone();
         let debug_mode = Arc::clone(&self.debug_mode);
         let suppress_banner = Arc::clone(&self.suppress_banner);
         let esc_interrupt_triggered_for_thread = Arc::new(AtomicBool::new(false));
@@ -301,11 +316,11 @@ impl Channel for ReplChannel {
 
             // Single message mode: send it and return
             if let Some(msg) = single_message {
-                let incoming = IncomingMessage::new("repl", "default", &msg).with_timezone(&sys_tz);
+                let incoming = IncomingMessage::new("repl", &user_id, &msg).with_timezone(&sys_tz);
                 let _ = tx.blocking_send(incoming);
                 // Ensure the agent exits after handling exactly one turn in -m mode,
                 // even when other channels (gateway/http) are enabled.
-                let _ = tx.blocking_send(IncomingMessage::new("repl", "default", "/quit"));
+                let _ = tx.blocking_send(IncomingMessage::new("repl", &user_id, "/quit"));
                 return;
             }
 
@@ -366,7 +381,7 @@ impl Channel for ReplChannel {
                             "/quit" | "/exit" => {
                                 // Forward shutdown command so the agent loop exits even
                                 // when other channels (e.g. web gateway) are still active.
-                                let msg = IncomingMessage::new("repl", "default", "/quit")
+                                let msg = IncomingMessage::new("repl", &user_id, "/quit")
                                     .with_timezone(&sys_tz);
                                 let _ = tx.blocking_send(msg);
                                 break;
@@ -389,7 +404,7 @@ impl Channel for ReplChannel {
                         }
 
                         let msg =
-                            IncomingMessage::new("repl", "default", line).with_timezone(&sys_tz);
+                            IncomingMessage::new("repl", &user_id, line).with_timezone(&sys_tz);
                         if tx.blocking_send(msg).is_err() {
                             break;
                         }
@@ -397,14 +412,14 @@ impl Channel for ReplChannel {
                     Err(ReadlineError::Interrupted) => {
                         if esc_interrupt_triggered_for_thread.swap(false, Ordering::Relaxed) {
                             // Esc: interrupt current operation and keep REPL open.
-                            let msg = IncomingMessage::new("repl", "default", "/interrupt")
+                            let msg = IncomingMessage::new("repl", &user_id, "/interrupt")
                                 .with_timezone(&sys_tz);
                             if tx.blocking_send(msg).is_err() {
                                 break;
                             }
                         } else {
                             // Ctrl+C (VINTR): request graceful shutdown.
-                            let msg = IncomingMessage::new("repl", "default", "/quit")
+                            let msg = IncomingMessage::new("repl", &user_id, "/quit")
                                 .with_timezone(&sys_tz);
                             let _ = tx.blocking_send(msg);
                             break;
@@ -416,7 +431,7 @@ impl Channel for ReplChannel {
                         // immediately — just drop the REPL thread silently so other
                         // channels (gateway, telegram, …) keep running.
                         if std::io::stdin().is_terminal() {
-                            let msg = IncomingMessage::new("repl", "default", "/quit")
+                            let msg = IncomingMessage::new("repl", &user_id, "/quit")
                                 .with_timezone(&sys_tz);
                             let _ = tx.blocking_send(msg);
                         }

src/channels/wasm/loader.rs

@@ -27,6 +27,7 @@ pub struct WasmChannelLoader {
     pairing_store: Arc<PairingStore>,
     settings_store: Option<Arc<dyn SettingsStore>>,
     secrets_store: Option<Arc<dyn SecretsStore + Send + Sync>>,
+    owner_scope_id: String,
 }
 
 impl WasmChannelLoader {
@@ -35,12 +36,14 @@ impl WasmChannelLoader {
         runtime: Arc<WasmChannelRuntime>,
         pairing_store: Arc<PairingStore>,
         settings_store: Option<Arc<dyn SettingsStore>>,
+        owner_scope_id: impl Into<String>,
     ) -> Self {
         Self {
             runtime,
             pairing_store,
             settings_store,
             secrets_store: None,
+            owner_scope_id: owner_scope_id.into(),
         }
     }
 
@@ -149,6 +152,7 @@ impl WasmChannelLoader {
             self.runtime.clone(),
             prepared,
             capabilities,
+            self.owner_scope_id.clone(),
             config_json,
             self.pairing_store.clone(),
             self.settings_store.clone(),
@@ -487,7 +491,8 @@ mod tests {
     async fn test_loader_invalid_name() {
         let config = WasmChannelRuntimeConfig::for_testing();
         let runtime = Arc::new(WasmChannelRuntime::new(config).unwrap());
-        let loader = WasmChannelLoader::new(runtime, Arc::new(PairingStore::new()), None);
+        let loader =
+            WasmChannelLoader::new(runtime, Arc::new(PairingStore::new()), None, "default");
 
         let dir = TempDir::new().unwrap();
         let wasm_path = dir.path().join("test.wasm");
@@ -505,7 +510,8 @@ mod tests {
     async fn load_from_dir_returns_empty_when_dir_missing() {
         let config = WasmChannelRuntimeConfig::for_testing();
         let runtime = Arc::new(WasmChannelRuntime::new(config).unwrap());
-        let loader = WasmChannelLoader::new(runtime, Arc::new(PairingStore::new()), None);
+        let loader =
+            WasmChannelLoader::new(runtime, Arc::new(PairingStore::new()), None, "default");
 
         let dir = TempDir::new().unwrap();
         let missing = dir.path().join("nonexistent_channels_dir");

src/channels/wasm/mod.rs

@@ -69,7 +69,7 @@
 //! let runtime = WasmChannelRuntime::new(config)?;
 //!
 //! // Load channels from directory
-//! let loader = WasmChannelLoader::new(runtime);
+//! let loader = WasmChannelLoader::new(runtime, pairing_store, settings_store, owner_scope_id);
 //! let channels = loader.load_from_dir(Path::new("~/.ironclaw/channels/")).await?;
 //!
 //! // Add to channel manager
@@ -90,6 +90,7 @@ pub mod setup;
 pub(crate) mod signature;
 #[allow(dead_code)]
 pub(crate) mod storage;
+mod telegram_host_config;
 mod wrapper;
 
 // Core types
@@ -107,4 +108,5 @@ pub use schema::{
     ChannelCapabilitiesFile, ChannelConfig, SecretSetupSchema, SetupSchema, WebhookSchema,
 };
 pub use setup::{WasmChannelSetup, inject_channel_credentials, setup_wasm_channels};
+pub(crate) use telegram_host_config::{TELEGRAM_CHANNEL_NAME, bot_username_setting_key};
 pub use wrapper::{HttpResponse, SharedWasmChannel, WasmChannel};

src/channels/wasm/router.rs

@@ -672,6 +672,7 @@ mod tests {
             runtime,
             prepared,
             capabilities,
+            "default",
             "{}".to_string(),
             Arc::new(PairingStore::new()),
             None,

src/channels/wasm/setup.rs

@@ -7,8 +7,9 @@ use std::collections::HashSet;
 use std::sync::Arc;
 
 use crate::channels::wasm::{
-    LoadedChannel, RegisteredEndpoint, SharedWasmChannel, WasmChannel, WasmChannelLoader,
-    WasmChannelRouter, WasmChannelRuntime, WasmChannelRuntimeConfig, create_wasm_channel_router,
+    LoadedChannel, RegisteredEndpoint, SharedWasmChannel, TELEGRAM_CHANNEL_NAME, WasmChannel,
+    WasmChannelLoader, WasmChannelRouter, WasmChannelRuntime, WasmChannelRuntimeConfig,
+    bot_username_setting_key, create_wasm_channel_router,
 };
 use crate::config::Config;
 use crate::db::Database;
@@ -48,7 +49,8 @@ pub async fn setup_wasm_channels(
     let mut loader = WasmChannelLoader::new(
         Arc::clone(&runtime),
         Arc::clone(&pairing_store),
-        settings_store,
+        settings_store.clone(),
+        config.owner_id.clone(),
     );
     if let Some(secrets) = secrets_store {
         loader = loader.with_secrets_store(Arc::clone(secrets));
@@ -70,7 +72,14 @@ pub async fn setup_wasm_channels(
     let mut channel_names: Vec<String> = Vec::new();
 
     for loaded in results.loaded {
-        let (name, channel) = register_channel(loaded, config, secrets_store, &wasm_router).await;
+        let (name, channel) = register_channel(
+            loaded,
+            config,
+            secrets_store,
+            settings_store.as_ref(),
+            &wasm_router,
+        )
+        .await;
         channel_names.push(name.clone());
         channels.push((name, channel));
     }
@@ -104,10 +113,16 @@ async fn register_channel(
     loaded: LoadedChannel,
     config: &Config,
     secrets_store: &Option<Arc<dyn SecretsStore + Send + Sync>>,
+    settings_store: Option<&Arc<dyn crate::db::SettingsStore>>,
     wasm_router: &Arc<WasmChannelRouter>,
 ) -> (String, Box<dyn crate::channels::Channel>) {
     let channel_name = loaded.name().to_string();
     tracing::info!("Loaded WASM channel: {}", channel_name);
+    let owner_actor_id = config
+        .channels
+        .wasm_channel_owner_ids
+        .get(channel_name.as_str())
+        .map(ToString::to_string);
 
     let secret_name = loaded.webhook_secret_name();
     let sig_key_secret_name = loaded.signature_key_secret_name();
@@ -115,7 +130,7 @@ async fn register_channel(
 
     let webhook_secret = if let Some(secrets) = secrets_store {
         secrets
-            .get_decrypted("default", &secret_name)
+            .get_decrypted(&config.owner_id, &secret_name)
             .await
             .ok()
             .map(|s| s.expose().to_string())
@@ -133,7 +148,7 @@ async fn register_channel(
         require_secret: webhook_secret.is_some(),
     }];
 
-    let channel_arc = Arc::new(loaded.channel);
+    let channel_arc = Arc::new(loaded.channel.with_owner_actor_id(owner_actor_id.clone()));
 
     // Inject runtime config (tunnel URL, webhook secret, owner_id).
     {
@@ -161,6 +176,15 @@ async fn register_channel(
             config_updates.insert("owner_id".to_string(), serde_json::json!(owner_id));
         }
 
+        if channel_name == TELEGRAM_CHANNEL_NAME
+            && let Some(store) = settings_store
+            && let Ok(Some(serde_json::Value::String(username))) = store
+                .get_setting("default", &bot_username_setting_key(&channel_name))
+                .await
+            && !username.trim().is_empty()
+        {
+            config_updates.insert("bot_username".to_string(), serde_json::json!(username));
+        }
         // Inject channel-specific secrets into config for channels that need
         // credentials in API request bodies (e.g., Feishu token exchange).
         // The credential injection system only replaces placeholders in URLs
@@ -198,7 +222,7 @@ async fn register_channel(
     // Register Ed25519 signature key if declared in capabilities.
     if let Some(ref sig_key_name) = sig_key_secret_name
         && let Some(secrets) = secrets_store
-        && let Ok(key_secret) = secrets.get_decrypted("default", sig_key_name).await
+        && let Ok(key_secret) = secrets.get_decrypted(&config.owner_id, sig_key_name).await
     {
         match wasm_router
             .register_signature_key(&channel_name, key_secret.expose())
@@ -216,7 +240,9 @@ async fn register_channel(
     // Register HMAC signing secret if declared in capabilities.
     if let Some(ref hmac_secret_name) = hmac_secret_name
         && let Some(secrets) = secrets_store
-        && let Ok(secret) = secrets.get_decrypted("default", hmac_secret_name).await
+        && let Ok(secret) = secrets
+            .get_decrypted(&config.owner_id, hmac_secret_name)
+            .await
     {
         wasm_router
             .register_hmac_secret(&channel_name, secret.expose())
@@ -231,6 +257,7 @@ async fn register_channel(
             .as_ref()
             .map(|s| s.as_ref() as &dyn SecretsStore),
         &channel_name,
+        &config.owner_id,
     )
     .await
     {
@@ -268,6 +295,7 @@ pub async fn inject_channel_credentials(
     channel: &Arc<WasmChannel>,
     secrets: Option<&dyn SecretsStore>,
     channel_name: &str,
+    owner_id: &str,
 ) -> anyhow::Result<usize> {
     if channel_name.trim().is_empty() {
         return Ok(0);
@@ -279,7 +307,7 @@ pub async fn inject_channel_credentials(
     // 1. Try injecting from persistent secrets store if available
     if let Some(secrets) = secrets {
         let all_secrets = secrets
-            .list("default")
+            .list(owner_id)
             .await
             .map_err(|e| anyhow::anyhow!("Failed to list secrets: {}", e))?;
 
@@ -290,7 +318,7 @@ pub async fn inject_channel_credentials(
                 continue;
             }
 
-            let decrypted = match secrets.get_decrypted("default", &secret_meta.name).await {
+            let decrypted = match secrets.get_decrypted(owner_id, &secret_meta.name).await {
                 Ok(d) => d,
                 Err(e) => {
                     tracing::warn!(

src/channels/wasm/telegram_host_config.rs

@@ -0,0 +1,6 @@
+pub const TELEGRAM_CHANNEL_NAME: &str = "telegram";
+const TELEGRAM_BOT_USERNAME_SETTING_PREFIX: &str = "channels.wasm_channel_bot_usernames";
+
+pub fn bot_username_setting_key(channel_name: &str) -> String {
+    format!("{TELEGRAM_BOT_USERNAME_SETTING_PREFIX}.{channel_name}")
+}

src/channels/web/handlers/chat.rs

@@ -162,15 +162,30 @@ pub async fn chat_auth_token_handler(
         .await
     {
         Ok(result) => {
-            clear_auth_mode(&state).await;
+            let mut resp = ActionResponse::ok(result.message.clone());
+            resp.activated = Some(result.activated);
+            resp.auth_url = result.auth_url.clone();
+            resp.verification = result.verification.clone();
+            resp.instructions = result.verification.as_ref().map(|v| v.instructions.clone());
 
-            state.sse.broadcast(SseEvent::AuthCompleted {
-                extension_name: req.extension_name.clone(),
-                success: true,
-                message: result.message.clone(),
-            });
+            if result.verification.is_some() {
+                state.sse.broadcast(SseEvent::AuthRequired {
+                    extension_name: req.extension_name.clone(),
+                    instructions: Some(result.message),
+                    auth_url: None,
+                    setup_url: None,
+                });
+            } else {
+                clear_auth_mode(&state).await;
 
-            Ok(Json(ActionResponse::ok(result.message)))
+                state.sse.broadcast(SseEvent::AuthCompleted {
+                    extension_name: req.extension_name.clone(),
+                    success: true,
+                    message: result.message,
+                });
+            }
+
+            Ok(Json(resp))
         }
         Err(e) => {
             let msg = e.to_string();

src/channels/web/handlers/extensions.rs

@@ -25,34 +25,34 @@ pub async fn extensions_list_handler(
         .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
 
     let pairing_store = crate::pairing::PairingStore::new();
+    let mut owner_bound_channels = std::collections::HashSet::new();
+    for ext in &installed {
+        if ext.kind == crate::extensions::ExtensionKind::WasmChannel
+            && ext_mgr.has_wasm_channel_owner_binding(&ext.name).await
+        {
+            owner_bound_channels.insert(ext.name.clone());
+        }
+    }
     let extensions = installed
         .into_iter()
         .map(|ext| {
             let activation_status = if ext.kind == crate::extensions::ExtensionKind::WasmChannel {
-                Some(if ext.activation_error.is_some() {
-                    "failed".to_string()
-                } else if !ext.authenticated {
-                    "installed".to_string()
-                } else if ext.active {
-                    let has_paired = pairing_store
-                        .read_allow_from(&ext.name)
-                        .map(|list| !list.is_empty())
-                        .unwrap_or(false);
-                    if has_paired {
-                        "active".to_string()
-                    } else {
-                        "pairing".to_string()
-                    }
-                } else {
-                    "configured".to_string()
-                })
+                let has_paired = pairing_store
+                    .read_allow_from(&ext.name)
+                    .map(|list| !list.is_empty())
+                    .unwrap_or(false);
+                crate::channels::web::types::classify_wasm_channel_activation(
+                    &ext,
+                    has_paired,
+                    owner_bound_channels.contains(&ext.name),
+                )
             } else if ext.kind == crate::extensions::ExtensionKind::ChannelRelay {
                 Some(if ext.active {
-                    "active".to_string()
+                    crate::channels::web::types::ExtensionActivationStatus::Active
                 } else if ext.authenticated {
-                    "configured".to_string()
+                    crate::channels::web::types::ExtensionActivationStatus::Configured
                 } else {
-                    "installed".to_string()
+                    crate::channels::web::types::ExtensionActivationStatus::Installed
                 })
             } else {
                 None

src/channels/web/server.rs

@@ -26,7 +26,6 @@ use tower_http::set_header::SetResponseHeaderLayer;
 use uuid::Uuid;
 
 use crate::agent::SessionManager;
-use crate::agent::routine::{Trigger, next_cron_fire};
 use crate::bootstrap::ironclaw_base_dir;
 use crate::channels::IncomingMessage;
 use crate::channels::relay::DEFAULT_RELAY_NAME;
@@ -36,6 +35,7 @@ use crate::channels::web::handlers::jobs::{
     jobs_events_handler, jobs_list_handler, jobs_prompt_handler, jobs_restart_handler,
     jobs_summary_handler,
 };
+use crate::channels::web::handlers::routines::{routines_delete_handler, routines_toggle_handler};
 use crate::channels::web::handlers::skills::{
     skills_install_handler, skills_list_handler, skills_remove_handler, skills_search_handler,
 };
@@ -1163,19 +1163,43 @@ async fn chat_auth_token_handler(
         .configure_token(&req.extension_name, &req.token)
         .await
     {
-        Ok(result) if result.activated => {
-            // Clear auth mode on the active thread
-            clear_auth_mode(&state).await;
+        Ok(result) => {
+            let mut resp = if result.verification.is_some() || result.activated {
+                ActionResponse::ok(result.message.clone())
+            } else {
+                ActionResponse::fail(result.message.clone())
+            };
+            resp.activated = Some(result.activated);
+            resp.auth_url = result.auth_url.clone();
+            resp.verification = result.verification.clone();
+            resp.instructions = result.verification.as_ref().map(|v| v.instructions.clone());
 
-            state.sse.broadcast(SseEvent::AuthCompleted {
-                extension_name: req.extension_name.clone(),
-                success: true,
-                message: result.message.clone(),
-            });
+            if result.verification.is_some() {
+                state.sse.broadcast(SseEvent::AuthRequired {
+                    extension_name: req.extension_name.clone(),
+                    instructions: Some(result.message),
+                    auth_url: None,
+                    setup_url: None,
+                });
+            } else if result.activated {
+                // Clear auth mode on the active thread
+                clear_auth_mode(&state).await;
 
-            Ok(Json(ActionResponse::ok(result.message)))
+                state.sse.broadcast(SseEvent::AuthCompleted {
+                    extension_name: req.extension_name.clone(),
+                    success: true,
+                    message: result.message,
+                });
+            } else {
+                state.sse.broadcast(SseEvent::AuthCompleted {
+                    extension_name: req.extension_name.clone(),
+                    success: false,
+                    message: result.message,
+                });
+            }
+
+            Ok(Json(resp))
         }
-        Ok(result) => Ok(Json(ActionResponse::fail(result.message))),
         Err(e) => {
             let msg = e.to_string();
             // Re-emit auth_required for retry on validation errors
@@ -1818,29 +1842,34 @@ async fn extensions_list_handler(
         .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
 
     let pairing_store = crate::pairing::PairingStore::new();
+    let mut owner_bound_channels = std::collections::HashSet::new();
+    for ext in &installed {
+        if ext.kind == crate::extensions::ExtensionKind::WasmChannel
+            && ext_mgr.has_wasm_channel_owner_binding(&ext.name).await
+        {
+            owner_bound_channels.insert(ext.name.clone());
+        }
+    }
     let extensions = installed
         .into_iter()
         .map(|ext| {
             let activation_status = if ext.kind == crate::extensions::ExtensionKind::WasmChannel {
-                Some(if ext.activation_error.is_some() {
-                    "failed".to_string()
-                } else if !ext.authenticated {
-                    // No credentials configured yet.
-                    "installed".to_string()
-                } else if ext.active {
-                    // Check pairing status for active channels.
-                    let has_paired = pairing_store
-                        .read_allow_from(&ext.name)
-                        .map(|list| !list.is_empty())
-                        .unwrap_or(false);
-                    if has_paired {
-                        "active".to_string()
-                    } else {
-                        "pairing".to_string()
-                    }
+                let has_paired = pairing_store
+                    .read_allow_from(&ext.name)
+                    .map(|list| !list.is_empty())
+                    .unwrap_or(false);
+                crate::channels::web::types::classify_wasm_channel_activation(
+                    &ext,
+                    has_paired,
+                    owner_bound_channels.contains(&ext.name),
+                )
+            } else if ext.kind == crate::extensions::ExtensionKind::ChannelRelay {
+                Some(if ext.active {
+                    ExtensionActivationStatus::Active
+                } else if ext.authenticated {
+                    ExtensionActivationStatus::Configured
                 } else {
-                    // Authenticated but not yet active.
-                    "configured".to_string()
+                    ExtensionActivationStatus::Installed
                 })
             } else {
                 None
@@ -2205,20 +2234,24 @@ async fn extensions_setup_submit_handler(
 
     match ext_mgr.configure(&name, &req.secrets).await {
         Ok(result) => {
-            // Broadcast completion status so chat UI can dismiss success cases while
-            // leaving failed auth/configuration flows visible for correction.
-            state.sse.broadcast(SseEvent::AuthCompleted {
-                extension_name: name.clone(),
-                success: result.activated,
-                message: result.message.clone(),
-            });
-            let mut resp = if result.activated {
+            let mut resp = if result.verification.is_some() || result.activated {
                 ActionResponse::ok(result.message)
             } else {
                 ActionResponse::fail(result.message)
             };
             resp.activated = Some(result.activated);
-            resp.auth_url = result.auth_url;
+            resp.auth_url = result.auth_url.clone();
+            resp.verification = result.verification.clone();
+            resp.instructions = result.verification.as_ref().map(|v| v.instructions.clone());
+            if result.verification.is_none() {
+                // Broadcast auth_completed so the chat UI can dismiss any in-progress
+                // auth card or setup modal that was triggered by tool_auth/tool_activate.
+                state.sse.broadcast(SseEvent::AuthCompleted {
+                    extension_name: name.clone(),
+                    success: result.activated,
+                    message: resp.message.clone(),
+                });
+            }
             Ok(Json(resp))
         }
         Err(e) => Ok(Json(ActionResponse::fail(e.to_string()))),
@@ -2430,83 +2463,6 @@ async fn routines_trigger_handler(
     })))
 }
 
-#[derive(Deserialize)]
-struct ToggleRequest {
-    enabled: Option<bool>,
-}
-
-async fn routines_toggle_handler(
-    State(state): State<Arc<GatewayState>>,
-    Path(id): Path<String>,
-    body: Option<Json<ToggleRequest>>,
-) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
-    let store = state.store.as_ref().ok_or((
-        StatusCode::SERVICE_UNAVAILABLE,
-        "Database not available".to_string(),
-    ))?;
-
-    let routine_id = Uuid::parse_str(&id)
-        .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid routine ID".to_string()))?;
-
-    let mut routine = store
-        .get_routine(routine_id)
-        .await
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
-        .ok_or((StatusCode::NOT_FOUND, "Routine not found".to_string()))?;
-
-    let was_enabled = routine.enabled;
-    // If a specific value was provided, use it; otherwise toggle.
-    routine.enabled = match body {
-        Some(Json(req)) => req.enabled.unwrap_or(!routine.enabled),
-        None => !routine.enabled,
-    };
-
-    if routine.enabled
-        && !was_enabled
-        && let Trigger::Cron { schedule, timezone } = &routine.trigger
-    {
-        routine.next_fire_at = next_cron_fire(schedule, timezone.as_deref())
-            .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
-    }
-
-    store
-        .update_routine(&routine)
-        .await
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
-
-    Ok(Json(serde_json::json!({
-        "status": if routine.enabled { "enabled" } else { "disabled" },
-        "routine_id": routine_id,
-    })))
-}
-
-async fn routines_delete_handler(
-    State(state): State<Arc<GatewayState>>,
-    Path(id): Path<String>,
-) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
-    let store = state.store.as_ref().ok_or((
-        StatusCode::SERVICE_UNAVAILABLE,
-        "Database not available".to_string(),
-    ))?;
-
-    let routine_id = Uuid::parse_str(&id)
-        .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid routine ID".to_string()))?;
-
-    let deleted = store
-        .delete_routine(routine_id)
-        .await
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
-
-    if deleted {
-        Ok(Json(serde_json::json!({
-            "status": "deleted",
-            "routine_id": routine_id,
-        })))
-    } else {
-        Err((StatusCode::NOT_FOUND, "Routine not found".to_string()))
-    }
-}
-
 async fn routines_runs_handler(
     State(state): State<Arc<GatewayState>>,
     Path(id): Path<String>,
@@ -2743,7 +2699,11 @@ struct GatewayStatusResponse {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::channels::web::types::{
+        ExtensionActivationStatus, classify_wasm_channel_activation,
+    };
     use crate::cli::oauth_defaults;
+    use crate::extensions::{ExtensionKind, InstalledExtension};
     use crate::testing::credentials::TEST_GATEWAY_CRYPTO_KEY;
 
     #[test]
@@ -2822,6 +2782,85 @@ mod tests {
         assert!(turns.is_empty());
     }
 
+    #[test]
+    fn test_wasm_channel_activation_status_owner_bound_counts_as_active() -> Result<(), String> {
+        let ext = InstalledExtension {
+            name: "telegram".to_string(),
+            kind: ExtensionKind::WasmChannel,
+            display_name: Some("Telegram".to_string()),
+            description: None,
+            url: None,
+            authenticated: true,
+            active: true,
+            tools: Vec::new(),
+            needs_setup: true,
+            has_auth: false,
+            installed: true,
+            activation_error: None,
+            version: None,
+        };
+
+        let owner_bound = classify_wasm_channel_activation(&ext, false, true);
+        if owner_bound != Some(ExtensionActivationStatus::Active) {
+            return Err(format!(
+                "owner-bound channel should be active, got {:?}",
+                owner_bound
+            ));
+        }
+
+        let unbound = classify_wasm_channel_activation(&ext, false, false);
+        if unbound != Some(ExtensionActivationStatus::Pairing) {
+            return Err(format!(
+                "unbound channel should be pairing, got {:?}",
+                unbound
+            ));
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_channel_relay_activation_status_is_preserved() -> Result<(), String> {
+        let relay = InstalledExtension {
+            name: "signal".to_string(),
+            kind: ExtensionKind::ChannelRelay,
+            display_name: Some("Signal".to_string()),
+            description: None,
+            url: None,
+            authenticated: true,
+            active: false,
+            tools: Vec::new(),
+            needs_setup: true,
+            has_auth: false,
+            installed: true,
+            activation_error: None,
+            version: None,
+        };
+
+        let status = if relay.kind == crate::extensions::ExtensionKind::WasmChannel {
+            classify_wasm_channel_activation(&relay, false, false)
+        } else if relay.kind == crate::extensions::ExtensionKind::ChannelRelay {
+            Some(if relay.active {
+                ExtensionActivationStatus::Active
+            } else if relay.authenticated {
+                ExtensionActivationStatus::Configured
+            } else {
+                ExtensionActivationStatus::Installed
+            })
+        } else {
+            None
+        };
+
+        if status != Some(ExtensionActivationStatus::Configured) {
+            return Err(format!(
+                "channel relay should retain configured status, got {:?}",
+                status
+            ));
+        }
+
+        Ok(())
+    }
+
     // --- OAuth callback handler tests ---
 
     /// Build a minimal `GatewayState` for testing the OAuth callback handler.
@@ -2935,6 +2974,92 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn test_extensions_setup_submit_telegram_verification_does_not_broadcast_auth_required() {
+        use axum::body::Body;
+        use tokio::time::{Duration, timeout};
+        use tower::ServiceExt;
+
+        let secrets = test_secrets_store();
+        let (ext_mgr, _wasm_tools_dir, wasm_channels_dir) = test_ext_mgr(secrets);
+
+        std::fs::write(
+            wasm_channels_dir.path().join("telegram.wasm"),
+            b"\0asm fake",
+        )
+        .expect("write fake telegram wasm");
+        let caps = serde_json::json!({
+            "type": "channel",
+            "name": "telegram",
+            "setup": {
+                "required_secrets": [
+                    {
+                        "name": "telegram_bot_token",
+                        "prompt": "Enter your Telegram Bot API token (from @BotFather)"
+                    }
+                ]
+            }
+        });
+        std::fs::write(
+            wasm_channels_dir.path().join("telegram.capabilities.json"),
+            serde_json::to_string(&caps).expect("serialize telegram caps"),
+        )
+        .expect("write telegram caps");
+
+        ext_mgr
+            .set_test_telegram_pending_verification("iclaw-7qk2m9", Some("test_hot_bot"))
+            .await;
+
+        let state = test_gateway_state(Some(ext_mgr));
+        let mut receiver = state.sse.sender().subscribe();
+        let app = Router::new()
+            .route(
+                "/api/extensions/{name}/setup",
+                post(extensions_setup_submit_handler),
+            )
+            .with_state(state);
+
+        let req_body = serde_json::json!({
+            "secrets": {
+                "telegram_bot_token": "123456789:ABCdefGhI"
+            }
+        });
+        let req = axum::http::Request::builder()
+            .method("POST")
+            .uri("/api/extensions/telegram/setup")
+            .header("content-type", "application/json")
+            .body(Body::from(req_body.to_string()))
+            .expect("request");
+
+        let resp = ServiceExt::<axum::http::Request<Body>>::oneshot(app, req)
+            .await
+            .expect("response");
+        assert_eq!(resp.status(), StatusCode::OK);
+
+        let body = axum::body::to_bytes(resp.into_body(), 1024 * 64)
+            .await
+            .expect("body");
+        let parsed: serde_json::Value = serde_json::from_slice(&body).expect("json response");
+        assert_eq!(parsed["success"], serde_json::Value::Bool(true));
+        assert_eq!(parsed["activated"], serde_json::Value::Bool(false));
+        assert_eq!(parsed["verification"]["code"], "iclaw-7qk2m9");
+
+        let deadline = tokio::time::Instant::now() + Duration::from_millis(100);
+        loop {
+            let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());
+            if remaining.is_zero() {
+                break;
+            }
+            match timeout(remaining, receiver.recv()).await {
+                Ok(Ok(crate::channels::web::types::SseEvent::AuthRequired { .. })) => {
+                    panic!("verification responses should not emit auth_required SSE events")
+                }
+                Ok(Ok(_)) => continue,
+                Ok(Err(_)) | Err(_) => break,
+            }
+        }
+    }
+
     fn expired_flow_created_at() -> Option<std::time::Instant> {
         std::time::Instant::now()
             .checked_sub(oauth_defaults::OAUTH_FLOW_EXPIRY + std::time::Duration::from_secs(1))

src/channels/web/static/app.js

@@ -527,7 +527,6 @@ function enableChatInput() {
   const btn = document.getElementById('send-btn');
   if (input) {
     input.disabled = false;
-    input.placeholder = I18n.t('chat.inputPlaceholder');
   }
   if (btn) btn.disabled = false;
 }
@@ -1205,11 +1204,13 @@ function showJobCard(data) {
 // --- Auth card ---
 
 function handleAuthRequired(data) {
-  setAuthFlowPending(true, data.instructions);
   if (data.auth_url) {
+    setAuthFlowPending(true, data.instructions);
     // OAuth flow: show the global auth prompt with an OAuth button + optional token paste field.
     showAuthCard(data);
   } else {
+    if (getConfigureOverlay(data.extension_name)) return;
+    setAuthFlowPending(true, data.instructions);
     // Setup flow: fetch the extension's credential schema and show the multi-field
     // configure modal (the same UI used by the Extensions tab "Setup" button).
     showConfigureModal(data.extension_name);
@@ -1433,13 +1434,11 @@ function setAuthFlowPending(pending, instructions) {
   if (authFlowPending) {
     input.disabled = true;
     btn.disabled = true;
-    input.placeholder = instructions || 'Complete extension auth to continue chatting';
     return;
   }
   if (!currentThreadIsReadOnly) {
     input.disabled = false;
     btn.disabled = false;
-    input.placeholder = I18n.t('chat.inputPlaceholder');
   }
 }
 
@@ -2712,8 +2711,11 @@ function renderConfigureModal(name, secrets) {
   const overlay = document.createElement('div');
   overlay.className = 'configure-overlay';
   overlay.setAttribute('data-extension-name', name);
+  overlay.dataset.telegramVerificationState = 'idle';
   overlay.addEventListener('click', (e) => {
-    if (e.target === overlay) closeConfigureModal();
+    if (e.target !== overlay) return;
+    if (name === 'telegram' && overlay.dataset.telegramVerificationState === 'waiting') return;
+    closeConfigureModal();
   });
 
   const modal = document.createElement('div');
@@ -2723,6 +2725,13 @@ function renderConfigureModal(name, secrets) {
   header.textContent = I18n.t('config.title', { name: name });
   modal.appendChild(header);
 
+  if (name === 'telegram') {
+    const hint = document.createElement('div');
+    hint.className = 'configure-hint';
+    hint.textContent = I18n.t('config.telegramOwnerHint');
+    modal.appendChild(hint);
+  }
+
   const form = document.createElement('div');
   form.className = 'configure-form';
 
@@ -2730,6 +2739,7 @@ function renderConfigureModal(name, secrets) {
   for (const secret of secrets) {
     const field = document.createElement('div');
     field.className = 'configure-field';
+    field.dataset.secretName = secret.name;
 
     const label = document.createElement('label');
     label.textContent = secret.prompt;
@@ -2774,6 +2784,16 @@ function renderConfigureModal(name, secrets) {
 
   modal.appendChild(form);
 
+  const error = document.createElement('div');
+  error.className = 'configure-inline-error';
+  error.style.display = 'none';
+  modal.appendChild(error);
+
+  const status = document.createElement('div');
+  status.className = 'configure-inline-status';
+  status.style.display = 'none';
+  modal.appendChild(status);
+
   const actions = document.createElement('div');
   actions.className = 'configure-actions';
 
@@ -2796,7 +2816,110 @@ function renderConfigureModal(name, secrets) {
   if (fields.length > 0) fields[0].input.focus();
 }
 
-function submitConfigureModal(name, fields) {
+function renderTelegramVerificationChallenge(overlay, verification) {
+  if (!overlay || !verification) return;
+  const modal = overlay.querySelector('.configure-modal');
+  if (!modal) return;
+  const telegramField = modal.querySelector('.configure-field[data-secret-name="telegram_bot_token"]');
+
+  let panel = modal.querySelector('.configure-verification');
+  if (!panel) {
+    panel = document.createElement('div');
+    panel.className = 'configure-verification';
+  }
+  if (telegramField && telegramField.parentNode) {
+    telegramField.insertAdjacentElement('afterend', panel);
+  } else {
+    modal.insertBefore(
+      panel,
+      modal.querySelector('.configure-inline-error') || modal.querySelector('.configure-actions')
+    );
+  }
+
+  panel.innerHTML = '';
+
+  const title = document.createElement('div');
+  title.className = 'configure-verification-title';
+  title.textContent = I18n.t('config.telegramChallengeTitle');
+  panel.appendChild(title);
+
+  const instructions = document.createElement('div');
+  instructions.className = 'configure-verification-instructions';
+  instructions.textContent = verification.instructions;
+  panel.appendChild(instructions);
+
+  const commandLabel = document.createElement('div');
+  commandLabel.className = 'configure-verification-instructions';
+  commandLabel.textContent = I18n.t('config.telegramCommandLabel');
+  panel.appendChild(commandLabel);
+
+  const command = document.createElement('code');
+  command.className = 'configure-verification-code';
+  command.textContent = '/start ' + verification.code;
+  panel.appendChild(command);
+
+  if (verification.deep_link) {
+    const link = document.createElement('a');
+    link.className = 'configure-verification-link';
+    link.href = verification.deep_link;
+    link.target = '_blank';
+    link.rel = 'noreferrer noopener';
+    link.textContent = I18n.t('config.telegramOpenBot');
+    panel.appendChild(link);
+  }
+}
+
+function getConfigurePrimaryButton(overlay) {
+  return overlay && overlay.querySelector('.configure-actions button.btn-ext.activate');
+}
+
+function getConfigureCancelButton(overlay) {
+  return overlay && overlay.querySelector('.configure-actions button.btn-ext.remove');
+}
+
+function setConfigureInlineError(overlay, message) {
+  const error = overlay && overlay.querySelector('.configure-inline-error');
+  if (!error) return;
+  error.textContent = message || '';
+  error.style.display = message ? 'block' : 'none';
+}
+
+function clearConfigureInlineError(overlay) {
+  setConfigureInlineError(overlay, '');
+}
+
+function setConfigureInlineStatus(overlay, message) {
+  const status = overlay && overlay.querySelector('.configure-inline-status');
+  if (!status) return;
+  status.textContent = message || '';
+  status.style.display = message ? 'block' : 'none';
+}
+
+function setTelegramConfigureState(overlay, fields, state) {
+  if (!overlay) return;
+  overlay.dataset.telegramVerificationState = state;
+
+  const primaryBtn = getConfigurePrimaryButton(overlay);
+  const cancelBtn = getConfigureCancelButton(overlay);
+  const waiting = state === 'waiting';
+  const retry = state === 'retry';
+
+  setConfigureInlineStatus(overlay, waiting ? I18n.t('config.telegramOwnerWaiting') : '');
+
+  if (primaryBtn) {
+    primaryBtn.style.display = waiting ? 'none' : '';
+    primaryBtn.disabled = false;
+    primaryBtn.textContent = retry ? I18n.t('config.telegramStartOver') : I18n.t('config.save');
+  }
+  if (cancelBtn) cancelBtn.disabled = waiting;
+}
+
+function startTelegramAutoVerify(name, fields) {
+  window.setTimeout(() => submitConfigureModal(name, fields, { telegramAutoVerify: true }), 0);
+}
+
+function submitConfigureModal(name, fields, options) {
+  options = options || {};
   const secrets = {};
   for (const f of fields) {
     if (f.input.value.trim()) {
@@ -2804,10 +2927,16 @@ function submitConfigureModal(name, fields) {
     }
   }
 
-  // Disable buttons to prevent double-submit
   const overlay = getConfigureOverlay(name) || document.querySelector('.configure-overlay');
+  const isTelegram = name === 'telegram';
+  clearConfigureInlineError(overlay);
+
+  // Disable buttons to prevent double-submit
   var btns = overlay ? overlay.querySelectorAll('.configure-actions button') : [];
   btns.forEach(function(b) { b.disabled = true; });
+  if (overlay && isTelegram) {
+    setTelegramConfigureState(overlay, fields, 'waiting');
+  }
 
   apiFetch('/api/extensions/' + encodeURIComponent(name) + '/setup', {
     method: 'POST',
@@ -2815,6 +2944,23 @@ function submitConfigureModal(name, fields) {
   })
     .then((res) => {
       if (res.success) {
+        if (res.verification && isTelegram) {
+          renderTelegramVerificationChallenge(overlay, res.verification);
+          fields.forEach(function(f) { f.input.value = ''; });
+          setTelegramConfigureState(overlay, fields, 'waiting');
+          // Once the verification challenge is rendered inline, the global auth lock
+          // should not keep the chat composer disabled for this setup-driven flow.
+          setAuthFlowPending(false);
+          enableChatInput();
+          if (!options.telegramAutoVerify) {
+            startTelegramAutoVerify(name, fields);
+            return;
+          }
+          setTelegramConfigureState(overlay, fields, 'retry');
+          setConfigureInlineError(overlay, I18n.t('config.telegramStartOverHint'));
+          return;
+        }
+
         closeConfigureModal();
         if (res.auth_url) {
           showAuthCard({
@@ -2830,11 +2976,29 @@ function submitConfigureModal(name, fields) {
       } else {
         // Keep modal open so the user can correct their input and retry.
         btns.forEach(function(b) { b.disabled = false; });
+        setConfigureInlineError(overlay, res.message || 'Configuration failed');
+        if (isTelegram) {
+          const hasVerification = overlay && overlay.querySelector('.configure-verification');
+          if (options.telegramAutoVerify || hasVerification) {
+            setTelegramConfigureState(overlay, fields, 'retry');
+          } else {
+            setTelegramConfigureState(overlay, fields, 'idle');
+          }
+        }
         showToast(res.message || 'Configuration failed', 'error');
       }
     })
     .catch((err) => {
       btns.forEach(function(b) { b.disabled = false; });
+      setConfigureInlineError(overlay, 'Configuration failed: ' + err.message);
+      if (isTelegram) {
+        const hasVerification = overlay && overlay.querySelector('.configure-verification');
+        if (options.telegramAutoVerify || hasVerification) {
+          setTelegramConfigureState(overlay, fields, 'retry');
+        } else {
+          setTelegramConfigureState(overlay, fields, 'idle');
+        }
+      }
       showToast('Configuration failed: ' + err.message, 'error');
     });
 }
@@ -2843,6 +3007,10 @@ function closeConfigureModal(extensionName) {
   if (typeof extensionName !== 'string') extensionName = null;
   const existing = getConfigureOverlay(extensionName);
   if (existing) existing.remove();
+  if (!document.querySelector('.configure-overlay') && !document.querySelector('.auth-card')) {
+    setAuthFlowPending(false);
+    enableChatInput();
+  }
 }
 
 // Validate that a server-supplied OAuth URL is HTTPS before opening a popup.

src/channels/web/static/i18n/en.js

@@ -342,6 +342,13 @@ I18n.register('en', {
   
   // Configure
   'config.title': 'Configure {name}',
+  'config.telegramOwnerHint': 'After saving, IronClaw will show a one-time code. Send `/start CODE` to your bot in Telegram and IronClaw will finish setup automatically.',
+  'config.telegramChallengeTitle': 'Telegram owner verification',
+  'config.telegramOwnerWaiting': 'Waiting for Telegram owner verification...',
+  'config.telegramCommandLabel': 'Send this in Telegram:',
+  'config.telegramStartOver': 'Start over',
+  'config.telegramStartOverHint': 'Telegram verification did not complete. Click Start over to generate a new code and try again.',
+  'config.telegramOpenBot': 'Open bot in Telegram',
   'config.optional': ' (optional)',
   'config.alreadySet': '(already set — leave empty to keep)',
   'config.alreadyConfigured': 'Already configured',

src/channels/web/static/i18n/zh-CN.js

@@ -342,6 +342,12 @@ I18n.register('zh-CN', {
   
   // 配置
   'config.title': '配置 {name}',
+  'config.telegramOwnerHint': '保存后，IronClaw 会显示一次性验证码。将 `/start CODE` 发送给你的 Telegram 机器人，IronClaw 会自动完成设置。',
+  'config.telegramChallengeTitle': 'Telegram 所有者验证',
+  'config.telegramOwnerWaiting': '正在等待 Telegram 所有者验证...',
+  'config.telegramCommandLabel': '请在 Telegram 中发送：',
+  'config.telegramStartOver': '重新开始',
+  'config.telegramStartOverHint': 'Telegram 验证未完成。点击“重新开始”以生成新的验证码并重试。',
   'config.optional': '（可选）',
   'config.alreadySet': '（已设置 — 留空以保持不变）',
   'config.alreadyConfigured': '已配置',

src/channels/web/static/style.css

@@ -2896,6 +2896,84 @@ body {
   color: var(--text-primary);
 }
 
+.configure-hint {
+  margin: 0 0 16px 0;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+  color: var(--text-secondary);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.configure-verification {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  margin: 16px 0 0 0;
+  padding: 12px;
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+}
+
+.configure-verification-title {
+  font-size: 13px;
+  font-weight: 600;
+  color: var(--text-primary);
+}
+
+.configure-verification-instructions {
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+}
+
+.configure-verification-code {
+  display: inline-block;
+  width: fit-content;
+  padding: 6px 10px;
+  border-radius: 6px;
+  background: rgba(255, 255, 255, 0.06);
+  border: 1px solid var(--border);
+  color: var(--text-primary);
+  font-size: 13px;
+}
+
+.configure-verification-link {
+  width: fit-content;
+  color: var(--accent, var(--text-link, #4ea3ff));
+  font-size: 13px;
+  text-decoration: none;
+}
+
+.configure-verification-link:hover {
+  text-decoration: underline;
+}
+
+.configure-inline-error {
+  margin: 16px 0 0 0;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: rgba(220, 38, 38, 0.12);
+  border: 1px solid rgba(220, 38, 38, 0.35);
+  color: #fca5a5;
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.configure-inline-status {
+  margin: 16px 0 0 0;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border);
+  color: var(--text-secondary);
+  font-size: 13px;
+  line-height: 1.5;
+}
+
 .configure-form {
   display: flex;
   flex-direction: column;

src/channels/web/types.rs

@@ -410,6 +410,40 @@ pub struct TransitionInfo {
 
 // --- Extensions ---
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "snake_case")]
+pub enum ExtensionActivationStatus {
+    Installed,
+    Configured,
+    Pairing,
+    Active,
+    Failed,
+}
+
+pub fn classify_wasm_channel_activation(
+    ext: &crate::extensions::InstalledExtension,
+    has_paired: bool,
+    has_owner_binding: bool,
+) -> Option<ExtensionActivationStatus> {
+    if ext.kind != crate::extensions::ExtensionKind::WasmChannel {
+        return None;
+    }
+
+    Some(if ext.activation_error.is_some() {
+        ExtensionActivationStatus::Failed
+    } else if !ext.authenticated {
+        ExtensionActivationStatus::Installed
+    } else if ext.active {
+        if has_paired || has_owner_binding {
+            ExtensionActivationStatus::Active
+        } else {
+            ExtensionActivationStatus::Pairing
+        }
+    } else {
+        ExtensionActivationStatus::Configured
+    })
+}
+
 #[derive(Debug, Serialize)]
 pub struct ExtensionInfo {
     pub name: String,
@@ -428,9 +462,9 @@ pub struct ExtensionInfo {
     /// Whether this extension has an auth configuration (OAuth or manual token).
     #[serde(default)]
     pub has_auth: bool,
-    /// WASM channel activation status: "installed", "configured", "active", "failed".
+    /// WASM channel activation status.
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub activation_status: Option<String>,
+    pub activation_status: Option<ExtensionActivationStatus>,
     /// Human-readable error when activation_status is "failed".
     #[serde(skip_serializing_if = "Option::is_none")]
     pub activation_error: Option<String>,
@@ -503,6 +537,9 @@ pub struct ActionResponse {
     /// Whether the channel was successfully activated after setup.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub activated: Option<bool>,
+    /// Pending manual verification challenge (for Telegram owner binding, etc.).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub verification: Option<crate::extensions::VerificationChallenge>,
 }
 
 impl ActionResponse {
@@ -514,6 +551,7 @@ impl ActionResponse {
             awaiting_token: None,
             instructions: None,
             activated: None,
+            verification: None,
         }
     }
 
@@ -525,6 +563,7 @@ impl ActionResponse {
             awaiting_token: None,
             instructions: None,
             activated: None,
+            verification: None,
         }
     }
 }

src/channels/web/ws.rs

@@ -265,14 +265,25 @@ async fn handle_client_message(
             if let Some(ref ext_mgr) = state.extension_manager {
                 match ext_mgr.configure_token(&extension_name, &token).await {
                     Ok(result) => {
-                        crate::channels::web::server::clear_auth_mode(state).await;
-                        state
-                            .sse
-                            .broadcast(crate::channels::web::types::SseEvent::AuthCompleted {
-                                extension_name,
-                                success: true,
-                                message: result.message,
-                            });
+                        if result.verification.is_some() {
+                            state.sse.broadcast(
+                                crate::channels::web::types::SseEvent::AuthRequired {
+                                    extension_name: extension_name.clone(),
+                                    instructions: Some(result.message),
+                                    auth_url: None,
+                                    setup_url: None,
+                                },
+                            );
+                        } else {
+                            crate::channels::web::server::clear_auth_mode(state).await;
+                            state.sse.broadcast(
+                                crate::channels::web::types::SseEvent::AuthCompleted {
+                                    extension_name,
+                                    success: true,
+                                    message: result.message,
+                                },
+                            );
+                        }
                     }
                     Err(e) => {
                         let msg = format!("Auth failed: {}", e);

src/cli/doctor.rs

@@ -405,10 +405,11 @@ fn check_routines_config() -> CheckResult {
 fn check_gateway_config(settings: &Settings) -> CheckResult {
     // Use the same resolve() path as runtime so invalid env values
     // (e.g. GATEWAY_PORT=abc) are caught here too.
-    let tunnel_enabled = crate::config::TunnelConfig::resolve(settings)
-        .map(|t| t.is_enabled())
-        .unwrap_or(false);
-    match crate::config::ChannelsConfig::resolve(settings, tunnel_enabled) {
+    let owner_id = match crate::config::resolve_owner_id(settings) {
+        Ok(owner_id) => owner_id,
+        Err(e) => return CheckResult::Fail(format!("config error: {e}")),
+    };
+    match crate::config::ChannelsConfig::resolve(settings, &owner_id) {
         Ok(channels) => match channels.gateway {
             Some(gw) => {
                 if gw.auth_token.is_some() {

src/cli/routines.rs

@@ -292,6 +292,16 @@ async fn list(
 
 // ── Create ──────────────────────────────────────────────────
 
+fn cli_notify_config(notify_channel: Option<String>) -> NotifyConfig {
+    NotifyConfig {
+        channel: notify_channel,
+        user: None,
+        on_attention: true,
+        on_failure: true,
+        on_success: false,
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 async fn create(
     db: &Arc<dyn Database>,
@@ -338,13 +348,7 @@ async fn create(
             max_concurrent: 1,
             dedup_window: None,
         },
-        notify: NotifyConfig {
-            channel: notify_channel,
-            user: user_id.to_string(),
-            on_attention: true,
-            on_failure: true,
-            on_success: false,
-        },
+        notify: cli_notify_config(notify_channel),
         last_run_at: None,
         next_fire_at: next_fire,
         run_count: 0,
@@ -729,4 +733,14 @@ mod tests {
         // Must be valid UTF-8 (would have panicked otherwise).
         assert!(result.is_char_boundary(result.len()));
     }
+
+    #[test]
+    fn cli_notify_config_defaults_to_runtime_target_resolution() {
+        let notify = cli_notify_config(Some("telegram".to_string()));
+        assert_eq!(notify.channel.as_deref(), Some("telegram")); // safety: test-only assertion
+        assert_eq!(notify.user, None); // safety: test-only assertion
+        assert!(notify.on_attention); // safety: test-only assertion
+        assert!(notify.on_failure); // safety: test-only assertion
+        assert!(!notify.on_success); // safety: test-only assertion
+    }
 }

src/config/channels.rs

@@ -91,36 +91,24 @@ pub struct SignalConfig {
 }
 
 impl ChannelsConfig {
-    /// Resolve channels config following `env > settings > default` for every field.
-    pub(crate) fn resolve(settings: &Settings, tunnel_enabled: bool) -> Result<Self, ConfigError> {
+    pub(crate) fn resolve(settings: &Settings, owner_id: &str) -> Result<Self, ConfigError> {
         let cs = &settings.channels;
 
-        // --- HTTP webhook ---
-        // HTTP is enabled when env vars are set OR settings has it enabled.
         let http_enabled_by_env =
             optional_env("HTTP_PORT")?.is_some() || optional_env("HTTP_HOST")?.is_some();
-        // When a tunnel is configured, default to loopback since external
-        // traffic arrives through the tunnel. Without a tunnel the webhook
-        // server needs to accept connections from the network directly.
-        let default_host = if tunnel_enabled {
-            "127.0.0.1"
-        } else {
-            "0.0.0.0"
-        };
         let http = if http_enabled_by_env || cs.http_enabled {
             Some(HttpConfig {
                 host: optional_env("HTTP_HOST")?
                     .or_else(|| cs.http_host.clone())
-                    .unwrap_or_else(|| default_host.to_string()),
+                    .unwrap_or_else(|| "0.0.0.0".to_string()),
                 port: parse_optional_env("HTTP_PORT", cs.http_port.unwrap_or(8080))?,
                 webhook_secret: optional_env("HTTP_WEBHOOK_SECRET")?.map(SecretString::from),
-                user_id: optional_env("HTTP_USER_ID")?.unwrap_or_else(|| "http".to_string()),
+                user_id: owner_id.to_string(),
             })
         } else {
             None
         };
 
-        // --- Web gateway ---
         let gateway_enabled = parse_bool_env("GATEWAY_ENABLED", cs.gateway_enabled)?;
         let gateway = if gateway_enabled {
             Some(GatewayConfig {
@@ -133,33 +121,29 @@ impl ChannelsConfig {
                 )?,
                 auth_token: optional_env("GATEWAY_AUTH_TOKEN")?
                     .or_else(|| cs.gateway_auth_token.clone()),
-                user_id: optional_env("GATEWAY_USER_ID")?
-                    .or_else(|| cs.gateway_user_id.clone())
-                    .unwrap_or_else(|| "default".to_string()),
+                user_id: owner_id.to_string(),
             })
         } else {
             None
         };
 
-        // --- Signal ---
         let signal_url = optional_env("SIGNAL_HTTP_URL")?.or_else(|| cs.signal_http_url.clone());
         let signal = if let Some(http_url) = signal_url {
             let account = optional_env("SIGNAL_ACCOUNT")?
                 .or_else(|| cs.signal_account.clone())
                 .ok_or(ConfigError::InvalidValue {
                     key: "SIGNAL_ACCOUNT".to_string(),
-                    message: "SIGNAL_ACCOUNT is required when Signal is enabled".to_string(),
+                    message: "SIGNAL_ACCOUNT is required when SIGNAL_HTTP_URL is set".to_string(),
                 })?;
-            let allow_from_str =
-                optional_env("SIGNAL_ALLOW_FROM")?.or_else(|| cs.signal_allow_from.clone());
-            let allow_from = match allow_from_str {
-                None => vec![account.clone()],
-                Some(s) => s
-                    .split(',')
-                    .map(|e| e.trim().to_string())
-                    .filter(|s| !s.is_empty())
-                    .collect(),
-            };
+            let allow_from =
+                match optional_env("SIGNAL_ALLOW_FROM")?.or_else(|| cs.signal_allow_from.clone()) {
+                    None => vec![account.clone()],
+                    Some(s) => s
+                        .split(',')
+                        .map(|e| e.trim().to_string())
+                        .filter(|s| !s.is_empty())
+                        .collect(),
+                };
             let dm_policy = optional_env("SIGNAL_DM_POLICY")?
                 .or_else(|| cs.signal_dm_policy.clone())
                 .unwrap_or_else(|| "pairing".to_string());
@@ -201,18 +185,8 @@ impl ChannelsConfig {
             None
         };
 
-        // --- CLI ---
         let cli_enabled = parse_bool_env("CLI_ENABLED", cs.cli_enabled)?;
 
-        // --- WASM channels ---
-        let wasm_channels_dir = optional_env("WASM_CHANNELS_DIR")?
-            .map(PathBuf::from)
-            .or_else(|| cs.wasm_channels_dir.clone())
-            .unwrap_or_else(default_channels_dir);
-
-        let wasm_channels_enabled =
-            parse_bool_env("WASM_CHANNELS_ENABLED", cs.wasm_channels_enabled)?;
-
         Ok(Self {
             cli: CliConfig {
                 enabled: cli_enabled,
@@ -220,8 +194,14 @@ impl ChannelsConfig {
             http,
             gateway,
             signal,
-            wasm_channels_dir,
-            wasm_channels_enabled,
+            wasm_channels_dir: optional_env("WASM_CHANNELS_DIR")?
+                .map(PathBuf::from)
+                .or_else(|| cs.wasm_channels_dir.clone())
+                .unwrap_or_else(default_channels_dir),
+            wasm_channels_enabled: parse_bool_env(
+                "WASM_CHANNELS_ENABLED",
+                cs.wasm_channels_enabled,
+            )?,
             wasm_channel_owner_ids: {
                 let mut ids = cs.wasm_channel_owner_ids.clone();
                 // Backwards compat: TELEGRAM_OWNER_ID env var
@@ -252,6 +232,8 @@ fn default_channels_dir() -> PathBuf {
 #[cfg(test)]
 mod tests {
     use crate::config::channels::*;
+    use crate::config::helpers::ENV_MUTEX;
+    use crate::settings::Settings;
 
     #[test]
     fn cli_config_fields() {
@@ -398,69 +380,6 @@ mod tests {
         assert!(!cfg.wasm_channels_enabled);
     }
 
-    /// When a tunnel is active and HTTP_HOST is not explicitly set, the
-    /// webhook server should default to loopback to avoid unnecessary exposure.
-    #[test]
-    fn http_host_defaults_to_loopback_with_tunnel() {
-        // Set HTTP_PORT to trigger HttpConfig creation, but leave HTTP_HOST unset
-        // so the default kicks in.
-        unsafe {
-            std::env::set_var("HTTP_PORT", "9999");
-            std::env::remove_var("HTTP_HOST");
-        }
-        let settings = crate::settings::Settings::default();
-        let cfg = ChannelsConfig::resolve(&settings, true).unwrap();
-        unsafe {
-            std::env::remove_var("HTTP_PORT");
-        }
-        let http = cfg.http.expect("HttpConfig should be present");
-        assert_eq!(
-            http.host, "127.0.0.1",
-            "tunnel active should default to loopback"
-        );
-        assert_eq!(http.port, 9999);
-    }
-
-    /// Without a tunnel, the webhook server defaults to 0.0.0.0 so external
-    /// services can reach it directly.
-    #[test]
-    fn http_host_defaults_to_all_interfaces_without_tunnel() {
-        unsafe {
-            std::env::set_var("HTTP_PORT", "9998");
-            std::env::remove_var("HTTP_HOST");
-        }
-        let settings = crate::settings::Settings::default();
-        let cfg = ChannelsConfig::resolve(&settings, false).unwrap();
-        unsafe {
-            std::env::remove_var("HTTP_PORT");
-        }
-        let http = cfg.http.expect("HttpConfig should be present");
-        assert_eq!(
-            http.host, "0.0.0.0",
-            "no tunnel should default to all interfaces"
-        );
-    }
-
-    /// An explicit HTTP_HOST always wins regardless of tunnel state.
-    #[test]
-    fn explicit_http_host_overrides_tunnel_default() {
-        unsafe {
-            std::env::set_var("HTTP_PORT", "9997");
-            std::env::set_var("HTTP_HOST", "192.168.1.50");
-        }
-        let settings = crate::settings::Settings::default();
-        let cfg = ChannelsConfig::resolve(&settings, true).unwrap();
-        unsafe {
-            std::env::remove_var("HTTP_PORT");
-            std::env::remove_var("HTTP_HOST");
-        }
-        let http = cfg.http.expect("HttpConfig should be present");
-        assert_eq!(
-            http.host, "192.168.1.50",
-            "explicit host should override tunnel default"
-        );
-    }
-
     #[test]
     fn default_channels_dir_ends_with_channels() {
         let dir = default_channels_dir();
@@ -471,242 +390,43 @@ mod tests {
     }
 
     #[test]
-    fn default_gateway_port_constant() {
-        assert_eq!(DEFAULT_GATEWAY_PORT, 3000);
-    }
-
-    /// With default settings and no env vars, gateway should use defaults.
-    #[test]
-    fn resolve_gateway_defaults_from_settings() {
-        let _lock = crate::config::helpers::ENV_MUTEX.lock();
-        // Clear env vars that would interfere
-        unsafe {
-            std::env::remove_var("GATEWAY_ENABLED");
-            std::env::remove_var("GATEWAY_HOST");
-            std::env::remove_var("GATEWAY_PORT");
-            std::env::remove_var("GATEWAY_AUTH_TOKEN");
-            std::env::remove_var("GATEWAY_USER_ID");
-            std::env::remove_var("HTTP_PORT");
-            std::env::remove_var("HTTP_HOST");
-            std::env::remove_var("SIGNAL_HTTP_URL");
-            std::env::remove_var("CLI_ENABLED");
-            std::env::remove_var("WASM_CHANNELS_DIR");
-            std::env::remove_var("WASM_CHANNELS_ENABLED");
-            std::env::remove_var("TELEGRAM_OWNER_ID");
-        }
-
-        let settings = crate::settings::Settings::default();
-        let cfg = ChannelsConfig::resolve(&settings, false).unwrap();
-
-        let gw = cfg.gateway.expect("gateway should be enabled by default");
-        assert_eq!(gw.host, "127.0.0.1");
-        assert_eq!(gw.port, DEFAULT_GATEWAY_PORT);
-        assert!(gw.auth_token.is_none());
-        assert_eq!(gw.user_id, "default");
-    }
-
-    /// Settings values should be used when no env vars are set.
-    #[test]
-    fn resolve_gateway_from_settings() {
-        let _lock = crate::config::helpers::ENV_MUTEX.lock();
-        unsafe {
-            std::env::remove_var("GATEWAY_ENABLED");
-            std::env::remove_var("GATEWAY_HOST");
-            std::env::remove_var("GATEWAY_PORT");
-            std::env::remove_var("GATEWAY_AUTH_TOKEN");
-            std::env::remove_var("GATEWAY_USER_ID");
-            std::env::remove_var("HTTP_PORT");
-            std::env::remove_var("HTTP_HOST");
-            std::env::remove_var("SIGNAL_HTTP_URL");
-            std::env::remove_var("CLI_ENABLED");
-            std::env::remove_var("WASM_CHANNELS_DIR");
-            std::env::remove_var("WASM_CHANNELS_ENABLED");
-            std::env::remove_var("TELEGRAM_OWNER_ID");
-        }
-
-        let mut settings = crate::settings::Settings::default();
-        settings.channels.gateway_port = Some(4000);
-        settings.channels.gateway_host = Some("0.0.0.0".to_string());
-        settings.channels.gateway_auth_token = Some("db-token-123".to_string());
-        settings.channels.gateway_user_id = Some("myuser".to_string());
-
-        let cfg = ChannelsConfig::resolve(&settings, false).unwrap();
-        let gw = cfg.gateway.expect("gateway should be enabled");
-        assert_eq!(gw.port, 4000);
-        assert_eq!(gw.host, "0.0.0.0");
-        assert_eq!(gw.auth_token.as_deref(), Some("db-token-123"));
-        assert_eq!(gw.user_id, "myuser");
-    }
-
-    /// Env vars should override settings values.
-    #[test]
-    fn resolve_env_overrides_settings() {
-        let _lock = crate::config::helpers::ENV_MUTEX.lock();
-        unsafe {
-            std::env::set_var("GATEWAY_PORT", "5000");
-            std::env::set_var("GATEWAY_HOST", "10.0.0.1");
-            std::env::set_var("GATEWAY_AUTH_TOKEN", "env-token");
-            std::env::remove_var("GATEWAY_ENABLED");
-            std::env::remove_var("GATEWAY_USER_ID");
-            std::env::remove_var("HTTP_PORT");
-            std::env::remove_var("HTTP_HOST");
-            std::env::remove_var("SIGNAL_HTTP_URL");
-            std::env::remove_var("CLI_ENABLED");
-            std::env::remove_var("WASM_CHANNELS_DIR");
-            std::env::remove_var("WASM_CHANNELS_ENABLED");
-            std::env::remove_var("TELEGRAM_OWNER_ID");
-        }
-
-        let mut settings = crate::settings::Settings::default();
-        settings.channels.gateway_port = Some(4000);
-        settings.channels.gateway_host = Some("0.0.0.0".to_string());
-        settings.channels.gateway_auth_token = Some("db-token".to_string());
-
-        let cfg = ChannelsConfig::resolve(&settings, false).unwrap();
-        let gw = cfg.gateway.expect("gateway should be enabled");
-        assert_eq!(gw.port, 5000, "env should override settings");
-        assert_eq!(gw.host, "10.0.0.1", "env should override settings");
-        assert_eq!(
-            gw.auth_token.as_deref(),
-            Some("env-token"),
-            "env should override settings"
-        );
-
-        // Cleanup
-        unsafe {
-            std::env::remove_var("GATEWAY_PORT");
-            std::env::remove_var("GATEWAY_HOST");
-            std::env::remove_var("GATEWAY_AUTH_TOKEN");
-        }
-    }
-
-    /// CLI enabled should fall back to settings.
-    #[test]
-    fn resolve_cli_enabled_from_settings() {
-        let _lock = crate::config::helpers::ENV_MUTEX.lock();
-        unsafe {
-            std::env::remove_var("CLI_ENABLED");
-            std::env::remove_var("GATEWAY_ENABLED");
-            std::env::remove_var("GATEWAY_HOST");
-            std::env::remove_var("GATEWAY_PORT");
-            std::env::remove_var("GATEWAY_AUTH_TOKEN");
-            std::env::remove_var("GATEWAY_USER_ID");
-            std::env::remove_var("HTTP_PORT");
-            std::env::remove_var("HTTP_HOST");
-            std::env::remove_var("SIGNAL_HTTP_URL");
-            std::env::remove_var("WASM_CHANNELS_DIR");
-            std::env::remove_var("WASM_CHANNELS_ENABLED");
-            std::env::remove_var("TELEGRAM_OWNER_ID");
-        }
-
-        let mut settings = crate::settings::Settings::default();
-        settings.channels.cli_enabled = false;
-
-        let cfg = ChannelsConfig::resolve(&settings, false).unwrap();
-        assert!(!cfg.cli.enabled, "settings should disable CLI");
-    }
-
-    /// HTTP channel should activate when settings has it enabled.
-    #[test]
-    fn resolve_http_from_settings() {
-        let _lock = crate::config::helpers::ENV_MUTEX.lock();
-        unsafe {
-            std::env::remove_var("HTTP_PORT");
-            std::env::remove_var("HTTP_HOST");
-            std::env::remove_var("HTTP_WEBHOOK_SECRET");
-            std::env::remove_var("HTTP_USER_ID");
-            std::env::remove_var("GATEWAY_ENABLED");
-            std::env::remove_var("GATEWAY_HOST");
-            std::env::remove_var("GATEWAY_PORT");
-            std::env::remove_var("GATEWAY_AUTH_TOKEN");
-            std::env::remove_var("GATEWAY_USER_ID");
-            std::env::remove_var("SIGNAL_HTTP_URL");
-            std::env::remove_var("CLI_ENABLED");
-            std::env::remove_var("WASM_CHANNELS_DIR");
-            std::env::remove_var("WASM_CHANNELS_ENABLED");
-            std::env::remove_var("TELEGRAM_OWNER_ID");
-        }
-
-        let mut settings = crate::settings::Settings::default();
+    fn resolve_uses_settings_channel_values_with_owner_scope_user_ids() {
+        let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
+        let mut settings = Settings::default();
         settings.channels.http_enabled = true;
-        settings.channels.http_port = Some(9090);
-        settings.channels.http_host = Some("10.0.0.1".to_string());
+        settings.channels.http_host = Some("127.0.0.2".to_string());
+        settings.channels.http_port = Some(8181);
+        settings.channels.gateway_enabled = true;
+        settings.channels.gateway_host = Some("127.0.0.3".to_string());
+        settings.channels.gateway_port = Some(9191);
+        settings.channels.gateway_auth_token = Some("tok".to_string());
+        settings.channels.signal_http_url = Some("http://127.0.0.1:8080".to_string());
+        settings.channels.signal_account = Some("+15551234567".to_string());
+        settings.channels.signal_allow_from = Some("+15551234567,+15557654321".to_string());
+        settings.channels.wasm_channels_dir = Some(PathBuf::from("/tmp/settings-channels"));
+        settings.channels.wasm_channels_enabled = false;
 
-        let cfg = ChannelsConfig::resolve(&settings, false).unwrap();
-        let http = cfg.http.expect("HTTP should be enabled from settings");
-        assert_eq!(http.port, 9090);
-        assert_eq!(http.host, "10.0.0.1");
-    }
+        let cfg = ChannelsConfig::resolve(&settings, "owner-scope").expect("resolve");
 
-    /// Settings round-trip through DB map for new gateway fields.
-    #[test]
-    fn settings_gateway_fields_db_roundtrip() {
-        let mut settings = crate::settings::Settings::default();
-        settings.channels.gateway_port = Some(4000);
-        settings.channels.gateway_host = Some("0.0.0.0".to_string());
-        settings.channels.gateway_auth_token = Some("tok-abc".to_string());
-        settings.channels.gateway_user_id = Some("myuser".to_string());
-        settings.channels.cli_enabled = false;
+        let http = cfg.http.expect("http config");
+        assert_eq!(http.host, "127.0.0.2");
+        assert_eq!(http.port, 8181);
+        assert_eq!(http.user_id, "owner-scope");
 
-        let map = settings.to_db_map();
-        let restored = crate::settings::Settings::from_db_map(&map);
+        let gateway = cfg.gateway.expect("gateway config");
+        assert_eq!(gateway.host, "127.0.0.3");
+        assert_eq!(gateway.port, 9191);
+        assert_eq!(gateway.auth_token.as_deref(), Some("tok"));
+        assert_eq!(gateway.user_id, "owner-scope");
+
+        let signal = cfg.signal.expect("signal config");
+        assert_eq!(signal.account, "+15551234567");
+        assert_eq!(signal.allow_from, vec!["+15551234567", "+15557654321"]);
 
-        assert_eq!(restored.channels.gateway_port, Some(4000));
-        assert_eq!(restored.channels.gateway_host.as_deref(), Some("0.0.0.0"));
         assert_eq!(
-            restored.channels.gateway_auth_token.as_deref(),
-            Some("tok-abc")
+            cfg.wasm_channels_dir,
+            PathBuf::from("/tmp/settings-channels")
         );
-        assert_eq!(restored.channels.gateway_user_id.as_deref(), Some("myuser"));
-        assert!(!restored.channels.cli_enabled);
-    }
-
-    /// Invalid boolean env values must produce errors, not silently degrade.
-    #[test]
-    fn resolve_rejects_invalid_bool_env() {
-        let _lock = crate::config::helpers::ENV_MUTEX.lock();
-        let settings = crate::settings::Settings::default();
-
-        // GATEWAY_ENABLED=maybe should error
-        unsafe {
-            std::env::set_var("GATEWAY_ENABLED", "maybe");
-            std::env::remove_var("HTTP_PORT");
-            std::env::remove_var("HTTP_HOST");
-            std::env::remove_var("SIGNAL_HTTP_URL");
-            std::env::remove_var("CLI_ENABLED");
-            std::env::remove_var("WASM_CHANNELS_ENABLED");
-            std::env::remove_var("GATEWAY_PORT");
-            std::env::remove_var("GATEWAY_HOST");
-            std::env::remove_var("GATEWAY_AUTH_TOKEN");
-            std::env::remove_var("GATEWAY_USER_ID");
-            std::env::remove_var("WASM_CHANNELS_DIR");
-            std::env::remove_var("TELEGRAM_OWNER_ID");
-        }
-        let result = ChannelsConfig::resolve(&settings, false);
-        assert!(result.is_err(), "GATEWAY_ENABLED=maybe should be rejected");
-
-        // CLI_ENABLED=on should error
-        unsafe {
-            std::env::remove_var("GATEWAY_ENABLED");
-            std::env::set_var("CLI_ENABLED", "on");
-        }
-        let result = ChannelsConfig::resolve(&settings, false);
-        assert!(result.is_err(), "CLI_ENABLED=on should be rejected");
-
-        // WASM_CHANNELS_ENABLED=yes should error
-        unsafe {
-            std::env::remove_var("CLI_ENABLED");
-            std::env::set_var("WASM_CHANNELS_ENABLED", "yes");
-        }
-        let result = ChannelsConfig::resolve(&settings, false);
-        assert!(
-            result.is_err(),
-            "WASM_CHANNELS_ENABLED=yes should be rejected"
-        );
-
-        // Cleanup
-        unsafe {
-            std::env::remove_var("WASM_CHANNELS_ENABLED");
-        }
+        assert!(!cfg.wasm_channels_enabled);
     }
 }

src/config/llm.rs

@@ -38,6 +38,8 @@ impl LlmConfig {
             provider: None,
             bedrock: None,
             request_timeout_secs: 120,
+            cheap_model: None,
+            smart_routing_cascade: false,
         }
     }
 
@@ -168,6 +170,14 @@ impl LlmConfig {
 
         let request_timeout_secs = parse_optional_env("LLM_REQUEST_TIMEOUT_SECS", 120)?;
 
+        // Generic cheap model (works with any backend).
+        // Falls back to NearAI-specific cheap_model in provider chain logic.
+        let cheap_model = optional_env("LLM_CHEAP_MODEL")?;
+
+        // Generic smart routing cascade flag.
+        // Defaults to true. Overrides NearAI-specific smart_routing_cascade.
+        let smart_routing_cascade = parse_optional_env("SMART_ROUTING_CASCADE", true)?;
+
         Ok(Self {
             backend: if is_nearai {
                 "nearai".to_string()
@@ -183,6 +193,8 @@ impl LlmConfig {
             provider,
             bedrock,
             request_timeout_secs,
+            cheap_model,
+            smart_routing_cascade,
         })
     }
 

src/config/mod.rs

@@ -26,7 +26,7 @@ mod tunnel;
 mod wasm;
 
 use std::collections::HashMap;
-use std::sync::{LazyLock, Mutex};
+use std::sync::{LazyLock, Mutex, Once};
 
 use crate::error::ConfigError;
 use crate::settings::Settings;
@@ -74,10 +74,12 @@ pub use self::helpers::{env_or_override, set_runtime_env};
 /// their data. Whichever runs first initialises the map; the second merges in.
 static INJECTED_VARS: LazyLock<Mutex<HashMap<String, String>>> =
     LazyLock::new(|| Mutex::new(HashMap::new()));
+static WARNED_EXPLICIT_DEFAULT_OWNER_ID: Once = Once::new();
 
 /// Main configuration for the agent.
 #[derive(Debug, Clone)]
 pub struct Config {
+    pub owner_id: String,
     pub database: DatabaseConfig,
     pub llm: LlmConfig,
     pub embeddings: EmbeddingsConfig,
@@ -118,6 +120,7 @@ impl Config {
         installed_skills_dir: std::path::PathBuf,
     ) -> Self {
         Self {
+            owner_id: "default".to_string(),
             database: DatabaseConfig {
                 backend: DatabaseBackend::LibSql,
                 url: secrecy::SecretString::from("unused://test".to_string()),
@@ -228,13 +231,7 @@ impl Config {
     pub async fn from_env_with_toml(
         toml_path: Option<&std::path::Path>,
     ) -> Result<Self, ConfigError> {
-        let _ = dotenvy::dotenv();
-        crate::bootstrap::load_ironclaw_env();
-        let mut settings = Settings::load();
-
-        // Overlay TOML config file (values win over JSON settings)
-        Self::apply_toml_overlay(&mut settings, toml_path)?;
-
+        let settings = load_bootstrap_settings(toml_path)?;
         Self::build(&settings).await
     }
 
@@ -306,16 +303,15 @@ impl Config {
 
     /// Build config from settings (shared by from_env and from_db).
     async fn build(settings: &Settings) -> Result<Self, ConfigError> {
-        // Resolve tunnel first so channels can default to loopback when a
-        // tunnel handles external exposure (no need to bind 0.0.0.0).
-        let tunnel = TunnelConfig::resolve(settings)?;
+        let owner_id = resolve_owner_id(settings)?;
 
         Ok(Self {
+            owner_id: owner_id.clone(),
             database: DatabaseConfig::resolve()?,
             llm: LlmConfig::resolve(settings)?,
             embeddings: EmbeddingsConfig::resolve(settings)?,
-            channels: ChannelsConfig::resolve(settings, tunnel.is_enabled())?,
-            tunnel,
+            tunnel: TunnelConfig::resolve(settings)?,
+            channels: ChannelsConfig::resolve(settings, &owner_id)?,
             agent: AgentConfig::resolve(settings)?,
             safety: resolve_safety_config(settings)?,
             wasm: WasmConfig::resolve(settings)?,
@@ -337,6 +333,43 @@ impl Config {
     }
 }
 
+pub(crate) fn load_bootstrap_settings(
+    toml_path: Option<&std::path::Path>,
+) -> Result<Settings, ConfigError> {
+    let _ = dotenvy::dotenv();
+    crate::bootstrap::load_ironclaw_env();
+
+    let mut settings = Settings::load();
+    Config::apply_toml_overlay(&mut settings, toml_path)?;
+    Ok(settings)
+}
+
+pub(crate) fn resolve_owner_id(settings: &Settings) -> Result<String, ConfigError> {
+    let env_owner_id = self::helpers::optional_env("IRONCLAW_OWNER_ID")?;
+    let settings_owner_id = settings.owner_id.clone();
+    let configured_owner_id = env_owner_id.clone().or(settings_owner_id.clone());
+
+    let owner_id = configured_owner_id
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+        .unwrap_or_else(|| "default".to_string());
+
+    if owner_id == "default"
+        && (env_owner_id.is_some()
+            || settings_owner_id
+                .as_deref()
+                .is_some_and(|value| !value.trim().is_empty()))
+    {
+        WARNED_EXPLICIT_DEFAULT_OWNER_ID.call_once(|| {
+            tracing::warn!(
+                "IRONCLAW_OWNER_ID resolved to the legacy 'default' scope explicitly; durable state will keep legacy owner behavior"
+            );
+        });
+    }
+
+    Ok(owner_id)
+}
+
 /// Load API keys from the encrypted secrets store into a thread-safe overlay.
 ///
 /// This bridges the gap between secrets stored during onboarding and the

src/config/transcription.rs

@@ -9,11 +9,15 @@ use crate::settings::Settings;
 pub struct TranscriptionConfig {
     /// Whether audio transcription is enabled.
     pub enabled: bool,
-    /// Provider: "openai" (default).
+    /// Provider: "openai" (default) or "chat_completions".
     pub provider: String,
     /// OpenAI API key (reuses OPENAI_API_KEY).
     pub openai_api_key: Option<SecretString>,
-    /// Model to use (default: "whisper-1").
+    /// Explicit transcription API key (overrides provider-specific keys).
+    pub api_key: Option<SecretString>,
+    /// LLM API key (reuses LLM_API_KEY, used as fallback for chat_completions).
+    pub llm_api_key: Option<SecretString>,
+    /// Model to use (default depends on provider).
     pub model: String,
     /// Base URL override for the transcription API.
     pub base_url: Option<String>,
@@ -25,6 +29,8 @@ impl Default for TranscriptionConfig {
             enabled: false,
             provider: "openai".to_string(),
             openai_api_key: None,
+            api_key: None,
+            llm_api_key: None,
             model: "whisper-1".to_string(),
             base_url: None,
         }
@@ -42,8 +48,15 @@ impl TranscriptionConfig {
             optional_env("TRANSCRIPTION_PROVIDER")?.unwrap_or_else(|| "openai".to_string());
 
         let openai_api_key = optional_env("OPENAI_API_KEY")?.map(SecretString::from);
+        let api_key = optional_env("TRANSCRIPTION_API_KEY")?.map(SecretString::from);
+        let llm_api_key = optional_env("LLM_API_KEY")?.map(SecretString::from);
 
-        let model = optional_env("TRANSCRIPTION_MODEL")?.unwrap_or_else(|| "whisper-1".to_string());
+        let default_model = match provider.as_str() {
+            "chat_completions" => "google/gemini-2.0-flash-001",
+            _ => "whisper-1",
+        };
+        let model =
+            optional_env("TRANSCRIPTION_MODEL")?.unwrap_or_else(|| default_model.to_string());
 
         let base_url = optional_env("TRANSCRIPTION_BASE_URL")?;
 
@@ -51,29 +64,67 @@ impl TranscriptionConfig {
             enabled,
             provider,
             openai_api_key,
+            api_key,
+            llm_api_key,
             model,
             base_url,
         })
     }
 
+    /// Resolve the API key for the configured provider.
+    ///
+    /// Priority: `TRANSCRIPTION_API_KEY` > provider-specific key.
+    fn resolve_api_key(&self) -> Option<&SecretString> {
+        self.api_key
+            .as_ref()
+            .or_else(|| match self.provider.as_str() {
+                "chat_completions" => self.llm_api_key.as_ref().or(self.openai_api_key.as_ref()),
+                _ => self.openai_api_key.as_ref(),
+            })
+    }
+
     /// Create the transcription provider if enabled and configured.
     pub fn create_provider(&self) -> Option<Box<dyn crate::transcription::TranscriptionProvider>> {
         if !self.enabled {
             return None;
         }
 
-        // Currently only OpenAI Whisper is supported; more providers can be
-        // added here with a match on self.provider.
-        let api_key = self.openai_api_key.as_ref()?;
-        tracing::info!(model = %self.model, "Audio transcription enabled via OpenAI Whisper");
+        let api_key = self.resolve_api_key()?;
 
-        let mut provider = crate::transcription::OpenAiWhisperProvider::new(api_key.clone())
-            .with_model(&self.model);
+        match self.provider.as_str() {
+            "chat_completions" => {
+                tracing::info!(
+                    model = %self.model,
+                    "Audio transcription enabled via Chat Completions API"
+                );
 
-        if let Some(ref base_url) = self.base_url {
-            provider = provider.with_base_url(base_url);
+                let mut provider = crate::transcription::ChatCompletionsTranscriptionProvider::new(
+                    api_key.clone(),
+                )
+                .with_model(&self.model);
+
+                if let Some(ref base_url) = self.base_url {
+                    provider = provider.with_base_url(base_url);
+                }
+
+                Some(Box::new(provider))
+            }
+            _ => {
+                tracing::info!(
+                    model = %self.model,
+                    "Audio transcription enabled via OpenAI Whisper"
+                );
+
+                let mut provider =
+                    crate::transcription::OpenAiWhisperProvider::new(api_key.clone())
+                        .with_model(&self.model);
+
+                if let Some(ref base_url) = self.base_url {
+                    provider = provider.with_base_url(base_url);
+                }
+
+                Some(Box::new(provider))
+            }
         }
-
-        Some(Box::new(provider))
     }
 }

src/context/manager.rs

@@ -46,11 +46,17 @@ impl ContextManager {
         description: impl Into<String>,
     ) -> Result<Uuid, JobError> {
         // Hold write lock for the entire check-insert to prevent TOCTOU races
-        // where two concurrent calls both pass the active_count check.
+        // where two concurrent calls both pass the parallel_count check.
         let mut contexts = self.contexts.write().await;
-        let active_count = contexts.values().filter(|c| c.state.is_active()).count();
+        // Only count jobs that consume execution slots (Pending, InProgress, Stuck).
+        // Completed and Submitted jobs are no longer actively executing and shouldn't
+        // block new job creation.
+        let parallel_count = contexts
+            .values()
+            .filter(|c| c.state.is_parallel_blocking())
+            .count();
 
-        if active_count >= self.max_jobs {
+        if parallel_count >= self.max_jobs {
             return Err(JobError::MaxJobsExceeded { max: self.max_jobs });
         }
 
@@ -965,4 +971,218 @@ mod tests {
         // And it's in the initial state (Pending), not modified by concurrent workers
         assert_eq!(returned_ctx.state, crate::context::JobState::Pending); // safety: test code
     }
+
+    #[tokio::test]
+    async fn sequential_routines_unlimited_completed_not_counted() {
+        // TEST: Sequential (non-parallel) routines should NOT be limited by max_jobs.
+        //
+        // Completed/Submitted jobs should NOT count toward the parallel job limit,
+        // since they're no longer actively consuming execution resources.
+        //
+        // Scenario: Create 10 sequential routines, each completing before the next starts.
+        // Currently FAILS because Completed jobs still count as "active".
+        // After fix, should PASS because only Pending/InProgress/Stuck count.
+
+        let manager = ContextManager::new(5); // max 5 truly parallel jobs
+
+        // Try to create and complete 10 sequential routines
+        for i in 0..10 {
+            let result = manager
+                .create_job(format!("Sequential Routine {}", i), "one at a time")
+                .await;
+
+            match result {
+                Ok(job_id) => {
+                    // Simulate execution: Pending -> InProgress -> Completed
+                    manager
+                        .update_context(job_id, |ctx| {
+                            ctx.transition_to(crate::context::JobState::InProgress, None)
+                        })
+                        .await
+                        .unwrap()
+                        .unwrap();
+
+                    manager
+                        .update_context(job_id, |ctx| {
+                            ctx.transition_to(crate::context::JobState::Completed, None)
+                        })
+                        .await
+                        .unwrap()
+                        .unwrap();
+
+                    println!("✓ Routine {} created and completed", i);
+                }
+                Err(JobError::MaxJobsExceeded { max }) => {
+                    panic!(
+                        "✗ Routine {} FAILED to create: MaxJobsExceeded (max={}).\n\
+                         This shows the bug: Completed jobs from routines 0-4 are still counting \
+                         toward the limit even though they're not running.\n\
+                         After the fix, this test should pass because Completed jobs won't count.",
+                        i, max
+                    );
+                }
+                Err(e) => {
+                    panic!("Unexpected error for routine {}: {:?}", i, e);
+                }
+            }
+        }
+
+        // If we reach here, all 10 routines succeeded (bug is fixed)
+        assert_eq!(manager.all_jobs().await.len(), 10);
+        println!("✓ SUCCESS: All 10 sequential routines created despite max_jobs=5 limit");
+        println!("  This is correct: Completed jobs don't count toward parallel limit");
+    }
+
+    #[tokio::test]
+    async fn parallel_jobs_limit_enforced_for_active_jobs() {
+        // TEST: Parallel (simultaneous) jobs ARE limited by max_jobs.
+        //
+        // Jobs in Pending/InProgress/Stuck states consume execution slots.
+        // The 6th truly-active job should fail because the limit is 5.
+        //
+        // This test verifies the limit DOES work correctly for parallel execution.
+
+        let manager = ContextManager::new(5); // max 5 parallel jobs
+
+        // Create 5 jobs and make them InProgress (simulating parallel execution)
+        let mut job_ids = Vec::new();
+        for i in 0..5 {
+            let job_id = manager
+                .create_job(format!("Parallel Job {}", i), "running in parallel")
+                .await
+                .expect("First 5 jobs should create successfully");
+            job_ids.push(job_id);
+
+            // Transition to InProgress (simulating active execution)
+            manager
+                .update_context(job_id, |ctx| {
+                    ctx.transition_to(crate::context::JobState::InProgress, None)
+                })
+                .await
+                .unwrap()
+                .unwrap();
+        }
+
+        // Verify all 5 jobs are InProgress
+        for job_id in &job_ids {
+            let ctx = manager.get_context(*job_id).await.unwrap();
+            assert_eq!(
+                ctx.state,
+                crate::context::JobState::InProgress,
+                "All jobs should be InProgress"
+            );
+        }
+
+        // Check active count - should be 5 (all InProgress)
+        let active_count = manager.active_count().await;
+        assert_eq!(
+            active_count, 5,
+            "Active count should be 5 (all InProgress jobs count)"
+        );
+
+        // Try to create a 6th job - should FAIL because limit is reached
+        let result = manager.create_job("Parallel Job 6", "sixth job").await;
+
+        match result {
+            Err(JobError::MaxJobsExceeded { max: 5 }) => {
+                println!("✓ SUCCESS: Parallel job limit correctly enforced at 5 active jobs");
+                println!("✓ 6th InProgress job correctly blocked when 5 are already running");
+            }
+            Ok(_) => {
+                panic!(
+                    "FAILED: 6th parallel job should have been blocked \
+                     but was created. Limit enforcement is broken."
+                );
+            }
+            Err(e) => {
+                panic!(
+                    "UNEXPECTED ERROR: Expected MaxJobsExceeded but got: {:?}",
+                    e
+                );
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn completed_jobs_should_free_slots_after_fix() {
+        // TEST: After the fix, Completed jobs should NOT count toward the limit.
+        //
+        // This test demonstrates that when a job transitions from InProgress -> Completed,
+        // it should free up a slot in the parallel execution limit.
+        //
+        // Currently FAILS (bug not fixed), proving Completed jobs incorrectly stay in the limit.
+        // After fix, this will PASS (Completed jobs freed their slot).
+
+        let manager = ContextManager::new(5); // max 5 parallel jobs
+
+        // Create 5 InProgress jobs (fill the limit)
+        let mut job_ids = Vec::new();
+        for i in 0..5 {
+            let job_id = manager
+                .create_job(format!("Job {}", i), "parallel")
+                .await
+                .unwrap();
+            job_ids.push(job_id);
+
+            manager
+                .update_context(job_id, |ctx| {
+                    ctx.transition_to(crate::context::JobState::InProgress, None)
+                })
+                .await
+                .unwrap()
+                .unwrap();
+        }
+
+        // Verify limit is hit
+        let result = manager.create_job("Job 5", "should fail").await;
+        assert!(
+            matches!(result, Err(JobError::MaxJobsExceeded { max: 5 })),
+            "Limit should be hit with 5 InProgress jobs"
+        );
+        println!("✓ Limit enforced: 5 InProgress jobs block 6th creation");
+
+        // Now transition job 0 from InProgress -> Completed
+        manager
+            .update_context(job_ids[0], |ctx| {
+                ctx.transition_to(crate::context::JobState::Completed, None)
+            })
+            .await
+            .unwrap()
+            .unwrap();
+
+        println!("✓ Job 0 transitioned: InProgress -> Completed");
+
+        // Try to create a 6th job - this will FAIL until the bug is fixed
+        let result = manager
+            .create_job("Job 5 (retry)", "after 1 Completed")
+            .await;
+
+        match result {
+            Ok(job_6) => {
+                println!("✓ SUCCESS: 6th job created after job 0 completed");
+                println!("✓ This proves Completed jobs don't count toward the limit (BUG FIXED)");
+
+                // Verify we can transition it to InProgress
+                manager
+                    .update_context(job_6, |ctx| {
+                        ctx.transition_to(crate::context::JobState::InProgress, None)
+                    })
+                    .await
+                    .unwrap()
+                    .unwrap();
+                println!("✓ 6th job now InProgress: 4 remaining + 1 new = 5 limit reached");
+            }
+            Err(JobError::MaxJobsExceeded { max: 5 }) => {
+                panic!(
+                    "✗ BUG NOT FIXED: 6th job creation still blocked after freeing slot.\n\
+                     State: 1 Completed (job 0) + 4 InProgress (jobs 1-4) = 5 active\n\
+                     BUG: Completed job 0 still counts toward limit\n\
+                     EXPECTED: Only 4 InProgress count, 1 slot free"
+                );
+            }
+            Err(e) => {
+                panic!("Unexpected error: {:?}", e);
+            }
+        }
+    }
 }

src/context/state.rs

@@ -81,6 +81,15 @@ impl JobState {
     pub fn is_active(&self) -> bool {
         !self.is_terminal()
     }
+
+    /// Check if this job consumes a parallel execution slot.
+    ///
+    /// Only jobs in Pending, InProgress, or Stuck states consume execution resources
+    /// and should count toward the parallel job limit. Completed and Submitted jobs
+    /// are in the state machine but are no longer actively executing.
+    pub fn is_parallel_blocking(&self) -> bool {
+        matches!(self, Self::Pending | Self::InProgress | Self::Stuck)
+    }
 }
 
 impl std::fmt::Display for JobState {
@@ -121,6 +130,9 @@ pub struct JobContext {
     pub state: JobState,
     /// User ID that owns this job (for workspace scoping).
     pub user_id: String,
+    /// Channel-specific requester/actor ID, when different from the owner scope.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub requester_id: Option<String>,
     /// Conversation ID if linked to a conversation.
     pub conversation_id: Option<Uuid>,
     /// Job title.
@@ -202,6 +214,7 @@ impl JobContext {
             job_id: Uuid::new_v4(),
             state: JobState::Pending,
             user_id: user_id.into(),
+            requester_id: None,
             conversation_id: None,
             title: title.into(),
             description: description.into(),
@@ -233,6 +246,12 @@ impl JobContext {
         self
     }
 
+    /// Set the channel-specific requester/actor ID.
+    pub fn with_requester_id(mut self, requester_id: impl Into<String>) -> Self {
+        self.requester_id = Some(requester_id.into());
+        self
+    }
+
     /// Transition to a new state.
     pub fn transition_to(
         &mut self,

src/db/libsql/jobs.rs

@@ -106,6 +106,7 @@ impl JobStore for LibSqlBackend {
                     job_id: get_text(&row, 0).parse().unwrap_or_default(),
                     state,
                     user_id: get_text(&row, 6),
+                    requester_id: None,
                     conversation_id: get_opt_text(&row, 1).and_then(|s| s.parse().ok()),
                     title: get_text(&row, 2),
                     description: get_text(&row, 3),

src/db/libsql/mod.rs

@@ -247,6 +247,17 @@ pub(crate) fn opt_text_owned(s: Option<String>) -> libsql::Value {
     }
 }
 
+pub(crate) fn normalize_notify_user(value: Option<String>) -> Option<String> {
+    value.and_then(|value| {
+        let trimmed = value.trim();
+        if trimmed.is_empty() || trimmed == "default" {
+            None
+        } else {
+            Some(trimmed.to_string())
+        }
+    })
+}
+
 /// Extract an i64 column, defaulting to 0.
 pub(crate) fn get_i64(row: &libsql::Row, idx: i32) -> i64 {
     row.get::<i64>(idx).unwrap_or(0)
@@ -378,7 +389,7 @@ pub(crate) fn row_to_routine_libsql(row: &libsql::Row) -> Result<Routine, Databa
         },
         notify: NotifyConfig {
             channel: get_opt_text(row, 12),
-            user: get_text(row, 13),
+            user: normalize_notify_user(get_opt_text(row, 13)),
             on_success: get_i64(row, 14) != 0,
             on_failure: get_i64(row, 15) != 0,
             on_attention: get_i64(row, 16) != 0,
@@ -419,7 +430,17 @@ mod tests {
     use chrono::{TimeZone, Utc};
 
     use crate::db::Database;
-    use crate::db::libsql::{LibSqlBackend, parse_timestamp};
+    use crate::db::libsql::{LibSqlBackend, normalize_notify_user, parse_timestamp};
+
+    #[test]
+    fn test_normalize_notify_user_treats_legacy_default_as_missing() {
+        assert_eq!(normalize_notify_user(None), None); // safety: test-only assertion
+        assert_eq!(normalize_notify_user(Some(String::new())), None); // safety: test-only assertion
+        assert_eq!(normalize_notify_user(Some("   ".to_string())), None); // safety: test-only assertion
+        assert_eq!(normalize_notify_user(Some("default".to_string())), None); // safety: test-only assertion
+        let normalized = normalize_notify_user(Some("123456789".to_string()));
+        assert_eq!(normalized, Some("123456789".to_string())); // safety: test-only assertion
+    }
 
     #[test]
     fn test_parse_timestamp_accepts_rfc3339_and_legacy_naive_formats() {

src/db/libsql/routines.rs

@@ -57,7 +57,7 @@ impl RoutineStore for LibSqlBackend {
                     max_concurrent,
                     dedup_window_secs,
                     opt_text(routine.notify.channel.as_deref()),
-                    routine.notify.user.as_str(),
+                    opt_text(routine.notify.user.as_deref()),
                     routine.notify.on_success as i64,
                     routine.notify.on_failure as i64,
                     routine.notify.on_attention as i64,
@@ -250,7 +250,7 @@ impl RoutineStore for LibSqlBackend {
                 max_concurrent,
                 dedup_window_secs,
                 opt_text(routine.notify.channel.as_deref()),
-                routine.notify.user.as_str(),
+                opt_text(routine.notify.user.as_deref()),
                 routine.notify.on_success as i64,
                 routine.notify.on_failure as i64,
                 routine.notify.on_attention as i64,

src/db/libsql_migrations.rs

@@ -462,7 +462,7 @@ CREATE TABLE IF NOT EXISTS routines (
     max_concurrent INTEGER NOT NULL DEFAULT 1,
     dedup_window_secs INTEGER,
     notify_channel TEXT,
-    notify_user TEXT NOT NULL DEFAULT 'default',
+    notify_user TEXT,
     notify_on_success INTEGER NOT NULL DEFAULT 0,
     notify_on_failure INTEGER NOT NULL DEFAULT 1,
     notify_on_attention INTEGER NOT NULL DEFAULT 1,
@@ -546,7 +546,9 @@ CREATE INDEX IF NOT EXISTS idx_tool_failures_unrepaired ON tool_failures(tool_na
 
 -- routines
 CREATE INDEX IF NOT EXISTS idx_routines_next_fire ON routines(next_fire_at);
-CREATE INDEX IF NOT EXISTS idx_routines_event_triggers ON routines(user_id);
+CREATE INDEX IF NOT EXISTS idx_routines_event_triggers
+    ON routines(trigger_type, user_id)
+    WHERE enabled = 1 AND trigger_type IN ('event', 'system_event');
 
 -- routine_runs
 CREATE INDEX IF NOT EXISTS idx_routine_runs_status ON routine_runs(status);
@@ -654,6 +656,74 @@ END;
         r#"
 ALTER TABLE agent_jobs ADD COLUMN max_tokens INTEGER NOT NULL DEFAULT 0;
 ALTER TABLE agent_jobs ADD COLUMN total_tokens_used INTEGER NOT NULL DEFAULT 0;
+"#,
+    ),
+    (
+        13,
+        "routine_notify_user_nullable",
+        // Remove the legacy 'default' sentinel from routine notify_user.
+        // SQLite cannot drop NOT NULL / DEFAULT constraints in place, so we
+        // rebuild the table and normalize existing 'default' values to NULL.
+        r#"
+PRAGMA foreign_keys=OFF;
+
+CREATE TABLE IF NOT EXISTS routines_new (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    description TEXT NOT NULL DEFAULT '',
+    user_id TEXT NOT NULL,
+    enabled INTEGER NOT NULL DEFAULT 1,
+    trigger_type TEXT NOT NULL,
+    trigger_config TEXT NOT NULL,
+    action_type TEXT NOT NULL,
+    action_config TEXT NOT NULL,
+    cooldown_secs INTEGER NOT NULL DEFAULT 300,
+    max_concurrent INTEGER NOT NULL DEFAULT 1,
+    dedup_window_secs INTEGER,
+    notify_channel TEXT,
+    notify_user TEXT,
+    notify_on_success INTEGER NOT NULL DEFAULT 0,
+    notify_on_failure INTEGER NOT NULL DEFAULT 1,
+    notify_on_attention INTEGER NOT NULL DEFAULT 1,
+    state TEXT NOT NULL DEFAULT '{}',
+    last_run_at TEXT,
+    next_fire_at TEXT,
+    run_count INTEGER NOT NULL DEFAULT 0,
+    consecutive_failures INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+    UNIQUE (user_id, name)
+);
+
+INSERT INTO routines_new (
+    id, name, description, user_id, enabled,
+    trigger_type, trigger_config, action_type, action_config,
+    cooldown_secs, max_concurrent, dedup_window_secs,
+    notify_channel, notify_user, notify_on_success, notify_on_failure, notify_on_attention,
+    state, last_run_at, next_fire_at, run_count, consecutive_failures,
+    created_at, updated_at
+)
+SELECT
+    id, name, description, user_id, enabled,
+    trigger_type, trigger_config, action_type, action_config,
+    cooldown_secs, max_concurrent, dedup_window_secs,
+    notify_channel,
+    CASE WHEN notify_user = 'default' THEN NULL ELSE notify_user END,
+    notify_on_success, notify_on_failure, notify_on_attention,
+    state, last_run_at, next_fire_at, run_count, consecutive_failures,
+    created_at, updated_at
+FROM routines;
+
+DROP TABLE routines;
+ALTER TABLE routines_new RENAME TO routines;
+
+CREATE INDEX IF NOT EXISTS idx_routines_user ON routines(user_id);
+CREATE INDEX IF NOT EXISTS idx_routines_next_fire ON routines(next_fire_at);
+CREATE INDEX IF NOT EXISTS idx_routines_event_triggers
+    ON routines(trigger_type, user_id)
+    WHERE enabled = 1 AND trigger_type IN ('event', 'system_event');
+
+PRAGMA foreign_keys=ON;
 "#,
     ),
 ];

src/db/tls.rs

@@ -5,13 +5,22 @@
 //! certificates — the same TLS stack that `reqwest` already uses for HTTP.
 
 use deadpool_postgres::{Pool, Runtime};
+use thiserror::Error;
 use tokio_postgres::NoTls;
 use tokio_postgres_rustls::MakeRustlsConnect;
 
 use crate::config::SslMode;
 
+#[derive(Debug, Error)]
+pub enum CreatePoolError {
+    #[error("{0}")]
+    Pool(#[from] deadpool_postgres::CreatePoolError),
+    #[error("postgres TLS configuration failed: {0}")]
+    TlsConfig(#[from] rustls::Error),
+}
+
 /// Build a rustls-based TLS connector using the platform's root certificate store.
-fn make_rustls_connector() -> MakeRustlsConnect {
+fn make_rustls_connector() -> Result<MakeRustlsConnect, rustls::Error> {
     let mut root_store = rustls::RootCertStore::empty();
     let native = rustls_native_certs::load_native_certs();
     for e in &native.errors {
@@ -25,10 +34,15 @@ fn make_rustls_connector() -> MakeRustlsConnect {
     if root_store.is_empty() {
         tracing::error!("no system root certificates found -- TLS connections will fail");
     }
-    let config = rustls::ClientConfig::builder()
-        .with_root_certificates(root_store)
-        .with_no_client_auth();
-    MakeRustlsConnect::new(config)
+    // `--all-features` brings in both aws-lc-rs and ring-backed rustls providers.
+    // Pick the same ring provider reqwest already uses so postgres TLS setup stays deterministic.
+    let config = rustls::ClientConfig::builder_with_provider(
+        rustls::crypto::ring::default_provider().into(),
+    )
+    .with_safe_default_protocol_versions()?
+    .with_root_certificates(root_store)
+    .with_no_client_auth();
+    Ok(MakeRustlsConnect::new(config))
 }
 
 /// Create a [`deadpool_postgres::Pool`] with the appropriate TLS connector.
@@ -45,12 +59,16 @@ fn make_rustls_connector() -> MakeRustlsConnect {
 pub fn create_pool(
     config: &deadpool_postgres::Config,
     ssl_mode: SslMode,
-) -> Result<Pool, deadpool_postgres::CreatePoolError> {
+) -> Result<Pool, CreatePoolError> {
     match ssl_mode {
-        SslMode::Disable => config.create_pool(Some(Runtime::Tokio1), NoTls),
+        SslMode::Disable => config
+            .create_pool(Some(Runtime::Tokio1), NoTls)
+            .map_err(CreatePoolError::from),
         SslMode::Prefer | SslMode::Require => {
-            let tls = make_rustls_connector();
-            config.create_pool(Some(Runtime::Tokio1), tls)
+            let tls = make_rustls_connector()?;
+            config
+                .create_pool(Some(Runtime::Tokio1), tls)
+                .map_err(CreatePoolError::from)
         }
     }
 }

src/error.rs

@@ -122,6 +122,9 @@ pub enum ChannelError {
     #[error("Failed to send response on channel {name}: {reason}")]
     SendFailed { name: String, reason: String },
 
+    #[error("Channel {name} is missing a routing target: {reason}")]
+    MissingRoutingTarget { name: String, reason: String },
+
     #[error("Invalid message format: {0}")]
     InvalidMessage(String),
 

src/extensions/mod.rs

@@ -453,6 +453,17 @@ pub struct ActivateResult {
 ///
 /// Returned by `ExtensionManager::configure()`, the single entrypoint
 /// for providing secrets to any extension (chat auth, gateway setup, etc.).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct VerificationChallenge {
+    /// One-time code the user must send back to the integration.
+    pub code: String,
+    /// Human-readable instructions for completing verification.
+    pub instructions: String,
+    /// Deep-link or shortcut URL that prefills the verification payload when supported.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub deep_link: Option<String>,
+}
+
 #[derive(Debug, Clone)]
 pub struct ConfigureResult {
     /// Human-readable status message.
@@ -461,6 +472,8 @@ pub struct ConfigureResult {
     pub activated: bool,
     /// OAuth authorization URL (if OAuth flow was started).
     pub auth_url: Option<String>,
+    /// Pending manual verification challenge (for Telegram owner binding, etc.).
+    pub verification: Option<VerificationChallenge>,
 }
 
 fn default_true() -> bool {

src/history/store.rs

@@ -227,6 +227,7 @@ impl Store {
                     job_id: row.get("id"),
                     state,
                     user_id: row.get::<_, String>("user_id"),
+                    requester_id: None,
                     conversation_id: row.get("conversation_id"),
                     title: row.get("title"),
                     description: row.get("description"),

src/llm/anthropic_oauth.rs

@@ -143,12 +143,14 @@ impl AnthropicOAuthProvider {
 
         if !status.is_success() {
             // Parse Retry-After header before consuming the body.
+            // Falls back to 60s if header is missing or unparseable (prevents "retry after None" errors).
             let retry_after = response
                 .headers()
                 .get("retry-after")
                 .and_then(|v| v.to_str().ok())
                 .and_then(|v| v.parse::<u64>().ok())
-                .map(std::time::Duration::from_secs);
+                .map(std::time::Duration::from_secs)
+                .or(Some(std::time::Duration::from_secs(60)));
 
             let response_text = response
                 .text()
@@ -705,4 +707,78 @@ mod tests {
         // Subsequent reads see the updated token
         assert_eq!(token.read().unwrap().expose_secret(), "new_token");
     }
+
+    // -- Retry-After header parsing tests (regression for rate limit "None" bug) --
+
+    #[test]
+    fn test_retry_after_parsing_delay_seconds() {
+        // Verify delay-seconds format is parsed correctly
+        let header_value = "45";
+        let duration = parse_retry_after_anthropic_for_test(header_value);
+        assert_eq!(
+            duration,
+            Some(std::time::Duration::from_secs(45)),
+            "Should parse delay-seconds format"
+        );
+    }
+
+    #[test]
+    fn test_retry_after_fallback_missing_header() {
+        // Regression test: When Retry-After header is missing,
+        // should fall back to 60s instead of None
+        let duration = parse_retry_after_anthropic_for_test("");
+        assert_eq!(
+            duration,
+            Some(std::time::Duration::from_secs(60)),
+            "Missing header should fallback to 60s"
+        );
+    }
+
+    #[test]
+    fn test_retry_after_fallback_invalid_format() {
+        // Regression test: When Retry-After header is in unexpected format,
+        // should fall back to 60s instead of None
+        let invalid_formats = vec![
+            "invalid",
+            "not-a-number",
+            "30.5", // float instead of int
+            "abc123",
+            "Mon, 02 Mar 2026 18:00:00 GMT", // RFC2822 not supported in anthropic version
+        ];
+
+        for format in invalid_formats {
+            let duration = parse_retry_after_anthropic_for_test(format);
+            assert_eq!(
+                duration,
+                Some(std::time::Duration::from_secs(60)),
+                "Invalid format '{}' should fallback to 60s",
+                format
+            );
+        }
+    }
+
+    #[test]
+    fn test_retry_after_zero_seconds_accepted() {
+        // Verify zero seconds is a valid retry delay
+        let duration = parse_retry_after_anthropic_for_test("0");
+        assert_eq!(duration, Some(std::time::Duration::ZERO));
+    }
+
+    #[test]
+    fn test_retry_after_large_number() {
+        // Verify large numbers are accepted
+        let duration = parse_retry_after_anthropic_for_test("7200"); // 2 hours
+        assert_eq!(duration, Some(std::time::Duration::from_secs(7200)));
+    }
+
+    /// Helper function to test Retry-After header parsing logic for Anthropic
+    /// (simulates the parsing done in send_request without actual HTTP, including fallback)
+    fn parse_retry_after_anthropic_for_test(header_value: &str) -> Option<std::time::Duration> {
+        header_value
+            .trim()
+            .parse::<u64>()
+            .ok()
+            .map(std::time::Duration::from_secs)
+            .or(Some(std::time::Duration::from_secs(60)))
+    }
 }

src/llm/config.rs

@@ -138,6 +138,30 @@ pub struct LlmConfig {
     /// Default: 120. Increase for local LLMs (Ollama, vLLM, LM Studio) that
     /// need more time for prompt evaluation on consumer hardware.
     pub request_timeout_secs: u64,
+    /// Generic cheap/fast model for lightweight tasks (heartbeat, routing, evaluation).
+    /// Works with any backend. Set via `LLM_CHEAP_MODEL` env var.
+    /// When set, takes priority over the NearAI-specific `NEARAI_CHEAP_MODEL`.
+    pub cheap_model: Option<String>,
+    /// Enable cascade mode for smart routing (retry with primary if cheap model
+    /// response seems uncertain). Default: true. Set via `SMART_ROUTING_CASCADE`.
+    pub smart_routing_cascade: bool,
+}
+
+impl LlmConfig {
+    /// Resolve the effective cheap model name.
+    ///
+    /// Resolution order:
+    /// 1. `LLM_CHEAP_MODEL` (generic, works with any backend)
+    /// 2. `NEARAI_CHEAP_MODEL` (NearAI-only, backward compatibility)
+    pub fn cheap_model_name(&self) -> Option<&str> {
+        self.cheap_model.as_deref().or_else(|| {
+            if self.backend == "nearai" {
+                self.nearai.cheap_model.as_deref()
+            } else {
+                None
+            }
+        })
+    }
 }
 
 /// NEAR AI configuration.

src/llm/mod.rs

@@ -378,32 +378,61 @@ fn create_ollama_from_registry(
 
 /// Create a cheap/fast LLM provider for lightweight tasks (heartbeat, routing, evaluation).
 ///
-/// Uses `NEARAI_CHEAP_MODEL` if set, otherwise falls back to the main provider.
-/// Currently only supports NEAR AI backend.
+/// Resolution order:
+/// 1. `LLM_CHEAP_MODEL` (generic, works with any backend)
+/// 2. `NEARAI_CHEAP_MODEL` (NearAI-only, backward compatibility)
+///
+/// Returns `None` if no cheap model is configured.
 pub fn create_cheap_llm_provider(
     config: &LlmConfig,
     session: Arc<SessionManager>,
 ) -> Result<Option<Arc<dyn LlmProvider>>, LlmError> {
-    let Some(ref cheap_model) = config.nearai.cheap_model else {
+    let Some(cheap_model) = config.cheap_model_name() else {
         return Ok(None);
     };
 
-    if config.backend != "nearai" {
-        tracing::warn!(
-            "NEARAI_CHEAP_MODEL is set but LLM_BACKEND is '{}', not nearai. \
-             Cheap model setting will be ignored.",
-            config.backend
-        );
-        return Ok(None);
+    create_cheap_provider_for_backend(config, session, cheap_model)
+}
+
+/// Create a cheap provider for a specific backend.
+///
+/// Handles backend-specific provider construction:
+/// - `nearai` — clones NearAiConfig, swaps model, uses `create_llm_provider_with_config`
+/// - `bedrock` — returns error (smart routing not yet supported)
+/// - All others — clones `RegistryProviderConfig`, swaps model, uses `create_registry_provider`
+fn create_cheap_provider_for_backend(
+    config: &LlmConfig,
+    session: Arc<SessionManager>,
+    cheap_model: &str,
+) -> Result<Option<Arc<dyn LlmProvider>>, LlmError> {
+    if config.backend == "nearai" {
+        let mut cheap_config = config.nearai.clone();
+        cheap_config.model = cheap_model.to_string();
+        let provider =
+            create_llm_provider_with_config(&cheap_config, session, config.request_timeout_secs)?;
+        return Ok(Some(provider));
     }
 
-    let mut cheap_config = config.nearai.clone();
-    cheap_config.model = cheap_model.clone();
+    if config.backend == "bedrock" {
+        return Err(LlmError::RequestFailed {
+            provider: "bedrock".to_string(),
+            reason: "Smart routing with cheap model is not supported for Bedrock yet".to_string(),
+        });
+    }
 
-    Ok(Some(Arc::new(NearAiChatProvider::new(
-        cheap_config,
-        session,
-    )?)))
+    // Registry-based provider: clone config and swap model
+    let reg_config = config.provider.as_ref().ok_or_else(|| LlmError::RequestFailed {
+        provider: config.backend.clone(),
+        reason: format!(
+            "Cannot create cheap provider for backend '{}': no registry provider config available",
+            config.backend
+        ),
+    })?;
+
+    let mut cheap_reg_config = reg_config.clone();
+    cheap_reg_config.model = cheap_model.to_string();
+    let provider = create_registry_provider(&cheap_reg_config, config.request_timeout_secs)?;
+    Ok(Some(provider))
 }
 
 /// Build the full LLM provider chain with all configured wrappers.
@@ -451,14 +480,15 @@ pub async fn build_provider_chain(
     };
 
     // 2. Smart routing (cheap/primary split)
-    let llm: Arc<dyn LlmProvider> = if let Some(ref cheap_model) = config.nearai.cheap_model {
-        let mut cheap_config = config.nearai.clone();
-        cheap_config.model = cheap_model.clone();
-        let cheap = create_llm_provider_with_config(
-            &cheap_config,
-            session.clone(),
-            config.request_timeout_secs,
-        )?;
+    let llm: Arc<dyn LlmProvider> = if let Some(cheap_model) = config.cheap_model_name() {
+        let cheap = create_cheap_provider_for_backend(config, session.clone(), cheap_model)?
+            .ok_or_else(|| LlmError::RequestFailed {
+                provider: config.backend.clone(),
+                reason: format!(
+                    "Failed to create cheap provider for model '{cheap_model}' on backend '{}'",
+                    config.backend
+                ),
+            })?;
         let cheap: Arc<dyn LlmProvider> = if retry_config.max_retries > 0 {
             Arc::new(RetryProvider::new(cheap, retry_config.clone()))
         } else {
@@ -473,7 +503,7 @@ pub async fn build_provider_chain(
             llm,
             cheap,
             SmartRoutingConfig {
-                cascade_enabled: config.nearai.smart_routing_cascade,
+                cascade_enabled: config.smart_routing_cascade,
                 ..SmartRoutingConfig::default()
             },
         ))
@@ -602,6 +632,8 @@ mod tests {
             provider: None,
             bedrock: None,
             request_timeout_secs: 120,
+            cheap_model: None,
+            smart_routing_cascade: true,
         }
     }
 
@@ -616,7 +648,7 @@ mod tests {
     }
 
     #[test]
-    fn test_create_cheap_llm_provider_creates_provider_when_configured() {
+    fn test_create_cheap_llm_provider_creates_provider_with_nearai_cheap_model() {
         let mut config = test_llm_config();
         config.nearai.cheap_model = Some("cheap-test-model".to_string());
 
@@ -630,7 +662,26 @@ mod tests {
     }
 
     #[test]
-    fn test_create_cheap_llm_provider_ignored_for_non_nearai_backend() {
+    fn test_create_cheap_llm_provider_generic_overrides_nearai() {
+        let mut config = test_llm_config();
+        config.nearai.cheap_model = Some("nearai-cheap".to_string());
+        config.cheap_model = Some("generic-cheap".to_string());
+
+        let session = Arc::new(SessionManager::new(SessionConfig::default()));
+        let result = create_cheap_llm_provider(&config, session);
+
+        assert!(result.is_ok());
+        let provider = result.unwrap();
+        assert!(provider.is_some());
+        assert_eq!(
+            provider.unwrap().model_name(),
+            "generic-cheap",
+            "LLM_CHEAP_MODEL should take priority over NEARAI_CHEAP_MODEL"
+        );
+    }
+
+    #[test]
+    fn test_create_cheap_llm_provider_nearai_cheap_ignored_for_non_nearai_backend() {
         let mut config = test_llm_config();
         config.backend = "openai".to_string();
         config.nearai.cheap_model = Some("cheap-test-model".to_string());
@@ -639,6 +690,48 @@ mod tests {
         let result = create_cheap_llm_provider(&config, session);
 
         assert!(result.is_ok());
-        assert!(result.unwrap().is_none());
+        assert!(
+            result.unwrap().is_none(),
+            "NEARAI_CHEAP_MODEL should be ignored when backend is not nearai"
+        );
+    }
+
+    #[test]
+    fn test_create_cheap_llm_provider_bedrock_returns_error() {
+        let mut config = test_llm_config();
+        config.backend = "bedrock".to_string();
+        config.cheap_model = Some("cheap-model".to_string());
+
+        let session = Arc::new(SessionManager::new(SessionConfig::default()));
+        let result = create_cheap_llm_provider(&config, session);
+
+        assert!(
+            result.is_err(),
+            "Bedrock should return an error for cheap model"
+        );
+    }
+
+    #[test]
+    fn test_cheap_model_name_resolution() {
+        // Generic takes priority
+        let mut config = test_llm_config();
+        config.cheap_model = Some("generic".to_string());
+        config.nearai.cheap_model = Some("nearai".to_string());
+        assert_eq!(config.cheap_model_name(), Some("generic"));
+
+        // NearAI fallback when backend is nearai
+        let mut config = test_llm_config();
+        config.nearai.cheap_model = Some("nearai".to_string());
+        assert_eq!(config.cheap_model_name(), Some("nearai"));
+
+        // NearAI ignored for non-nearai backend
+        let mut config = test_llm_config();
+        config.backend = "openai".to_string();
+        config.nearai.cheap_model = Some("nearai".to_string());
+        assert_eq!(config.cheap_model_name(), None);
+
+        // None when nothing configured
+        let config = test_llm_config();
+        assert_eq!(config.cheap_model_name(), None);
     }
 }

src/llm/models.rs

@@ -345,5 +345,7 @@ pub(crate) fn build_nearai_model_fetch_config() -> crate::config::LlmConfig {
         provider: None,
         bedrock: None,
         request_timeout_secs: 120,
+        cheap_model: None,
+        smart_routing_cascade: false,
     }
 }

src/llm/nearai_chat.rs

@@ -215,6 +215,7 @@ impl NearAiChatProvider {
         let status = response.status();
         // Extract Retry-After header before consuming the response body.
         // Supports both delay-seconds (RFC 7231 §7.1.3) and HTTP-date formats.
+        // Falls back to 60s if header is missing or unparseable (prevents "retry after None" errors).
         let retry_after_header = response
             .headers()
             .get("retry-after")
@@ -235,7 +236,8 @@ impl NearAiChatProvider {
                     ));
                 }
                 None
-            });
+            })
+            .or(Some(std::time::Duration::from_secs(60)));
         let response_text = response.text().await.map_err(|e| LlmError::RequestFailed {
             provider: "nearai_chat".to_string(),
             reason: format!("Failed to read response body: {}", e),
@@ -2187,4 +2189,115 @@ mod tests {
             "http://example.com/api/proxy/v1/chat/completions"
         );
     }
+
+    // -- Retry-After header parsing tests (regression for rate limit "None" bug) --
+
+    #[test]
+    fn test_retry_after_parsing_delay_seconds() {
+        // Verify delay-seconds format (most common) is parsed correctly
+        let header_value = "30";
+        let duration = parse_retry_after_for_test(header_value);
+        assert_eq!(duration, Some(std::time::Duration::from_secs(30)));
+    }
+
+    #[test]
+    fn test_retry_after_parsing_rfc2822_date() {
+        // Verify HTTP-date (RFC 2822) format is parsed correctly
+        // Use a date 60 seconds in the future
+        let now = chrono::Utc::now();
+        let future = now + chrono::Duration::seconds(60);
+        let date_str = future.to_rfc2822();
+
+        let duration = parse_retry_after_for_test(&date_str);
+        assert!(duration.is_some());
+        let d = duration.unwrap();
+        // Allow ±5 seconds of drift due to processing time
+        assert!(
+            d.as_secs() >= 55 && d.as_secs() <= 65,
+            "Expected ~60s, got {}s",
+            d.as_secs()
+        );
+    }
+
+    #[test]
+    fn test_retry_after_fallback_missing_header() {
+        // Regression test: When Retry-After header is missing,
+        // should fall back to 60s instead of None
+        let duration = parse_retry_after_for_test("");
+        assert_eq!(
+            duration,
+            Some(std::time::Duration::from_secs(60)),
+            "Missing header should fallback to 60s"
+        );
+    }
+
+    #[test]
+    fn test_retry_after_fallback_invalid_format() {
+        // Regression test: When Retry-After header is in unexpected format,
+        // should fall back to 60s instead of None
+        let invalid_formats = vec![
+            "invalid",
+            "not-a-number",
+            "30.5", // float instead of int
+            "abc123",
+        ];
+
+        for format in invalid_formats {
+            let duration = parse_retry_after_for_test(format);
+            assert_eq!(
+                duration,
+                Some(std::time::Duration::from_secs(60)),
+                "Invalid format '{}' should fallback to 60s",
+                format
+            );
+        }
+    }
+
+    #[test]
+    fn test_retry_after_past_date_returns_zero() {
+        // When HTTP-date is in the past, should return Duration::ZERO
+        // (not None, which would trigger immediate retry)
+        let past = chrono::Utc::now() - chrono::Duration::seconds(60);
+        let past_date_str = past.to_rfc2822();
+
+        let duration = parse_retry_after_for_test(&past_date_str);
+        assert_eq!(
+            duration,
+            Some(std::time::Duration::ZERO),
+            "Past date should return Duration::ZERO, not None"
+        );
+    }
+
+    #[test]
+    fn test_retry_after_zero_seconds_accepted() {
+        // Verify zero seconds is a valid retry delay
+        let duration = parse_retry_after_for_test("0");
+        assert_eq!(duration, Some(std::time::Duration::ZERO));
+    }
+
+    #[test]
+    fn test_retry_after_large_number() {
+        // Verify large numbers are accepted
+        let duration = parse_retry_after_for_test("3600"); // 1 hour
+        assert_eq!(duration, Some(std::time::Duration::from_secs(3600)));
+    }
+
+    /// Helper function to test Retry-After header parsing logic
+    /// (simulates the parsing done in send_request without actual HTTP, including fallback)
+    fn parse_retry_after_for_test(header_value: &str) -> Option<std::time::Duration> {
+        let trimmed = header_value.trim();
+        let parsed = if let Ok(secs) = trimmed.parse::<u64>() {
+            Some(std::time::Duration::from_secs(secs))
+        } else if let Ok(dt) = chrono::DateTime::parse_from_rfc2822(trimmed) {
+            let now = chrono::Utc::now();
+            let delta = dt.signed_duration_since(now);
+            Some(std::time::Duration::from_secs(
+                delta.num_seconds().max(0) as u64
+            ))
+        } else {
+            None
+        };
+        // Apply fallback to 60s if parsing failed (matches actual code behavior)
+        parsed.or(Some(std::time::Duration::from_secs(60)))
+    }
 }

src/llm/retry.rs

@@ -394,4 +394,31 @@ mod tests {
         assert_eq!(retry.cost_per_token(), (Decimal::ZERO, Decimal::ZERO));
         assert_eq!(retry.calculate_cost(100, 50), Decimal::ZERO);
     }
+
+    // Regression test: Rate limiter fallback when Retry-After header is missing
+    //
+    // Verifies that RateLimited errors always have a duration (never None)
+    // due to the 60-second fallback applied in all rate limit error creation sites
+    // (nearai_chat.rs, anthropic_oauth.rs, embeddings.rs).
+    #[test]
+    fn rate_limited_error_always_has_duration() {
+        let err = LlmError::RateLimited {
+            provider: "test".to_string(),
+            retry_after: Some(std::time::Duration::from_secs(60)),
+        };
+
+        if let LlmError::RateLimited { retry_after, .. } = err {
+            assert!(
+                retry_after.is_some(),
+                "Rate limited error should always have retry_after duration"
+            );
+            assert_eq!(
+                retry_after,
+                Some(std::time::Duration::from_secs(60)),
+                "Fallback should be 60 seconds"
+            );
+        } else {
+            panic!("Expected RateLimited error");
+        }
+    }
 }

src/main.rs

@@ -153,7 +153,8 @@ async fn async_main() -> anyhow::Result<()> {
                     provider_only: *provider_only,
                     quick: *quick,
                 };
-                let mut wizard = SetupWizard::with_config(config);
+                let mut wizard =
+                    SetupWizard::try_with_config_and_toml(config, cli.config.as_deref())?;
                 wizard.run().await?;
             }
             #[cfg(not(any(feature = "postgres", feature = "libsql")))]
@@ -195,10 +196,13 @@ async fn async_main() -> anyhow::Result<()> {
     {
         println!("Onboarding needed: {}", reason);
         println!();
-        let mut wizard = SetupWizard::with_config(SetupConfig {
-            quick: true,
-            ..Default::default()
-        });
+        let mut wizard = SetupWizard::try_with_config_and_toml(
+            SetupConfig {
+                quick: true,
+                ..Default::default()
+            },
+            cli.config.as_deref(),
+        )?;
         wizard.run().await?;
     }
 
@@ -282,9 +286,12 @@ async fn async_main() -> anyhow::Result<()> {
 
     // Create CLI channel
     let repl_channel = if let Some(ref msg) = cli.message {
-        Some(ReplChannel::with_message(msg.clone()))
+        Some(ReplChannel::with_message_for_user(
+            config.owner_id.clone(),
+            msg.clone(),
+        ))
     } else if config.channels.cli.enabled {
-        let repl = ReplChannel::new();
+        let repl = ReplChannel::with_user_id(config.owner_id.clone());
         repl.suppress_banner();
         Some(repl)
     } else {
@@ -311,12 +318,7 @@ async fn async_main() -> anyhow::Result<()> {
     webhook_routes.push(webhooks::routes(ToolWebhookState {
         tools: Arc::clone(&components.tools),
         routine_engine: Arc::clone(&shared_routine_engine_slot),
-        user_id: config
-            .channels
-            .gateway
-            .as_ref()
-            .map(|g| g.user_id.clone())
-            .unwrap_or_else(|| "default".to_string()),
+        user_id: config.owner_id.clone(),
         secrets_store: components.secrets_store.clone(),
     }));
 
@@ -618,7 +620,7 @@ async fn async_main() -> anyhow::Result<()> {
     // Register message tool for sending messages to connected channels
     components
         .tools
-        .register_message_tools(Arc::clone(&channels))
+        .register_message_tools(Arc::clone(&channels), components.extension_manager.clone())
         .await;
 
     // Wire up channel runtime for hot-activation of WASM channels.
@@ -703,6 +705,7 @@ async fn async_main() -> anyhow::Result<()> {
         .map(|db| Arc::clone(db) as Arc<dyn ironclaw::db::SettingsStore>);
 
     let deps = AgentDeps {
+        owner_id: config.owner_id.clone(),
         store: components.db,
         llm: components.llm,
         cheap_llm: components.cheap_llm,
@@ -775,6 +778,7 @@ async fn async_main() -> anyhow::Result<()> {
         let sighup_webhook_server = webhook_server.clone();
         let sighup_settings_store_clone = sighup_settings_store.clone();
         let sighup_secrets_store = components.secrets_store.clone();
+        let sighup_owner_id = config.owner_id.clone();
         let mut shutdown_rx = shutdown_tx.subscribe();
 
         tokio::spawn(async move {
@@ -805,7 +809,7 @@ async fn async_main() -> anyhow::Result<()> {
                 if let Some(ref secrets_store) = sighup_secrets_store {
                     // Inject HTTP webhook secret from encrypted store
                     if let Ok(webhook_secret) = secrets_store
-                        .get_decrypted("default", "http_webhook_secret")
+                        .get_decrypted(&sighup_owner_id, "http_webhook_secret")
                         .await
                     {
                         // Thread-safe: Uses INJECTED_VARS mutex instead of unsafe std::env::set_var
@@ -821,7 +825,7 @@ async fn async_main() -> anyhow::Result<()> {
                 // Reload config (now with secrets injected into environment)
                 let new_config = match &sighup_settings_store_clone {
                     Some(store) => {
-                        ironclaw::config::Config::from_db(store.as_ref(), "default").await
+                        ironclaw::config::Config::from_db(store.as_ref(), &sighup_owner_id).await
                     }
                     None => ironclaw::config::Config::from_env().await,
                 };

src/orchestrator/mod.rs

@@ -51,6 +51,15 @@ use crate::db::Database;
 use crate::llm::LlmProvider;
 use crate::secrets::SecretsStore;
 
+/// Resolve the orchestrator port from the `ORCHESTRATOR_PORT` environment
+/// variable, falling back to 50051.
+fn resolve_orchestrator_port() -> u16 {
+    std::env::var("ORCHESTRATOR_PORT")
+        .ok()
+        .and_then(|v| v.parse().ok())
+        .unwrap_or(50051)
+}
+
 /// Result of orchestrator setup, containing all handles needed by the agent.
 pub struct OrchestratorSetup {
     pub container_job_manager: Option<Arc<ContainerJobManager>>,
@@ -101,11 +110,12 @@ pub async fn setup_orchestrator(
         let job_event_tx = Some(tx);
 
         let token_store = TokenStore::new();
+        let orchestrator_port = resolve_orchestrator_port();
         let job_config = ContainerJobConfig {
             image: config.sandbox.image.clone(),
             memory_limit_mb: config.sandbox.memory_limit_mb,
             cpu_shares: config.sandbox.cpu_shares,
-            orchestrator_port: 50051,
+            orchestrator_port,
             claude_code_api_key: std::env::var("ANTHROPIC_API_KEY").ok(),
             claude_code_oauth_token: crate::config::ClaudeCodeConfig::extract_oauth_token(),
             claude_code_model: config.claude_code.model.clone(),
@@ -127,7 +137,7 @@ pub async fn setup_orchestrator(
         };
 
         tokio::spawn(async move {
-            if let Err(e) = OrchestratorApi::start(orchestrator_state, 50051).await {
+            if let Err(e) = OrchestratorApi::start(orchestrator_state, orchestrator_port).await {
                 tracing::error!("Orchestrator API failed: {}", e);
             }
         });
@@ -151,3 +161,40 @@ pub async fn setup_orchestrator(
         docker_status,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Mutex;
+
+    use super::*;
+
+    /// Serialize access to `ORCHESTRATOR_PORT` env var across test threads.
+    static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+    #[test]
+    fn resolve_orchestrator_port_from_env() {
+        let _guard = ENV_LOCK.lock().unwrap();
+
+        // Safety: env-var mutation requires unsafe in edition 2024;
+        // ENV_LOCK serializes concurrent access from other test threads.
+
+        // Absent env var → default 50051
+        unsafe { std::env::remove_var("ORCHESTRATOR_PORT") };
+        assert_eq!(resolve_orchestrator_port(), 50051);
+
+        // Valid custom port
+        unsafe { std::env::set_var("ORCHESTRATOR_PORT", "50052") };
+        assert_eq!(resolve_orchestrator_port(), 50052);
+
+        // Non-numeric value → fallback to default
+        unsafe { std::env::set_var("ORCHESTRATOR_PORT", "not_a_port") };
+        assert_eq!(resolve_orchestrator_port(), 50051);
+
+        // Out of u16 range → fallback to default
+        unsafe { std::env::set_var("ORCHESTRATOR_PORT", "99999") };
+        assert_eq!(resolve_orchestrator_port(), 50051);
+
+        // Cleanup
+        unsafe { std::env::remove_var("ORCHESTRATOR_PORT") };
+    }
+}

src/settings.rs

@@ -16,6 +16,14 @@ pub struct Settings {
     #[serde(default, alias = "setup_completed")]
     pub onboard_completed: bool,
 
+    /// Stable owner scope for this IronClaw instance.
+    ///
+    /// This is bootstrap configuration loaded from env / disk / TOML. We do
+    /// not persist it in the per-user DB settings table because the DB lookup
+    /// itself already requires the owner scope to be known.
+    #[serde(default)]
+    pub owner_id: Option<String>,
+
     // === Step 1: Database ===
     /// Database backend: "postgres" or "libsql".
     #[serde(default)]
@@ -733,6 +741,10 @@ impl Settings {
         let mut settings = Self::default();
 
         for (key, value) in map {
+            if key == "owner_id" {
+                continue;
+            }
+
             // Convert the JSONB value to a string for the existing set() method
             let value_str = match value {
                 serde_json::Value::String(s) => s.clone(),
@@ -772,6 +784,7 @@ impl Settings {
 
         let mut map = std::collections::HashMap::new();
         collect_settings_json(&json, String::new(), &mut map);
+        map.remove("owner_id");
         map
     }
 

src/testing/mod.rs

@@ -439,6 +439,7 @@ impl TestHarnessBuilder {
         };
 
         let deps = AgentDeps {
+            owner_id: "default".to_string(),
             store: Some(Arc::clone(&db)),
             llm,
             cheap_llm: None,
@@ -1077,7 +1078,7 @@ mod tests {
             },
             notify: NotifyConfig {
                 channel: None,
-                user: "user1".to_string(),
+                user: Some("user1".to_string()),
                 on_attention: true,
                 on_failure: true,
                 on_success: false,
@@ -1210,7 +1211,7 @@ mod tests {
             },
             notify: NotifyConfig {
                 channel: None,
-                user: "user1".to_string(),
+                user: Some("user1".to_string()),
                 on_attention: false,
                 on_failure: false,
                 on_success: false,

src/tools/builtin/message.rs

@@ -10,6 +10,7 @@ use async_trait::async_trait;
 use crate::bootstrap::ironclaw_base_dir;
 use crate::channels::{ChannelManager, OutgoingResponse};
 use crate::context::JobContext;
+use crate::extensions::ExtensionManager;
 use crate::tools::tool::{
     ApprovalRequirement, Tool, ToolError, ToolOutput, ToolRateLimitConfig, require_str,
 };
@@ -17,6 +18,7 @@ use crate::tools::tool::{
 /// Tool for sending messages to channels.
 pub struct MessageTool {
     channel_manager: Arc<ChannelManager>,
+    extension_manager: Option<Arc<ExtensionManager>>,
     /// Default channel for current conversation (set per-turn).
     /// Uses std::sync::RwLock because requires_approval() is sync and called from async context.
     default_channel: Arc<RwLock<Option<String>>>,
@@ -32,12 +34,18 @@ impl MessageTool {
 
         Self {
             channel_manager,
+            extension_manager: None,
             default_channel: Arc::new(RwLock::new(None)),
             default_target: Arc::new(RwLock::new(None)),
             base_dir,
         }
     }
 
+    pub fn with_extension_manager(mut self, extension_manager: Arc<ExtensionManager>) -> Self {
+        self.extension_manager = Some(extension_manager);
+        self
+    }
+
     /// Set the base directory for attachment validation.
     /// This is primarily used for testing or future configuration.
     pub fn with_base_dir(mut self, dir: PathBuf) -> Self {
@@ -111,39 +119,76 @@ impl Tool for MessageTool {
 
         let content = require_str(&params, "content")?;
 
+        let explicit_channel = params
+            .get("channel")
+            .and_then(|v| v.as_str())
+            .map(|value| value.to_string());
+        let default_channel = self
+            .default_channel
+            .read()
+            .unwrap_or_else(|e| e.into_inner())
+            .clone();
+        let metadata_channel = ctx
+            .metadata
+            .get("notify_channel")
+            .and_then(|v| v.as_str())
+            .map(|value| value.to_string());
+
         // Get channel: use param → conversation default → job metadata → None (broadcast all)
-        let channel: Option<String> =
-            if let Some(c) = params.get("channel").and_then(|v| v.as_str()) {
-                Some(c.to_string())
-            } else if let Some(c) = self
-                .default_channel
+        let channel: Option<String> = explicit_channel
+            .clone()
+            .or_else(|| default_channel.clone())
+            .or_else(|| metadata_channel.clone());
+
+        let can_use_default_target = match (explicit_channel.as_deref(), default_channel.as_deref())
+        {
+            (None, _) => true,
+            (Some(explicit), Some(current)) if explicit == current => true,
+            _ => false,
+        };
+        let can_use_metadata_target = match (channel.as_deref(), metadata_channel.as_deref()) {
+            (None, _) => true,
+            (Some(resolved), Some(current)) if resolved == current => true,
+            _ => false,
+        };
+
+        // Get target: use param → conversation default → job metadata → owner scope
+        // fallback when a specific channel is known.
+        let target = if let Some(t) = params.get("target").and_then(|v| v.as_str()) {
+            Some(t.to_string())
+        } else if can_use_default_target
+            && let Some(t) = self
+                .default_target
                 .read()
                 .unwrap_or_else(|e| e.into_inner())
                 .clone()
-            {
-                Some(c)
-            } else {
-                ctx.metadata
-                    .get("notify_channel")
-                    .and_then(|v| v.as_str())
-                    .map(|c| c.to_string())
-            };
-
-        // Get target: use param → conversation default → job metadata
-        let target = if let Some(t) = params.get("target").and_then(|v| v.as_str()) {
-            t.to_string()
-        } else if let Some(t) = self
-            .default_target
-            .read()
-            .unwrap_or_else(|e| e.into_inner())
-            .clone()
         {
-            t
-        } else if let Some(t) = ctx.metadata.get("notify_user").and_then(|v| v.as_str()) {
-            t.to_string()
+            Some(t)
+        } else if can_use_metadata_target
+            && let Some(t) = ctx.metadata.get("notify_user").and_then(|v| v.as_str())
+        {
+            Some(t.to_string())
+        } else if channel.is_some() {
+            if let Some(channel_name) = channel.as_deref() {
+                if let Some(extension_manager) = self.extension_manager.as_ref()
+                    && let Some(target) = extension_manager
+                        .notification_target_for_channel(channel_name)
+                        .await
+                {
+                    Some(target)
+                } else {
+                    Some(ctx.user_id.clone())
+                }
+            } else {
+                Some(ctx.user_id.clone())
+            }
         } else {
+            None
+        };
+
+        let Some(target) = target else {
             return Err(ToolError::ExecutionFailed(
-                "No target specified and no active conversation. Provide target parameter."
+                "No target specified and no channel-scoped routing target could be resolved. Provide target parameter."
                     .to_string(),
             ));
         };
@@ -659,6 +704,31 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn message_tool_falls_back_to_ctx_user_when_channel_known() {
+        // Regression for owner-scoped notifications: a channel can be known
+        // even when the concrete delivery target is omitted, so the message
+        // tool should pass ctx.user_id through to the channel layer.
+        let tool = MessageTool::new(Arc::new(ChannelManager::new()));
+
+        let mut ctx =
+            crate::context::JobContext::with_user("owner-scope", "routine-job", "price alert");
+        ctx.metadata = serde_json::json!({
+            "notify_channel": "telegram",
+        });
+
+        let result = tool
+            .execute(serde_json::json!({"content": "NEAR price is $5"}), &ctx)
+            .await;
+
+        assert!(result.is_err()); // safety: test-only assertion
+        let err = result.unwrap_err().to_string();
+        let mentions_missing_target = err.contains("No target specified");
+        assert!(!mentions_missing_target); // safety: test-only assertion
+        let mentions_missing_channel = err.contains("No channel specified");
+        assert!(!mentions_missing_channel); // safety: test-only assertion
+    }
+
     #[tokio::test]
     async fn message_tool_no_metadata_still_errors() {
         // When neither conversation context nor metadata is set, should still
@@ -710,4 +780,33 @@ mod tests {
             err
         );
     }
+
+    #[tokio::test]
+    async fn message_tool_does_not_apply_metadata_target_to_different_default_channel() {
+        let tool = MessageTool::new(Arc::new(ChannelManager::new()));
+        tool.set_context(Some("telegram".to_string()), None).await;
+
+        let mut ctx = crate::context::JobContext::with_user("owner-scope", "test", "test");
+        ctx.metadata = serde_json::json!({
+            "notify_channel": "signal",
+            "notify_user": "metadata-user",
+        });
+
+        let result = tool
+            .execute(serde_json::json!({"content": "hello"}), &ctx)
+            .await;
+
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(
+            !err.contains("metadata-user"),
+            "metadata target should not be applied to a different default channel: {}",
+            err
+        );
+        assert!(
+            err.contains("owner-scope"),
+            "expected owner-scope fallback target when metadata channel differs: {}",
+            err
+        );
+    }
 }

src/tools/builtin/routine.rs

@@ -106,7 +106,7 @@ pub(crate) fn routine_create_parameters_schema() -> serde_json::Value {
             },
             "notify_user": {
                 "type": "string",
-                "description": "User or destination to notify, for example a username or chat ID."
+                "description": "Optional explicit user or destination to notify, for example a username or chat ID. Omit it to use the configured owner's last-seen target for that channel."
             },
             "timezone": {
                 "type": "string",
@@ -387,8 +387,7 @@ impl Tool for RoutineCreateTool {
                 user: params
                     .get("notify_user")
                     .and_then(|v| v.as_str())
-                    .unwrap_or("default")
-                    .to_string(),
+                    .map(String::from),
                 ..NotifyConfig::default()
             },
             last_run_at: None,

src/tools/registry.rs

@@ -501,9 +501,14 @@ impl ToolRegistry {
     pub async fn register_message_tools(
         &self,
         channel_manager: Arc<crate::channels::ChannelManager>,
+        extension_manager: Option<Arc<crate::extensions::ExtensionManager>>,
     ) {
         use crate::tools::builtin::MessageTool;
-        let tool = Arc::new(MessageTool::new(channel_manager));
+        let mut tool = MessageTool::new(channel_manager);
+        if let Some(extension_manager) = extension_manager {
+            tool = tool.with_extension_manager(extension_manager);
+        }
+        let tool = Arc::new(tool);
         *self.message_tool.write().await = Some(Arc::clone(&tool));
         self.tools
             .write()

src/tools/wasm/wrapper.rs

@@ -841,13 +841,7 @@ impl Tool for WasmToolWrapper {
         // Pre-resolve host credentials from secrets store (async, before blocking task).
         // This decrypts the secrets once so the sync http_request() host function
         // can inject them without needing async access.
-        //
-        // BUG FIX: ExtensionManager stores OAuth tokens under user_id "default"
-        // (hardcoded at construction in app.rs), but this was previously looking
-        // them up under ctx.user_id — which could be a Telegram user ID, web
-        // gateway user, etc. — causing credential resolution to silently fail.
-        // Must match the storage key until per-user credential isolation is added.
-        let credential_user_id = "default";
+        let credential_user_id = &ctx.user_id;
         let host_credentials = resolve_host_credentials(
             &self.capabilities,
             self.secrets_store.as_deref(),
@@ -1165,6 +1159,13 @@ async fn resolve_host_credentials(
         let secret = match store.get_decrypted(user_id, &mapping.secret_name).await {
             Ok(s) => Some(s),
             Err(e) => {
+                tracing::trace!(
+                    user_id = %user_id,
+                    secret_name = %mapping.secret_name,
+                    error = %e,
+                    "No matching host credential resolved for WASM tool in the requested scope"
+                );
+
                 // If lookup fails and we're not already looking up "default", try "default" as fallback
                 if user_id != "default" {
                     tracing::debug!(
@@ -1385,7 +1386,16 @@ fn build_tool_usage_hint(tool_name: &str, schema: &serde_json::Value) -> String
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
+    use std::sync::{Arc, Mutex};
+
+    use async_trait::async_trait;
+    use uuid::Uuid;
+
+    use crate::context::JobContext;
+    use crate::secrets::{
+        CreateSecretParams, DecryptedSecret, InMemorySecretsStore, Secret, SecretError, SecretRef,
+        SecretsStore,
+    };
 
     use crate::testing::credentials::{
         TEST_BEARER_TOKEN_123, TEST_GOOGLE_OAUTH_FRESH, TEST_GOOGLE_OAUTH_LEGACY,
@@ -1396,6 +1406,78 @@ mod tests {
     use crate::tools::wasm::capabilities::Capabilities;
     use crate::tools::wasm::runtime::{WasmRuntimeConfig, WasmToolRuntime};
 
+    struct RecordingSecretsStore {
+        inner: InMemorySecretsStore,
+        get_decrypted_lookups: Mutex<Vec<(String, String)>>,
+    }
+
+    impl RecordingSecretsStore {
+        fn new() -> Self {
+            Self {
+                inner: test_secrets_store(),
+                get_decrypted_lookups: Mutex::new(Vec::new()),
+            }
+        }
+
+        fn decrypted_lookups(&self) -> Vec<(String, String)> {
+            self.get_decrypted_lookups.lock().unwrap().clone()
+        }
+    }
+
+    #[async_trait]
+    impl SecretsStore for RecordingSecretsStore {
+        async fn create(
+            &self,
+            user_id: &str,
+            params: CreateSecretParams,
+        ) -> Result<Secret, SecretError> {
+            self.inner.create(user_id, params).await
+        }
+
+        async fn get(&self, user_id: &str, name: &str) -> Result<Secret, SecretError> {
+            self.inner.get(user_id, name).await
+        }
+
+        async fn get_decrypted(
+            &self,
+            user_id: &str,
+            name: &str,
+        ) -> Result<DecryptedSecret, SecretError> {
+            self.get_decrypted_lookups
+                .lock()
+                .unwrap()
+                .push((user_id.to_string(), name.to_string()));
+            self.inner.get_decrypted(user_id, name).await
+        }
+
+        async fn exists(&self, user_id: &str, name: &str) -> Result<bool, SecretError> {
+            self.inner.exists(user_id, name).await
+        }
+
+        async fn list(&self, user_id: &str) -> Result<Vec<SecretRef>, SecretError> {
+            self.inner.list(user_id).await
+        }
+
+        async fn delete(&self, user_id: &str, name: &str) -> Result<bool, SecretError> {
+            self.inner.delete(user_id, name).await
+        }
+
+        async fn record_usage(&self, secret_id: Uuid) -> Result<(), SecretError> {
+            self.inner.record_usage(secret_id).await
+        }
+
+        async fn is_accessible(
+            &self,
+            user_id: &str,
+            secret_name: &str,
+            allowed_secrets: &[String],
+        ) -> Result<bool, SecretError> {
+            self.inner
+                .is_accessible(user_id, secret_name, allowed_secrets)
+                .await
+        }
+    }
+
     #[test]
     fn test_wrapper_creation() {
         // This test verifies the runtime can be created
@@ -1691,6 +1773,104 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn test_resolve_host_credentials_owner_scope_bearer() {
+        use std::collections::HashMap;
+
+        use crate::secrets::{
+            CreateSecretParams, CredentialLocation, CredentialMapping, SecretsStore,
+        };
+        use crate::tools::wasm::capabilities::HttpCapability;
+        use crate::tools::wasm::wrapper::resolve_host_credentials;
+
+        let store = test_secrets_store();
+        let ctx = JobContext::with_user("owner-scope", "owner-scope test", "owner-scope test");
+
+        store
+            .create(
+                &ctx.user_id,
+                CreateSecretParams::new("google_oauth_token", TEST_GOOGLE_OAUTH_TOKEN),
+            )
+            .await
+            .unwrap();
+
+        let mut credentials = HashMap::new();
+        credentials.insert(
+            "google_oauth_token".to_string(),
+            CredentialMapping {
+                secret_name: "google_oauth_token".to_string(),
+                location: CredentialLocation::AuthorizationBearer,
+                host_patterns: vec!["www.googleapis.com".to_string()],
+            },
+        );
+
+        let caps = Capabilities {
+            http: Some(HttpCapability {
+                credentials,
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+
+        let result = resolve_host_credentials(&caps, Some(&store), &ctx.user_id, None).await;
+        assert_eq!(result.len(), 1);
+        assert_eq!(
+            result[0].headers.get("Authorization"),
+            Some(&format!("Bearer {TEST_GOOGLE_OAUTH_TOKEN}"))
+        );
+    }
+
+    #[tokio::test]
+    async fn test_execute_resolves_host_credentials_from_owner_scope_context() {
+        use std::collections::HashMap;
+
+        use crate::secrets::{CredentialLocation, CredentialMapping};
+        use crate::tools::wasm::capabilities::HttpCapability;
+
+        let runtime = Arc::new(WasmToolRuntime::new(WasmRuntimeConfig::for_testing()).unwrap());
+        let prepared = runtime
+            .prepare("search", b"\0asm\x0d\0\x01\0", None)
+            .await
+            .unwrap();
+        let store = Arc::new(RecordingSecretsStore::new());
+        let ctx = JobContext::with_user("owner-scope", "owner-scope test", "owner-scope test");
+
+        store
+            .create(
+                &ctx.user_id,
+                CreateSecretParams::new("google_oauth_token", TEST_GOOGLE_OAUTH_TOKEN),
+            )
+            .await
+            .unwrap();
+
+        let mut credentials = HashMap::new();
+        credentials.insert(
+            "google_oauth_token".to_string(),
+            CredentialMapping {
+                secret_name: "google_oauth_token".to_string(),
+                location: CredentialLocation::AuthorizationBearer,
+                host_patterns: vec!["www.googleapis.com".to_string()],
+            },
+        );
+
+        let caps = Capabilities {
+            http: Some(HttpCapability {
+                credentials,
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+
+        let wrapper = super::WasmToolWrapper::new(Arc::clone(&runtime), prepared, caps)
+            .with_secrets_store(store.clone());
+        let result = wrapper.execute(serde_json::json!({}), &ctx).await;
+        assert!(result.is_err());
+
+        let lookups = store.decrypted_lookups();
+        assert!(lookups.contains(&("owner-scope".to_string(), "google_oauth_token".to_string())));
+        assert!(!lookups.contains(&("default".to_string(), "google_oauth_token".to_string())));
+    }
+
     #[tokio::test]
     async fn test_resolve_host_credentials_missing_secret() {
         use std::collections::HashMap;

src/transcription/chat_completions.rs

@@ -0,0 +1,179 @@
+//! Chat Completions-based transcription provider.
+//!
+//! Uses the `/v1/chat/completions` endpoint with `input_audio` content type
+//! to transcribe audio. Compatible with OpenRouter, OpenAI GPT-4o-audio, and
+//! any provider that supports audio input via the Chat Completions API.
+
+use async_trait::async_trait;
+use base64::Engine;
+use secrecy::{ExposeSecret, SecretString};
+
+use super::{AudioFormat, TranscriptionError, TranscriptionProvider};
+
+/// Transcription provider that sends audio via the Chat Completions API.
+///
+/// Unlike the Whisper provider (which uses `/v1/audio/transcriptions` with
+/// multipart upload), this provider sends base64-encoded audio as an
+/// `input_audio` content part in a chat message, enabling use with
+/// OpenRouter and other providers that only expose audio through the
+/// Chat Completions API.
+pub struct ChatCompletionsTranscriptionProvider {
+    client: reqwest::Client,
+    api_key: SecretString,
+    model: String,
+    base_url: String,
+}
+
+impl ChatCompletionsTranscriptionProvider {
+    /// Create a new provider with the given API key.
+    pub fn new(api_key: SecretString) -> Self {
+        Self {
+            client: match reqwest::Client::builder()
+                .timeout(std::time::Duration::from_secs(120))
+                .build()
+            {
+                Ok(c) => c,
+                Err(e) => {
+                    tracing::error!(
+                        "Failed to build HTTP client with timeout, falling back to default: {e}"
+                    );
+                    reqwest::Client::default()
+                }
+            },
+            api_key,
+            model: "google/gemini-2.0-flash-001".to_string(),
+            base_url: "https://openrouter.ai/api".to_string(),
+        }
+    }
+
+    /// Override the base URL.
+    pub fn with_base_url(mut self, base_url: impl Into<String>) -> Self {
+        self.base_url = base_url.into().trim_end_matches('/').to_string();
+        self
+    }
+
+    /// Override the model name.
+    pub fn with_model(mut self, model: impl Into<String>) -> Self {
+        self.model = model.into();
+        self
+    }
+}
+
+/// Map [`AudioFormat`] to the format string expected by the Chat Completions API.
+fn audio_format_str(format: AudioFormat) -> &'static str {
+    match format {
+        AudioFormat::Ogg => "ogg",
+        AudioFormat::Mp3 => "mp3",
+        AudioFormat::Mp4 => "mp4",
+        AudioFormat::Wav => "wav",
+        AudioFormat::Webm => "webm",
+        AudioFormat::Flac => "flac",
+        AudioFormat::M4a => "m4a",
+    }
+}
+
+#[async_trait]
+impl TranscriptionProvider for ChatCompletionsTranscriptionProvider {
+    async fn transcribe(
+        &self,
+        audio_data: &[u8],
+        format: AudioFormat,
+    ) -> Result<String, TranscriptionError> {
+        if audio_data.is_empty() {
+            return Err(TranscriptionError::EmptyAudio);
+        }
+
+        let b64 = base64::engine::general_purpose::STANDARD.encode(audio_data);
+
+        let body = serde_json::json!({
+            "model": self.model,
+            "messages": [{
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": "Transcribe this audio. Return only the transcript text, nothing else."
+                    },
+                    {
+                        "type": "input_audio",
+                        "input_audio": {
+                            "data": b64,
+                            "format": audio_format_str(format)
+                        }
+                    }
+                ]
+            }]
+        });
+
+        let url = format!("{}/v1/chat/completions", self.base_url);
+
+        let response = self
+            .client
+            .post(&url)
+            .header(
+                "Authorization",
+                format!("Bearer {}", self.api_key.expose_secret()),
+            )
+            .json(&body)
+            .send()
+            .await
+            .map_err(|e| TranscriptionError::RequestFailed(e.to_string()))?;
+
+        let status = response.status();
+        if !status.is_success() {
+            let body = response
+                .text()
+                .await
+                .unwrap_or_else(|_| "unknown error".to_string());
+            return Err(TranscriptionError::RequestFailed(format!(
+                "HTTP {}: {}",
+                status, body
+            )));
+        }
+
+        let json: serde_json::Value = response
+            .json()
+            .await
+            .map_err(|e| TranscriptionError::RequestFailed(e.to_string()))?;
+
+        // Extract text from the standard Chat Completions response format:
+        // { "choices": [{ "message": { "content": "..." } }] }
+        let text = json
+            .get("choices")
+            .and_then(|c| c.get(0))
+            .and_then(|c| c.get("message"))
+            .and_then(|m| m.get("content"))
+            .and_then(|c| c.as_str())
+            .ok_or_else(|| {
+                TranscriptionError::RequestFailed(
+                    "unexpected response format: missing choices[0].message.content".to_string(),
+                )
+            })?;
+
+        Ok(text.trim().to_string())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn audio_format_str_maps_all_variants() {
+        assert_eq!(audio_format_str(AudioFormat::Ogg), "ogg");
+        assert_eq!(audio_format_str(AudioFormat::Mp3), "mp3");
+        assert_eq!(audio_format_str(AudioFormat::Mp4), "mp4");
+        assert_eq!(audio_format_str(AudioFormat::Wav), "wav");
+        assert_eq!(audio_format_str(AudioFormat::Webm), "webm");
+        assert_eq!(audio_format_str(AudioFormat::Flac), "flac");
+        assert_eq!(audio_format_str(AudioFormat::M4a), "m4a");
+    }
+
+    #[tokio::test]
+    async fn rejects_empty_audio() {
+        let provider =
+            ChatCompletionsTranscriptionProvider::new(SecretString::from("test-key".to_string()));
+        let result = provider.transcribe(&[], AudioFormat::Ogg).await;
+        assert!(matches!(result, Err(TranscriptionError::EmptyAudio)));
+    }
+}

src/transcription/mod.rs

@@ -4,8 +4,10 @@
 //! backends and a [`TranscriptionMiddleware`] that detects audio attachments
 //! on incoming messages and replaces them with transcribed text.
 
+mod chat_completions;
 mod openai;
 
+pub use self::chat_completions::ChatCompletionsTranscriptionProvider;
 pub use self::openai::OpenAiWhisperProvider;
 
 use async_trait::async_trait;

src/workspace/embeddings.rs

@@ -231,7 +231,8 @@ impl EmbeddingProvider for OpenAiEmbeddings {
                 .get("retry-after")
                 .and_then(|v| v.to_str().ok())
                 .and_then(|s| s.parse::<u64>().ok())
-                .map(std::time::Duration::from_secs);
+                .map(std::time::Duration::from_secs)
+                .or(Some(std::time::Duration::from_secs(60)));
             return Err(EmbeddingError::RateLimited { retry_after });
         }
 
@@ -372,7 +373,8 @@ impl EmbeddingProvider for NearAiEmbeddings {
                 .get("retry-after")
                 .and_then(|v| v.to_str().ok())
                 .and_then(|s| s.parse::<u64>().ok())
-                .map(std::time::Duration::from_secs);
+                .map(std::time::Duration::from_secs)
+                .or(Some(std::time::Duration::from_secs(60)));
             return Err(EmbeddingError::RateLimited { retry_after });
         }
 
@@ -646,4 +648,48 @@ mod tests {
         let provider = OpenAiEmbeddings::new("test-key").with_base_url("custom.example.com/v1");
         assert_eq!(provider.base_url, "https://custom.example.com/v1");
     }
+
+    // -- Retry-After header parsing tests (regression for rate limit "None" bug) --
+
+    #[test]
+    fn test_retry_after_parsing_delay_seconds() {
+        // Verify delay-seconds format is parsed correctly
+        let header_value = "120";
+        let duration = parse_retry_after_embeddings_for_test(header_value);
+        assert_eq!(
+            duration,
+            Some(std::time::Duration::from_secs(120)),
+            "Should parse delay-seconds format"
+        );
+    }
+
+    #[test]
+    fn test_retry_after_fallback_missing_header() {
+        // Regression test: When Retry-After header is missing,
+        // should fall back to 60s instead of None
+        let duration = parse_retry_after_embeddings_for_test("");
+        assert_eq!(
+            duration,
+            Some(std::time::Duration::from_secs(60)),
+            "Missing header should fallback to 60s"
+        );
+    }
+
+    #[test]
+    fn test_retry_after_zero_seconds_accepted() {
+        // Verify zero seconds is a valid retry delay
+        let duration = parse_retry_after_embeddings_for_test("0");
+        assert_eq!(duration, Some(std::time::Duration::ZERO));
+    }
+
+    /// Helper function to test Retry-After header parsing logic for embeddings
+    /// (simulates the parsing done in embed without actual HTTP, including fallback)
+    fn parse_retry_after_embeddings_for_test(header_value: &str) -> Option<std::time::Duration> {
+        header_value
+            .trim()
+            .parse::<u64>()
+            .ok()
+            .map(std::time::Duration::from_secs)
+            .or(Some(std::time::Duration::from_secs(60)))
+    }
 }