rename Quiet to Observe, remove Listen Only toggle

Quiet mode is renamed to Observe with new semantics: the agent learns
from the conversation (context + memory) but never responds, even when
mentioned or replied to. This creates three clearly distinct modes:

- Active: responds to everything
- Mention Only: sees everything, responds only to mentions/replies/commands
- Observe: sees and learns from everything, never responds

Also removes the legacy Listen Only toggle from the Channel Behaviour
config UI — response modes in channel settings fully replace it.

Backwards compat: "quiet" is accepted as a serde alias and in config
parsing, so existing channel_settings rows and TOML configs continue
to work.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jamiepine

docs/content/docs/(getting-started)/configuring-channels.mdx

@@ -22,7 +22,7 @@ Controls when the agent responds to messages.
 | Mode | Behavior |
 |------|----------|
 | **Active** (default) | Responds to all messages normally. |
-| **Quiet** | Observes and learns from the conversation (history + memory persistence), but only responds when @mentioned, replied to, or given a command. |
+| **Observe** | Learns from the conversation passively — never responds, even when mentioned. All messages are ingested into context and memory. Use this for channels the agent should monitor without participating. |
 | **Mention Only** | Messages are still visible to the agent for context, but it only responds when @mentioned, replied to, or given a command. Memory capture continues passively. |
 
 #### Mention Only vs. Binding-Level Require Mention
@@ -116,7 +116,7 @@ Some settings can be toggled at runtime via slash commands in chat:
 | Command | Effect |
 |---------|--------|
 | `/active` | Switch to Active response mode |
-| `/quiet` | Switch to Quiet response mode |
+| `/observe` | Switch to Observe response mode |
 | `/mention-only` | Switch to Mention Only response mode |
 
 These persist to the channel's settings and survive restarts.

interface/src/api/types.ts

