fix: restore updater/menu wiring and thread session loading

Author: mweinbach

src-tauri/src/backend/app_server.rs

@@ -49,6 +49,17 @@ fn normalize_root_path(value: &str) -> String {
     if normalized.is_empty() {
         return String::new();
     }
+    let lower = normalized.to_ascii_lowercase();
+    let normalized = if lower.starts_with("//?/unc/") {
+        format!("//{}", &normalized[8..])
+    } else if lower.starts_with("//?/") || lower.starts_with("//./") {
+        normalized[4..].to_string()
+    } else {
+        normalized.to_string()
+    };
+    if normalized.is_empty() {
+        return String::new();
+    }
 
     let bytes = normalized.as_bytes();
     let is_drive_path = bytes.len() >= 3
@@ -133,13 +144,24 @@ fn resolve_workspace_for_cwd(
     if normalized_cwd.is_empty() {
         return None;
     }
-    workspace_roots.iter().find_map(|(workspace_id, root)| {
-        if root == &normalized_cwd {
-            Some(workspace_id.clone())
-        } else {
-            None
-        }
-    })
+    workspace_roots
+        .iter()
+        .filter_map(|(workspace_id, root)| {
+            if root.is_empty() {
+                return None;
+            }
+            let is_exact_match = root == &normalized_cwd;
+            let is_nested_match = normalized_cwd.len() > root.len()
+                && normalized_cwd.starts_with(root)
+                && normalized_cwd.as_bytes().get(root.len()) == Some(&b'/');
+            if is_exact_match || is_nested_match {
+                Some((workspace_id, root.len()))
+            } else {
+                None
+            }
+        })
+        .max_by_key(|(_, root_len)| *root_len)
+        .map(|(workspace_id, _)| workspace_id.clone())
 }
 
 fn is_global_workspace_notification(method: &str) -> bool {
@@ -844,4 +866,46 @@ mod tests {
             Some("ws-1".to_string())
         );
     }
+
+    #[test]
+    fn resolve_workspace_for_cwd_normalizes_windows_namespace_paths() {
+        let mut roots = HashMap::new();
+        roots.insert("ws-1".to_string(), normalize_root_path("C:\\Dev\\Codex"));
+        assert_eq!(
+            resolve_workspace_for_cwd("\\\\?\\C:\\Dev\\Codex", &roots),
+            Some("ws-1".to_string())
+        );
+    }
+
+    #[test]
+    fn normalize_root_path_normalizes_windows_namespace_unc_paths() {
+        assert_eq!(
+            normalize_root_path("\\\\?\\UNC\\SERVER\\Share\\Repo\\"),
+            "//server/share/repo"
+        );
+    }
+
+    #[test]
+    fn resolve_workspace_for_cwd_matches_nested_paths() {
+        let mut roots = HashMap::new();
+        roots.insert("ws-1".to_string(), normalize_root_path("/tmp/codex"));
+        assert_eq!(
+            resolve_workspace_for_cwd("/tmp/codex/subdir/project", &roots),
+            Some("ws-1".to_string())
+        );
+    }
+
+    #[test]
+    fn resolve_workspace_for_cwd_prefers_longest_matching_root() {
+        let mut roots = HashMap::new();
+        roots.insert("ws-parent".to_string(), normalize_root_path("/tmp/codex"));
+        roots.insert(
+            "ws-child".to_string(),
+            normalize_root_path("/tmp/codex/subdir"),
+        );
+        assert_eq!(
+            resolve_workspace_for_cwd("/tmp/codex/subdir/project", &roots),
+            Some("ws-child".to_string())
+        );
+    }
 }

src-tauri/src/lib.rs

@@ -88,12 +88,7 @@ pub fn run() {
         }
     }
 
-    // Windows: no native menu bar.
-    #[cfg(all(desktop, target_os = "windows"))]
-    let builder = tauri::Builder::default().manage(menu::MenuItemRegistry::<tauri::Wry>::default());
-
-    // macOS/Linux: keep the native menu behavior.
-    #[cfg(all(desktop, not(target_os = "windows")))]
+    #[cfg(desktop)]
     let builder = tauri::Builder::default()
         .manage(menu::MenuItemRegistry::<tauri::Wry>::default())
         .on_menu_event(menu::handle_menu_event)
