fix(threads): prevent phantom sessions and restore recency ordering

Remove eager session prewarming that created extra placeholder sessions, and map OpenCode nested time fields so real sessions sort and timestamp correctly. Also timestamp newly started threads immediately so relative time labels render without delay.

Author: jacobjmc

src-tauri/src/backend/app_server.rs

@@ -156,9 +156,6 @@ pub(crate) struct WorkspaceSession {
     pub(crate) translation_state: Mutex<SessionTranslationState>,
     /// Cached model/provider data from `GET /config/providers`.
     pub(crate) models_cache: Mutex<Option<Value>>,
-    /// Pre-warmed OpenCode session ID created eagerly on workspace connect.
-    /// Consumed by the first `start_thread` call to avoid a duplicate `POST /session`.
-    pub(crate) prewarmed_session_id: Mutex<Option<String>>,
     /// One in-flight prompt at a time per workspace session.
     pub(crate) prompt_lock: Mutex<()>,
     /// Sender to signal SSE reader shutdown when workspace disconnects.
@@ -634,7 +631,6 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
         background_thread_callbacks: Mutex::new(HashMap::new()),
         translation_state: Mutex::new(SessionTranslationState::new(String::new())),
         models_cache: Mutex::new(None),
-        prewarmed_session_id: Mutex::new(None),
         prompt_lock: Mutex::new(()),
         shutdown_tx,
     });
@@ -656,32 +652,11 @@ pub(crate) async fn spawn_workspace_session<E: EventSink>(
     };
     event_sink.emit_app_server_event(payload);
 
-    // Eagerly create a session and fetch providers to populate the model selector.
+    // Eagerly fetch providers to populate the model selector.
     let prewarm_session = Arc::clone(&session);
     let prewarm_sink = event_sink.clone();
     let prewarm_workspace_id = entry.id.clone();
     tokio::spawn(async move {
-        // Create a session.
-        match prewarm_session.rest_post("/session", json!({})).await {
-            Ok(response) => {
-                let session_id = response
-                    .get("id")
-                    .and_then(|v| v.as_str())
-                    .unwrap_or_default()
-                    .to_string();
-
-                if !session_id.is_empty() {
-                    *prewarm_session.prewarmed_session_id.lock().await = Some(session_id);
-                }
-            }
-            Err(err) => {
-                eprintln!(
-                    "Pre-warm POST /session failed for {}: {}",
-                    prewarm_workspace_id, err
-                );
-            }
-        }
-
         // Fetch provider/model config.
         match prewarm_session.rest_get("/config/providers").await {
             Ok(providers) => {

src-tauri/src/shared/codex_core.rs

@@ -98,17 +98,6 @@ pub(crate) async fn start_thread_core(
 ) -> Result<Value, String> {
     let session = get_session_clone(sessions, &workspace_id).await?;
 
-    // Reuse the pre-warmed session if available.
-    if let Some(session_id) = session.prewarmed_session_id.lock().await.take() {
-        let mut ts = session.translation_state.lock().await;
-        ts.session_id = session_id.clone();
-        return Ok(json!({
-            "result": {
-                "thread": { "id": session_id }
-            }
-        }));
-    }
-
     // POST /session → { id, projectID, directory }
     let response = session.rest_post("/session", json!({})).await?;
     let session_id = response
@@ -439,11 +428,17 @@ pub(crate) async fn list_threads_core(
             let updated_at = s
                 .get("updatedAt")
                 .or_else(|| s.get("updated_at"))
+                .or_else(|| s.get("time").and_then(|time| time.get("updated")))
+                .or_else(|| s.get("time").and_then(|time| time.get("updatedAt")))
+                .or_else(|| s.get("time").and_then(|time| time.get("updated_at")))
                 .cloned()
                 .unwrap_or(Value::Null);
             let created_at = s
                 .get("createdAt")
                 .or_else(|| s.get("created_at"))
+                .or_else(|| s.get("time").and_then(|time| time.get("created")))
+                .or_else(|| s.get("time").and_then(|time| time.get("createdAt")))
+                .or_else(|| s.get("time").and_then(|time| time.get("created_at")))
                 .cloned()
                 .unwrap_or_else(|| updated_at.clone());
             let directory = s

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

@@ -102,7 +102,8 @@ describe("useThreadActions", () => {
       result: { thread: { id: "thread-1" } },
     });
 
-    const { result, dispatch, loadedThreadsRef } = renderActions();
+    const { result, dispatch, loadedThreadsRef, threadActivityRef } =
+      renderActions();
 
     let threadId: string | null = null;
     await act(async () => {
@@ -121,7 +122,23 @@ describe("useThreadActions", () => {
       workspaceId: "ws-1",
       threadId: "thread-1",
     });
+    expect(dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "setThreadTimestamp",
+        workspaceId: "ws-1",
+        threadId: "thread-1",
+        timestamp: expect.any(Number),
+      }),
+    );
     expect(loadedThreadsRef.current["thread-1"]).toBe(true);
+    expect(threadActivityRef.current["ws-1"]?.["thread-1"]).toEqual(
+      expect.any(Number),
+    );
+    expect(saveThreadActivity).toHaveBeenCalledWith(
+      expect.objectContaining({
+        "ws-1": expect.objectContaining({ "thread-1": expect.any(Number) }),
+      }),
+    );
   });
 
   it("forks a thread and activates the fork", async () => {

src/features/threads/hooks/useThreadActions.ts

@@ -103,7 +103,26 @@ export function useThreadActions({
         });
         const threadId = extractThreadId(response);
         if (threadId) {
+          const timestamp = Date.now();
+          const workspaceActivity = threadActivityRef.current[workspaceId] ?? {};
+          if (timestamp > (workspaceActivity[threadId] ?? 0)) {
+            const nextActivity = {
+              ...threadActivityRef.current,
+              [workspaceId]: {
+                ...workspaceActivity,
+                [threadId]: timestamp,
+              },
+            };
+            threadActivityRef.current = nextActivity;
+            saveThreadActivity(nextActivity);
+          }
           dispatch({ type: "ensureThread", workspaceId, threadId });
+          dispatch({
+            type: "setThreadTimestamp",
+            workspaceId,
+            threadId,
+            timestamp,
+          });
           if (shouldActivate) {
             dispatch({ type: "setActiveThreadId", workspaceId, threadId });
           }
@@ -122,7 +141,7 @@ export function useThreadActions({
         throw error;
       }
     },
-    [dispatch, extractThreadId, loadedThreadsRef, onDebug],
+    [dispatch, extractThreadId, loadedThreadsRef, onDebug, threadActivityRef],
   );
 
   const resumeThreadForWorkspace = useCallback(