@@ -134,7 +134,7 @@ export type ConversationSettings = {
 	model_overrides?: ModelOverrides;
 	memory?: "full" | "ambient" | "off";
 	delegation?: "standard" | "direct";
-	response_mode?: "active" | "quiet" | "mention_only";
+	response_mode?: "active" | "observe" | "mention_only";
 	save_attachments?: boolean;
 	worker_context?: {
 		history?: "none" | "summary" | "recent" | "full";

interface/src/components/ChannelCard.tsx

@@ -160,9 +160,9 @@ export function ChannelCard({
 						<span className="text-tiny text-ink-faint">
 							{formatTimeAgo(channel.last_activity_at)}
 						</span>
-						{channel.response_mode === "quiet" && (
+						{channel.response_mode === "observe" && (
 							<span className="inline-flex items-center rounded-md bg-amber-500/10 px-1.5 py-0.5 text-tiny font-medium text-amber-400">
-								Quiet
+								Observe
 							</span>
 						)}
 						{channel.response_mode === "mention_only" && (

interface/src/components/ConversationSettingsPanel.tsx

@@ -95,14 +95,14 @@ const DELEGATION_DESCRIPTIONS: Record<string, string> = {
 
 const RESPONSE_MODE_OPTIONS = [
 	{ value: "active", label: "Active" },
-	{ value: "quiet", label: "Quiet" },
+	{ value: "observe", label: "Observe" },
 	{ value: "mention_only", label: "Mention Only" },
 ] as const;
 
 const RESPONSE_MODE_DESCRIPTIONS: Record<string, string> = {
 	active: "Responds to all messages normally.",
-	quiet:
-		"Observes and learns from the conversation, but only responds when @mentioned, replied to, or given a command.",
+	observe:
+		"Learns from the conversation passively — never responds, even when mentioned. Use this for channels the agent should monitor without participating.",
 	mention_only:
 		"Messages are still visible to the agent for context, but it only responds when explicitly @mentioned, replied to, or given a command. To block messages entirely, use the binding-level require mention setting instead.",
 };

interface/src/components/WebChatPanel.tsx

@@ -336,9 +336,9 @@ export function WebChatPanel({agentId}: WebChatPanelProps) {
 									?? settings.model ?? defaults.model}
 							</span>
 						)}
-						{settings.response_mode === "quiet" && (
+						{settings.response_mode === "observe" && (
 							<span className="rounded-md bg-amber-500/10 px-1.5 py-0.5 text-[10px] font-medium text-amber-400">
-								Quiet
+								Observe
 							</span>
 						)}
 						{settings.response_mode === "mention_only" && (

interface/src/routes/AgentConfig.tsx

@@ -1221,12 +1221,7 @@ function ConfigSectionEditor({ sectionId, label, description, detail, config, on
 			case "channel":
 				return (
 					<div className="grid gap-4">
-						<ConfigToggleField
-							label="Listen-Only Mode"
-							description="Only respond when explicitly invoked (slash command, @mention, or reply-to-bot)."
-							value={localValues.listen_only_mode as boolean}
-							onChange={(v) => handleChange("listen_only_mode", v)}
-						/>
+						<p className="text-sm text-ink-faint">Channel behavior is now configured per-channel via response modes in Channel Settings.</p>
 					</div>
 				);
 			case "projects":

src/agent/channel.rs

@@ -694,7 +694,7 @@ impl Channel {
         self.resolved_settings = resolved;
     }
 
-    /// Whether the channel is in a non-active response mode (Quiet or MentionOnly).
+    /// Whether the channel is in a non-active response mode (Observe or MentionOnly).
     fn is_suppressed(&self) -> bool {
         !matches!(self.resolved_settings.response_mode, ResponseMode::Active)
     }
@@ -917,7 +917,7 @@ impl Channel {
                     .unwrap_or_else(|| routing.resolve(ProcessType::Branch, None));
                 let mode = match self.resolved_settings.response_mode {
                     ResponseMode::Active => "active",
-                    ResponseMode::Quiet => "quiet (only command/@mention/reply)",
+                    ResponseMode::Observe => "observe (learning, never responds)",
                     ResponseMode::MentionOnly => "mention-only (@mention/reply only)",
                 };
                 let adapter = self.current_adapter().unwrap_or("unknown");
@@ -941,11 +941,11 @@ impl Channel {
                 self.send_builtin_text(body, "status").await;
                 return Ok(true);
             }
-            "/quiet" => {
-                self.set_response_mode(ResponseMode::Quiet).await;
+            "/quiet" | "/observe" => {
+                self.set_response_mode(ResponseMode::Observe).await;
                 self.send_builtin_text(
-                    "quiet mode enabled. i'll only reply to commands, @mentions, or replies to my message.".to_string(),
-                    "quiet",
+                    "observe mode enabled. i'll learn from this conversation but won't respond.".to_string(),
+                    "observe",
                 ).await;
                 return Ok(true);
             }
@@ -975,8 +975,8 @@ impl Channel {
                     "- /today: in-progress + ready task snapshot".to_string(),
                     "- /tasks: ready task list".to_string(),
                     "- /digest: one-shot day digest (00:00 -> now)".to_string(),
-                    "- /quiet: only reply to commands, @mentions, or replies".to_string(),
-                    "- /mention-only: only respond when @mentioned or replied to".to_string(),
+                    "- /observe: learn from conversation, never respond".to_string(),
+                    "- /mention-only: only respond when @mentioned, replied to, or given a command".to_string(),
                     "- /active: normal reply mode".to_string(),
                     "- /agent-id: runtime agent id".to_string(),
                 ];
@@ -1418,37 +1418,36 @@ impl Channel {
             }
         }
 
-        if !matches!(self.resolved_settings.response_mode, ResponseMode::Active)
-            && !batch_has_invoke
-            && !self.is_dm()
-        {
+        // Observe mode: always suppress (even with mentions in batch).
+        // MentionOnly mode: suppress only when no invocations in the batch.
+        let should_suppress_batch = !self.is_dm()
+            && match self.resolved_settings.response_mode {
+                ResponseMode::Active => false,
+                ResponseMode::Observe => true,
+                ResponseMode::MentionOnly => !batch_has_invoke,
+            };
+
+        if should_suppress_batch {
             tracing::debug!(
                 channel_id = %self.id,
                 message_count,
                 response_mode = ?self.resolved_settings.response_mode,
                 "suppressing unsolicited coalesced batch"
             );
-            // In MentionOnly mode, inject batch messages into in-memory history
-            // so the LLM retains channel context when eventually triggered.
-            if matches!(
-                self.resolved_settings.response_mode,
-                ResponseMode::MentionOnly
-            ) {
-                {
-                    let mut history = self.state.history.write().await;
-                    for (formatted_text, _, _) in &pending_batch_entries {
-                        history.push(rig::message::Message::User {
-                            content: OneOrMany::one(UserContent::text(formatted_text)),
-                        });
-                    }
-                }
-                // Compaction guard: suppressed messages accumulate in history
-                // without agent turns, so check compaction to prevent unbounded growth.
-                if let Err(error) = self.compactor.check_and_compact().await {
-                    tracing::warn!(channel_id = %self.id, %error, "compaction check failed");
+            // Inject batch messages into in-memory history so the agent
+            // retains channel context.
+            {
+                let mut history = self.state.history.write().await;
+                for (formatted_text, _, _) in &pending_batch_entries {
+                    history.push(rig::message::Message::User {
+                        content: OneOrMany::one(UserContent::text(formatted_text)),
+                    });
                 }
             }
-            // Both Quiet and MentionOnly keep passive memory capture.
+            if let Err(error) = self.compactor.check_and_compact().await {
+                tracing::warn!(channel_id = %self.id, %error, "compaction check failed");
+            }
+            // Both Observe and MentionOnly keep passive memory capture.
             self.message_count += message_count;
             self.check_memory_persistence().await;
             return Ok(());
@@ -1798,9 +1797,12 @@ impl Channel {
             }
         }
 
-        // Deterministic ping ack for Discord quiet-mode mentions/replies to avoid
+        // Deterministic ping ack for Discord mention-only mentions/replies to avoid
         // flaky model behavior (e.g. skipping or over-formatting simple liveness checks).
-        if should_send_discord_quiet_mode_ping_ack(&message, &raw_text, self.is_suppressed()) {
+        // Skipped in Observe mode — the agent never responds in Observe.
+        if !matches!(self.resolved_settings.response_mode, ResponseMode::Observe)
+            && should_send_discord_quiet_mode_ping_ack(&message, &raw_text, self.is_suppressed())
+        {
             self.send_builtin_text("yeah i'm here".to_string(), "discord-ping")
                 .await;
             return Ok(());
@@ -1848,40 +1850,41 @@ impl Channel {
         let mut invoked_by_reply = false;
 
         // Response mode guardrail:
-        // In Quiet/MentionOnly modes, ingest messages but only reply when explicitly invoked.
+        // Observe mode: always suppress — agent learns but never responds.
+        // MentionOnly mode: suppress unless explicitly invoked.
         if !matches!(self.resolved_settings.response_mode, ResponseMode::Active)
             && message.source != "system"
             && !self.is_dm()
         {
-            (invoked_by_command, invoked_by_mention, invoked_by_reply) =
-                self.compute_listen_mode_invocation(&message, &raw_text);
+            // Observe mode always suppresses; MentionOnly checks for invocation.
+            let should_suppress =
+                if matches!(self.resolved_settings.response_mode, ResponseMode::Observe) {
+                    true
+                } else {
+                    (invoked_by_command, invoked_by_mention, invoked_by_reply) =
+                        self.compute_listen_mode_invocation(&message, &raw_text);
+                    !invoked_by_command && !invoked_by_mention && !invoked_by_reply
+                };
 
-            if !invoked_by_command && !invoked_by_mention && !invoked_by_reply {
+            if should_suppress {
                 tracing::debug!(
                     channel_id = %self.id,
                     source = %message.source,
                     response_mode = ?self.resolved_settings.response_mode,
                     "suppressing unsolicited reply"
                 );
-                // In MentionOnly mode, inject the message into in-memory history
-                // so the LLM retains channel context when eventually triggered.
-                if matches!(
-                    self.resolved_settings.response_mode,
-                    ResponseMode::MentionOnly
-                ) {
-                    {
-                        let mut history = self.state.history.write().await;
-                        history.push(rig::message::Message::User {
-                            content: OneOrMany::one(UserContent::text(&user_text)),
-                        });
-                    }
-                    // Compaction guard: suppressed messages accumulate in history
-                    // without agent turns, so check compaction to prevent unbounded growth.
-                    if let Err(error) = self.compactor.check_and_compact().await {
-                        tracing::warn!(channel_id = %self.id, %error, "compaction check failed");
-                    }
+                // In Observe and MentionOnly modes, inject the message into
+                // in-memory history so the agent retains channel context.
+                {
+                    let mut history = self.state.history.write().await;
+                    history.push(rig::message::Message::User {
+                        content: OneOrMany::one(UserContent::text(&user_text)),
+                    });
+                }
+                if let Err(error) = self.compactor.check_and_compact().await {
+                    tracing::warn!(channel_id = %self.id, %error, "compaction check failed");
                 }
-                // Both Quiet and MentionOnly keep passive memory capture.
+                // Both Observe and MentionOnly keep passive memory capture.
                 self.message_count += 1;
                 self.check_memory_persistence().await;
                 return Ok(());
@@ -1948,10 +1951,10 @@ impl Channel {
         self.handle_agent_result(result, &skip_flag, &replied_flag, is_retrigger)
             .await;
 
-        // Safety-net: in quiet mode, explicit mention/reply should never be dropped silently.
+        // Safety-net: in mention-only mode, explicit mention/reply should never be dropped silently.
         if should_send_quiet_mode_fallback(
             &message,
-            QuietModeFallbackState {
+            ObserveModeFallbackState {
                 is_suppressed: self.is_suppressed(),
                 is_retrigger,
                 invoked_by_command,
@@ -3626,7 +3629,7 @@ fn should_send_discord_quiet_mode_ping_ack(
 }
 
 #[derive(Debug, Clone, Copy)]
-struct QuietModeFallbackState {
+struct ObserveModeFallbackState {
     is_suppressed: bool,
     is_retrigger: bool,
     invoked_by_command: bool,
@@ -3638,7 +3641,7 @@ struct QuietModeFallbackState {
 
 fn should_send_quiet_mode_fallback(
     message: &InboundMessage,
-    state: QuietModeFallbackState,
+    state: ObserveModeFallbackState,
 ) -> bool {
     state.is_suppressed
         && !state.is_retrigger
@@ -3668,7 +3671,7 @@ fn is_dm_conversation_id(conv_id: &str) -> bool {
 #[cfg(test)]
 mod tests {
     use super::{
-        QuietModeFallbackState, compute_listen_mode_invocation, is_dm_conversation_id,
+        ObserveModeFallbackState, compute_listen_mode_invocation, is_dm_conversation_id,
         recv_channel_event, should_process_event_for_channel,
         should_send_discord_quiet_mode_ping_ack, should_send_quiet_mode_fallback,
     };
@@ -3896,7 +3899,7 @@ mod tests {
 
         assert!(should_send_quiet_mode_fallback(
             &message,
-            QuietModeFallbackState {
+            ObserveModeFallbackState {
                 is_suppressed: true,
                 is_retrigger: false,
                 invoked_by_command: false,
@@ -3908,7 +3911,7 @@ mod tests {
         ));
         assert!(!should_send_quiet_mode_fallback(
             &message,
-            QuietModeFallbackState {
+            ObserveModeFallbackState {
                 is_suppressed: true,
                 is_retrigger: false,
                 invoked_by_command: false,
@@ -3920,7 +3923,7 @@ mod tests {
         ));
         assert!(!should_send_quiet_mode_fallback(
             &message,
-            QuietModeFallbackState {
+            ObserveModeFallbackState {
                 is_suppressed: true,
                 is_retrigger: false,
                 invoked_by_command: false,
@@ -3932,7 +3935,7 @@ mod tests {
         ));
         assert!(!should_send_quiet_mode_fallback(
             &message,
-            QuietModeFallbackState {
+            ObserveModeFallbackState {
                 is_suppressed: true,
                 is_retrigger: true,
                 invoked_by_command: false,

src/api/channels.rs

@@ -144,7 +144,7 @@ pub(super) async fn list_channels(
                     let settings = &cs.model_overrides;
                     let mode = match settings.response_mode {
                         crate::conversation::ResponseMode::Active => None,
-                        crate::conversation::ResponseMode::Quiet => Some("quiet".to_string()),
+                        crate::conversation::ResponseMode::Observe => Some("observe".to_string()),
                         crate::conversation::ResponseMode::MentionOnly => {
                             Some("mention_only".to_string())
                         }

src/config/load.rs

@@ -123,7 +123,7 @@ fn parse_response_mode(
     if let Some(mode) = response_mode {
         return match mode {
             "active" => Some(ResponseMode::Active),
-            "quiet" => Some(ResponseMode::Quiet),
+            "observe" | "quiet" => Some(ResponseMode::Observe),
             "mention_only" => Some(ResponseMode::MentionOnly),
             unknown => {
                 tracing::warn!(
@@ -137,8 +137,8 @@ fn parse_response_mode(
     // Backwards compat: listen_only_mode maps to response_mode
     match listen_only_mode {
         Some(true) => {
-            tracing::warn!("listen_only_mode is deprecated, use response_mode = \"quiet\" instead");
-            Some(ResponseMode::Quiet)
+            tracing::warn!("listen_only_mode is deprecated, use response_mode = \"observe\" instead");
+            Some(ResponseMode::Observe)
         }
         Some(false) => Some(ResponseMode::Active),
         None => None,
@@ -2453,7 +2453,7 @@ impl Config {
                     }
                     if let Some(r) = s.response_mode.as_deref() {
                         match r {
-                            "quiet" => cs.response_mode = ResponseMode::Quiet,
+                            "observe" | "quiet" => cs.response_mode = ResponseMode::Observe,
                             "mention_only" => cs.response_mode = ResponseMode::MentionOnly,
                             "active" => cs.response_mode = ResponseMode::Active,
                             other => tracing::warn!(

src/conversation/settings.rs

@@ -116,9 +116,12 @@ pub enum ResponseMode {
     /// Respond to all messages normally.
     #[default]
     Active,
-    /// Observe and learn (history + memory persistence) but only respond
-    /// to @mentions, replies-to-bot, and slash commands.
-    Quiet,
+    /// Observe only — never respond, even when mentioned or replied to.
+    /// All messages are ingested into in-memory context and conversation
+    /// history, and passive memory capture continues. The agent learns
+    /// from the conversation but never generates a response.
+    #[serde(alias = "quiet")]
+    Observe,
     /// Only respond when explicitly @mentioned, replied to, or given a command.
     /// Messages that don't pass the mention check are still ingested into
     /// the in-memory context window (so the agent stays context-aware),