Limit agent mode list to primary

Author: jacobjmc

AGENTS.md

@@ -180,5 +180,6 @@ Use extra care in high-churn/high-complexity files:
 - Setup/build/release/test commands: `README.md`
 - Architecture decision (ACP to REST migration): `docs/shaping/rest-api-migration.md`
 - Frontend event contract: `docs/app-server-events.md`
+- For OpenCode API/feature changes, refer to `opencode-server-api.mdx` and `./tmp/opencode` before implementing protocol or behavior updates.
 
 ##

src-tauri/src/backend/event_translator.rs

@@ -22,10 +22,14 @@ struct PerSessionTurnState {
     agent_message_item_id: Option<String>,
     /// OpenCode part ID for the current text part (used to handle part removals/reset).
     agent_message_part_id: Option<String>,
+    /// Number of bytes already emitted for the current agent text part.
+    agent_message_text_len: usize,
     /// Stable item ID for the current reasoning stream.
     reasoning_item_id: Option<String>,
     /// OpenCode part ID for the current reasoning part (used to route `message.part.delta` events).
     reasoning_part_id: Option<String>,
+    /// Number of bytes already emitted for the current reasoning part.
+    reasoning_text_len: usize,
     /// Stable item ID for the current user-message being assembled from SSE chunks.
     user_message_item_id: Option<String>,
     /// Buffered text for the current user-message being assembled from SSE chunks.
@@ -126,8 +130,10 @@ impl SessionTranslationState {
         turn_state.tool_call_items.clear();
         turn_state.agent_message_item_id = None;
         turn_state.agent_message_part_id = None;
+        turn_state.agent_message_text_len = 0;
         turn_state.reasoning_item_id = None;
         turn_state.reasoning_part_id = None;
+        turn_state.reasoning_text_len = 0;
         turn_state.user_message_item_id = preserved_user_message_item_id;
         turn_state.user_message_text = preserved_user_message_text;
     }
@@ -141,6 +147,9 @@ impl SessionTranslationState {
             turn_state.agent_message_item_id = None;
             turn_state.reasoning_item_id = None;
             turn_state.reasoning_part_id = None;
+            turn_state.reasoning_text_len = 0;
+            turn_state.agent_message_part_id = None;
+            turn_state.agent_message_text_len = 0;
             // Preserve user_message_item_id so replay reuses the same ID
             // the live SSE translator already emitted (prevents duplicates).
             turn_state.user_message_text.clear();
@@ -185,6 +194,7 @@ impl SessionTranslationState {
         let turn_state = self.get_turn_state_mut(session_id);
         turn_state.agent_message_item_id = None;
         turn_state.agent_message_part_id = None;
+        turn_state.agent_message_text_len = 0;
     }
 
     fn remove_part_mapping(&mut self, session_id: &str, part_id: &str) {
@@ -196,10 +206,12 @@ impl SessionTranslationState {
         if turn_state.reasoning_part_id.as_deref() == Some(part_id) {
             turn_state.reasoning_part_id = None;
             turn_state.reasoning_item_id = None;
+            turn_state.reasoning_text_len = 0;
         }
         if turn_state.agent_message_part_id.as_deref() == Some(part_id) {
             turn_state.agent_message_part_id = None;
             turn_state.agent_message_item_id = None;
+            turn_state.agent_message_text_len = 0;
         }
     }
 
@@ -209,8 +221,10 @@ impl SessionTranslationState {
             turn_state.tool_call_items.clear();
             turn_state.agent_message_item_id = None;
             turn_state.agent_message_part_id = None;
+            turn_state.agent_message_text_len = 0;
             turn_state.reasoning_item_id = None;
             turn_state.reasoning_part_id = None;
+            turn_state.reasoning_text_len = 0;
             turn_state.user_message_item_id = None;
             turn_state.user_message_text.clear();
         }
@@ -233,8 +247,10 @@ impl SessionTranslationState {
             turn_state.tool_call_items.clear();
             turn_state.agent_message_item_id = None;
             turn_state.agent_message_part_id = None;
+            turn_state.agent_message_text_len = 0;
             turn_state.reasoning_item_id = None;
             turn_state.reasoning_part_id = None;
+            turn_state.reasoning_text_len = 0;
         }
     }
 
@@ -256,6 +272,19 @@ impl SessionTranslationState {
     }
 }
 
+fn unseen_suffix<'a>(full_text: &'a str, emitted_len: usize) -> Option<&'a str> {
+    if full_text.is_empty() {
+        return None;
+    }
+    if emitted_len == 0 {
+        return Some(full_text);
+    }
+    if full_text.len() <= emitted_len {
+        return None;
+    }
+    full_text.get(emitted_len..).filter(|suffix| !suffix.is_empty())
+}
+
 fn parse_u64(value: Option<&Value>) -> Option<u64> {
     value
         .and_then(|v| {
@@ -542,10 +571,20 @@ fn translate_part_updated(properties: &Value, state: &mut SessionTranslationStat
                 // Emit a userMessage item so the prompt is visible immediately
                 // (particularly important for subagent sessions whose prompts
                 // aren't injected by send_user_message_core).
+                let effective_text_owned;
                 let effective_text = if delta.is_empty() {
-                    part.get("text")
-                        .and_then(|v| v.as_str())
-                        .unwrap_or_default()
+                    let full_text = part.get("text").and_then(|v| v.as_str()).unwrap_or_default();
+                    let current_user_text = state
+                        .get_turn_state(&thread_id)
+                        .map(|ts| ts.user_message_text.clone())
+                        .unwrap_or_default();
+                    if full_text.starts_with(current_user_text.as_str()) {
+                        let suffix = &full_text[current_user_text.len()..];
+                        effective_text_owned = suffix.to_string();
+                        effective_text_owned.as_str()
+                    } else {
+                        full_text
+                    }
                 } else {
                     delta
                 };
@@ -575,18 +614,37 @@ fn translate_part_updated(properties: &Value, state: &mut SessionTranslationStat
             }
             if let Some(pid) = part.get("id").and_then(|v| v.as_str()) {
                 let turn_state = state.get_turn_state_mut(&thread_id);
-                turn_state.agent_message_part_id = Some(pid.to_string());
+                if turn_state.agent_message_part_id.as_deref() != Some(pid) {
+                    turn_state.agent_message_part_id = Some(pid.to_string());
+                    turn_state.agent_message_text_len = 0;
+                }
             }
             let effective_delta = if delta.is_empty() {
-                part.get("text")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
+                let full_text = part.get("text").and_then(|v| v.as_str()).unwrap_or_default();
+                let emitted_len = state
+                    .get_turn_state(&thread_id)
+                    .map(|ts| ts.agent_message_text_len)
+                    .unwrap_or(0);
+                match unseen_suffix(full_text, emitted_len) {
+                    Some(suffix) => suffix,
+                    None => return vec![],
+                }
             } else {
                 delta
             };
             if effective_delta.is_empty() {
                 return vec![];
             }
+            if delta.is_empty() {
+                let full_len = part
+                    .get("text")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.len())
+                    .unwrap_or(effective_delta.len());
+                state.get_turn_state_mut(&thread_id).agent_message_text_len = full_len;
+            } else {
+                state.get_turn_state_mut(&thread_id).agent_message_text_len += effective_delta.len();
+            }
 
             let item_id = state.agent_message_item(&thread_id);
             vec![json!({
@@ -606,18 +664,37 @@ fn translate_part_updated(properties: &Value, state: &mut SessionTranslationStat
             }
             if let Some(pid) = part.get("id").and_then(|v| v.as_str()) {
                 let turn_state = state.get_turn_state_mut(&thread_id);
-                turn_state.reasoning_part_id = Some(pid.to_string());
+                if turn_state.reasoning_part_id.as_deref() != Some(pid) {
+                    turn_state.reasoning_part_id = Some(pid.to_string());
+                    turn_state.reasoning_text_len = 0;
+                }
             }
             let effective_delta = if delta.is_empty() {
-                part.get("text")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
+                let full_text = part.get("text").and_then(|v| v.as_str()).unwrap_or_default();
+                let emitted_len = state
+                    .get_turn_state(&thread_id)
+                    .map(|ts| ts.reasoning_text_len)
+                    .unwrap_or(0);
+                match unseen_suffix(full_text, emitted_len) {
+                    Some(suffix) => suffix,
+                    None => return vec![],
+                }
             } else {
                 delta
             };
             if effective_delta.is_empty() {
                 return vec![];
             }
+            if delta.is_empty() {
+                let full_len = part
+                    .get("text")
+                    .and_then(|v| v.as_str())
+                    .map(|s| s.len())
+                    .unwrap_or(effective_delta.len());
+                state.get_turn_state_mut(&thread_id).reasoning_text_len = full_len;
+            } else {
+                state.get_turn_state_mut(&thread_id).reasoning_text_len += effective_delta.len();
+            }
             let item_id = state.reasoning_item(&thread_id);
             vec![json!({
                 "method": "item/reasoning/textDelta",
@@ -751,6 +828,7 @@ fn translate_part_delta(properties: &Value, state: &mut SessionTranslationState)
 
             if is_reasoning {
                 let item_id = state.reasoning_item(&thread_id);
+                state.get_turn_state_mut(&thread_id).reasoning_text_len += delta.len();
                 return vec![json!({
                     "method": "item/reasoning/textDelta",
                     "params": {
@@ -763,6 +841,7 @@ fn translate_part_delta(properties: &Value, state: &mut SessionTranslationState)
             }
 
             let item_id = state.agent_message_item(&thread_id);
+            state.get_turn_state_mut(&thread_id).agent_message_text_len += delta.len();
             vec![json!({
                 "method": "item/agentMessage/delta",
                 "params": {
@@ -2429,6 +2508,62 @@ mod tests {
         assert_eq!(events[0]["params"]["delta"], "hello");
     }
 
+    #[test]
+    fn text_part_updated_uses_only_unseen_suffix_after_streamed_deltas() {
+        let mut state = make_state();
+
+        let delta1 = json!({
+            "type": "message.part.delta",
+            "properties": {
+                "sessionID": "ses_test123",
+                "messageID": "msg_1",
+                "partID": "prt_text_1",
+                "field": "text",
+                "delta": "I'm currently in Plan Mode (read-only), "
+            }
+        });
+        let events1 = translate_sse_event(&delta1, &mut state);
+        assert_eq!(events1.len(), 1);
+        assert_eq!(events1[0]["params"]["delta"], "I'm currently in Plan Mode (read-only), ");
+
+        let delta2 = json!({
+            "type": "message.part.delta",
+            "properties": {
+                "sessionID": "ses_test123",
+                "messageID": "msg_1",
+                "partID": "prt_text_1",
+                "field": "text",
+                "delta": "so I can't make any file edits right now."
+            }
+        });
+        let events2 = translate_sse_event(&delta2, &mut state);
+        assert_eq!(events2.len(), 1);
+        assert_eq!(
+            events2[0]["params"]["delta"],
+            "so I can't make any file edits right now."
+        );
+
+        let updated = json!({
+            "type": "message.part.updated",
+            "properties": {
+                "part": {
+                    "type": "text",
+                    "id": "prt_text_1",
+                    "sessionID": "ses_test123",
+                    "messageID": "msg_1",
+                    "text": "I'm currently in Plan Mode (read-only), so I can't make any file edits right now.\n\nTo make edits, switch out of Plan Mode first."
+                }
+            }
+        });
+        let events3 = translate_sse_event(&updated, &mut state);
+        assert_eq!(events3.len(), 1);
+        assert_eq!(events3[0]["method"], "item/agentMessage/delta");
+        assert_eq!(
+            events3[0]["params"]["delta"],
+            "\n\nTo make edits, switch out of Plan Mode first."
+        );
+    }
+
     #[test]
     fn user_text_part_updated_emits_user_message_item() {
         let mut state = make_state();

src-tauri/src/shared/codex_core.rs

@@ -259,6 +259,18 @@ fn collaboration_mode_entry_from_agent(agent: &Value) -> Option<Value> {
         return None;
     }
 
+    let agent_mode = agent
+        .get("mode")
+        .and_then(|v| v.as_str())
+        .map(str::trim)
+        .filter(|value| !value.is_empty());
+    if let Some(mode) = agent_mode {
+        // Collaboration mode picker should only show primary-capable agents.
+        if mode != "primary" && mode != "all" {
+            return None;
+        }
+    }
+
     let hidden = agent
         .get("hidden")
         .and_then(|v| v.as_bool())
@@ -2000,20 +2012,36 @@ mod tests {
     }
 
     #[test]
-    fn collaboration_mode_entry_from_agent_includes_subagent_and_skips_hidden() {
+    fn collaboration_mode_entry_from_agent_keeps_primary_capable_and_skips_subagent_hidden() {
         let subagent = collaboration_mode_entry_from_agent(&json!({
             "name": "explore",
             "mode": "subagent",
             "hidden": false,
             "description": "Explore-only agent"
+        }));
+        assert!(subagent.is_none());
+
+        let primary = collaboration_mode_entry_from_agent(&json!({
+            "name": "build",
+            "mode": "primary",
+            "hidden": false,
+            "description": "Primary agent"
         }))
-        .expect("subagent should be included");
-        assert_eq!(subagent["mode"], "explore");
-        assert_eq!(subagent["label"], "Explore");
+        .expect("primary agent should be included");
+        assert_eq!(primary["mode"], "build");
+        assert_eq!(primary["label"], "Build");
+
+        let dual_role = collaboration_mode_entry_from_agent(&json!({
+            "name": "general",
+            "mode": "all",
+            "hidden": false
+        }))
+        .expect("all-mode agent should be included");
+        assert_eq!(dual_role["mode"], "general");
 
         let hidden = collaboration_mode_entry_from_agent(&json!({
             "name": "summary",
-            "mode": "subagent",
+            "mode": "primary",
             "hidden": true
         }));
         assert!(hidden.is_none());

src/features/threads/hooks/threadReducer/threadLifecycleSlice.ts

@@ -4,6 +4,25 @@ import { prefersUpdatedSort } from "./common";
 
 type ThreadStatus = ThreadState["threadStatusById"][string];
 
+function sortThreadsByUpdatedAtDesc(threads: ThreadSummary[]): ThreadSummary[] {
+  const originalIndexById = new Map(
+    threads.map((thread, index) => [thread.id, index] as const),
+  );
+  return [...threads].sort((a, b) => {
+    const aUpdated = a.updatedAt ?? 0;
+    const bUpdated = b.updatedAt ?? 0;
+    if (bUpdated !== aUpdated) {
+      return bUpdated - aUpdated;
+    }
+    const aIndex = originalIndexById.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+    const bIndex = originalIndexById.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+    if (aIndex !== bIndex) {
+      return aIndex - bIndex;
+    }
+    return a.id.localeCompare(b.id);
+  });
+}
+
 function statusEquals(previous: ThreadStatus, nextStatus: ThreadStatus) {
   return (
     previous.isProcessing === nextStatus.isProcessing &&
@@ -296,10 +315,7 @@ export function reduceThreadLifecycle(
         return state;
       }
       const sorted = prefersUpdatedSort(state, action.workspaceId)
-        ? [
-            ...next.filter((thread) => thread.id === action.threadId),
-            ...next.filter((thread) => thread.id !== action.threadId),
-          ]
+        ? sortThreadsByUpdatedAtDesc(next)
         : next;
       return {
         ...state,