@@ -121,6 +116,8 @@ pub fn run() {
             {
                 if let Some(main_window) = app.get_webview_window("main") {
                     let _ = main_window.set_decorations(false);
+                    // Keep menu accelerators wired while suppressing a visible native menu bar.
+                    let _ = main_window.hide_menu();
                 }
             }
             #[cfg(desktop)]

src-tauri/src/menu.rs

@@ -2,10 +2,8 @@ use std::collections::HashMap;
 use std::sync::Mutex;
 
 use serde::Deserialize;
-#[cfg(not(target_os = "windows"))]
 use tauri::menu::{Menu, MenuItemBuilder, PredefinedMenuItem, Submenu};
 use tauri::menu::MenuItem;
-#[cfg(not(target_os = "windows"))]
 use tauri::{Emitter, WebviewUrl, WebviewWindowBuilder};
 use tauri::{Manager, Runtime};
 
@@ -22,7 +20,6 @@ impl<R: Runtime> Default for MenuItemRegistry<R> {
 }
 
 impl<R: Runtime> MenuItemRegistry<R> {
-    #[cfg(not(target_os = "windows"))]
     fn register(&self, id: &str, item: &MenuItem<R>) {
         if let Ok(mut items) = self.items.lock() {
             items.insert(id.to_string(), item.clone());
@@ -63,7 +60,6 @@ pub fn menu_set_accelerators<R: Runtime>(
     Ok(())
 }
 
-#[cfg(not(target_os = "windows"))]
 pub(crate) fn build_menu<R: tauri::Runtime>(
     handle: &tauri::AppHandle<R>,
 ) -> tauri::Result<Menu<R>> {
@@ -328,7 +324,6 @@ pub(crate) fn build_menu<R: tauri::Runtime>(
     )
 }
 
-#[cfg(not(target_os = "windows"))]
 pub(crate) fn handle_menu_event<R: tauri::Runtime>(
     app: &tauri::AppHandle<R>,
     event: tauri::menu::MenuEvent,
@@ -396,7 +391,6 @@ pub(crate) fn handle_menu_event<R: tauri::Runtime>(
     }
 }
 
-#[cfg(not(target_os = "windows"))]
 fn emit_menu_event<R: tauri::Runtime>(app: &tauri::AppHandle<R>, event: &str) {
     if let Some(window) = app.get_webview_window("main") {
         let _ = window.show();

src-tauri/src/shared/codex_core.rs

@@ -241,9 +241,19 @@ pub(crate) async fn list_threads_core(
         "cursor": cursor,
         "limit": limit,
         "sortKey": sort_key,
-        // Keep spawned sub-agent sessions visible in thread/list so UI refreshes
-        // do not drop parent -> child sidebar relationships.
-        "sourceKinds": ["cli", "vscode", "subAgentThreadSpawn"]
+        // Keep interactive and sub-agent sessions visible across CLI versions so
+        // thread/list refreshes do not drop valid historical conversations.
+        "sourceKinds": [
+            "cli",
+            "vscode",
+            "appServer",
+            "subAgent",
+            "subAgentReview",
+            "subAgentCompact",
+            "subAgentThreadSpawn",
+            "subAgentOther",
+            "unknown"
+        ]
     });
     session
         .send_request_for_workspace(&workspace_id, "thread/list", params)

src/features/settings/components/sections/SettingsAboutSection.tsx

@@ -19,7 +19,7 @@ function formatBytes(value: number) {
 export function SettingsAboutSection() {
   const [appBuildType, setAppBuildType] = useState<AppBuildType | "unknown">("unknown");
   const { state: updaterState, checkForUpdates, startUpdate } = useUpdater({
-    enabled: false,
+    enabled: true,
   });
 
   useEffect(() => {

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

@@ -312,6 +312,31 @@ export function reduceThreadLifecycle(
     case "setThreads": {
       const hidden = state.hiddenThreadIdsByWorkspace[action.workspaceId] ?? {};
       const visibleThreads = action.threads.filter((thread) => !hidden[thread.id]);
+      const preserveAnchors = action.preserveAnchors === true;
+      if (!preserveAnchors) {
+        const currentActiveThreadId =
+          state.activeThreadIdByWorkspace[action.workspaceId] ?? null;
+        const activeThreadStillVisible = currentActiveThreadId
+          ? visibleThreads.some((thread) => thread.id === currentActiveThreadId)
+          : false;
+        return {
+          ...state,
+          threadsByWorkspace: {
+            ...state.threadsByWorkspace,
+            [action.workspaceId]: visibleThreads,
+          },
+          activeThreadIdByWorkspace: {
+            ...state.activeThreadIdByWorkspace,
+            [action.workspaceId]: activeThreadStillVisible
+              ? currentActiveThreadId
+              : (visibleThreads[0]?.id ?? null),
+          },
+          threadSortKeyByWorkspace: {
+            ...state.threadSortKeyByWorkspace,
+            [action.workspaceId]: action.sortKey,
+          },
+        };
+      }
       const existingThreads = state.threadsByWorkspace[action.workspaceId] ?? [];
       const existingById = new Map(
         existingThreads.map((thread) => [thread.id, thread] as const),

src/features/threads/hooks/useThreadActions.test.tsx

@@ -734,6 +734,7 @@ describe("useThreadActions", () => {
       type: "setThreads",
       workspaceId: "ws-1",
       sortKey: "updated_at",
+      preserveAnchors: true,
       threads: [
         {
           id: "thread-1",
@@ -1095,6 +1096,84 @@ describe("useThreadActions", () => {
     });
   });
 
+  it("matches windows namespace-prefixed workspace threads client-side", async () => {
+    const windowsWorkspace: WorkspaceInfo = {
+      ...workspace,
+      path: "C:\\Dev\\CodexMon",
+    };
+    vi.mocked(listThreads).mockResolvedValue({
+      result: {
+        data: [
+          {
+            id: "thread-win-ns-1",
+            cwd: "\\\\?\\C:\\Dev\\CodexMon",
+            preview: "Windows namespace thread",
+            updated_at: 5000,
+          },
+        ],
+        nextCursor: null,
+      },
+    });
+    vi.mocked(getThreadTimestamp).mockReturnValue(5000);
+
+    const { result, dispatch } = renderActions();
+
+    await act(async () => {
+      await result.current.listThreadsForWorkspace(windowsWorkspace);
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "setThreads",
+      workspaceId: "ws-1",
+      sortKey: "updated_at",
+      threads: [
+        {
+          id: "thread-win-ns-1",
+          name: "Windows namespace thread",
+          updatedAt: 5000,
+          createdAt: 0,
+        },
+      ],
+    });
+  });
+
+  it("matches nested workspace threads client-side", async () => {
+    vi.mocked(listThreads).mockResolvedValue({
+      result: {
+        data: [
+          {
+            id: "thread-nested-1",
+            cwd: "/tmp/codex/subdir/project",
+            preview: "Nested thread",
+            updated_at: 5000,
+          },
+        ],
+        nextCursor: null,
+      },
+    });
+    vi.mocked(getThreadTimestamp).mockReturnValue(5000);
+
+    const { result, dispatch } = renderActions();
+
+    await act(async () => {
+      await result.current.listThreadsForWorkspace(workspace);
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "setThreads",
+      workspaceId: "ws-1",
+      sortKey: "updated_at",
+      threads: [
+        {
+          id: "thread-nested-1",
+          name: "Nested thread",
+          updatedAt: 5000,
+          createdAt: 0,
+        },
+      ],
+    });
+  });
+
   it("preserves list state when requested", async () => {
     vi.mocked(listThreads).mockResolvedValue({
       result: {
@@ -1313,6 +1392,52 @@ describe("useThreadActions", () => {
     });
   });
 
+  it("matches nested workspace threads when loading older threads", async () => {
+    vi.mocked(listThreads).mockResolvedValue({
+      result: {
+        data: [
+          {
+            id: "thread-nested-older",
+            cwd: "/tmp/codex/subdir/project",
+            preview: "Nested older preview",
+            updated_at: 4000,
+          },
+        ],
+        nextCursor: null,
+      },
+    });
+    vi.mocked(getThreadTimestamp).mockImplementation((thread) => {
+      const value = (thread as Record<string, unknown>).updated_at as number;
+      return value ?? 0;
+    });
+
+    const { result, dispatch } = renderActions({
+      threadsByWorkspace: {
+        "ws-1": [{ id: "thread-1", name: "Agent 1", updatedAt: 6000 }],
+      },
+      threadListCursorByWorkspace: { "ws-1": "cursor-1" },
+    });
+
+    await act(async () => {
+      await result.current.loadOlderThreadsForWorkspace(workspace);
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "setThreads",
+      workspaceId: "ws-1",
+      sortKey: "updated_at",
+      threads: [
+        { id: "thread-1", name: "Agent 1", updatedAt: 6000 },
+        {
+          id: "thread-nested-older",
+          name: "Nested older preview",
+          updatedAt: 4000,
+          createdAt: 0,
+        },
+      ],
+    });
+  });
+
   it("detects model metadata from list responses", async () => {
     vi.mocked(listThreads).mockResolvedValue({
       result: {