fix: handle thread archive/unarchive app server events

Author: Dimillian

docs/app-server-events.md

@@ -59,7 +59,9 @@ routed in `useAppServerEvents.ts` or handled in feature-specific subscriptions.
 - `item/agentMessage/delta`
 - `turn/started`
 - `thread/started`
+- `thread/archived`
 - `thread/name/updated`
+- `thread/unarchived`
 - `codex/backgroundThread`
 - `error`
 - `turn/completed`
@@ -103,9 +105,7 @@ events are currently not routed:
 - `item/mcpToolCall/progress`
 - `mcpServer/oauthLogin/completed`
 - `model/rerouted`
-- `thread/archived`
 - `thread/compacted` (deprecated; intentionally not routed)
-- `thread/unarchived`
 - `deprecationNotice`
 - `configWarning`
 - `windows/worldWritableWarning`

src/features/app/hooks/useAppServerEvents.test.tsx

@@ -49,6 +49,8 @@ describe("useAppServerEvents", () => {
       onWorkspaceConnected: vi.fn(),
       onThreadStarted: vi.fn(),
       onThreadNameUpdated: vi.fn(),
+      onThreadArchived: vi.fn(),
+      onThreadUnarchived: vi.fn(),
       onBackgroundThreadAction: vi.fn(),
       onAgentMessageDelta: vi.fn(),
       onReasoningSummaryBoundary: vi.fn(),
@@ -144,6 +146,28 @@ describe("useAppServerEvents", () => {
       threadName: "Renamed from server",
     });
 
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "thread/archived",
+          params: { thread_id: "thread-2" },
+        },
+      });
+    });
+    expect(handlers.onThreadArchived).toHaveBeenCalledWith("ws-1", "thread-2");
+
+    act(() => {
+      listener?.({
+        workspace_id: "ws-1",
+        message: {
+          method: "thread/unarchived",
+          params: { threadId: "thread-2" },
+        },
+      });
+    });
+    expect(handlers.onThreadUnarchived).toHaveBeenCalledWith("ws-1", "thread-2");
+
     act(() => {
       listener?.({
         workspace_id: "ws-1",

src/features/app/hooks/useAppServerEvents.ts

@@ -35,6 +35,8 @@ type AppServerEventHandlers = {
     workspaceId: string,
     payload: { threadId: string; threadName: string | null },
   ) => void;
+  onThreadArchived?: (workspaceId: string, threadId: string) => void;
+  onThreadUnarchived?: (workspaceId: string, threadId: string) => void;
   onBackgroundThreadAction?: (
     workspaceId: string,
     threadId: string,
@@ -108,9 +110,11 @@ export const METHODS_ROUTED_IN_USE_APP_SERVER_EVENTS = [
   "item/reasoning/textDelta",
   "item/started",
   "item/tool/requestUserInput",
+  "thread/archived",
   "thread/name/updated",
   "thread/started",
   "thread/tokenUsage/updated",
+  "thread/unarchived",
   "turn/completed",
   "turn/diff/updated",
   "turn/plan/updated",
@@ -248,6 +252,22 @@ export function useAppServerEvents(handlers: AppServerEventHandlers) {
         return;
       }
 
+      if (method === "thread/archived") {
+        const threadId = String(params.threadId ?? params.thread_id ?? "").trim();
+        if (threadId) {
+          currentHandlers.onThreadArchived?.(workspace_id, threadId);
+        }
+        return;
+      }
+
+      if (method === "thread/unarchived") {
+        const threadId = String(params.threadId ?? params.thread_id ?? "").trim();
+        if (threadId) {
+          currentHandlers.onThreadUnarchived?.(workspace_id, threadId);
+        }
+        return;
+      }
+
       if (method === "codex/backgroundThread") {
         const threadId = String(params.threadId ?? params.thread_id ?? "");
         const action = String(params.action ?? "hide");

src/features/threads/hooks/useThreadEventHandlers.ts

@@ -97,6 +97,8 @@ export function useThreadEventHandlers({
   const {
     onThreadStarted,
     onThreadNameUpdated,
+    onThreadArchived,
+    onThreadUnarchived,
     onTurnStarted,
     onTurnCompleted,
     onTurnPlanUpdated,
@@ -164,6 +166,8 @@ export function useThreadEventHandlers({
       onFileChangeOutputDelta,
       onThreadStarted,
       onThreadNameUpdated,
+      onThreadArchived,
+      onThreadUnarchived,
       onTurnStarted,
       onTurnCompleted,
       onTurnPlanUpdated,
@@ -191,6 +195,8 @@ export function useThreadEventHandlers({
       onFileChangeOutputDelta,
       onThreadStarted,
       onThreadNameUpdated,
+      onThreadArchived,
+      onThreadUnarchived,
       onTurnStarted,
       onTurnCompleted,
       onTurnPlanUpdated,

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

@@ -207,6 +207,48 @@ describe("useThreadTurnEvents", () => {
     );
   });
 
+  it("removes thread state on thread archived", () => {
+    const { result, dispatch } = makeOptions();
+
+    act(() => {
+      result.current.onThreadArchived("ws-1", "thread-7");
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "removeThread",
+      workspaceId: "ws-1",
+      threadId: "thread-7",
+    });
+  });
+
+  it("re-adds thread summary on thread unarchived", () => {
+    const { result, dispatch, recordThreadActivity, safeMessageActivity } =
+      makeOptions();
+
+    act(() => {
+      result.current.onThreadUnarchived("ws-1", "thread-8");
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "ensureThread",
+      workspaceId: "ws-1",
+      threadId: "thread-8",
+    });
+    expect(dispatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "setThreadTimestamp",
+        workspaceId: "ws-1",
+        threadId: "thread-8",
+      }),
+    );
+    expect(recordThreadActivity).toHaveBeenCalledWith(
+      "ws-1",
+      "thread-8",
+      expect.any(Number),
+    );
+    expect(safeMessageActivity).toHaveBeenCalled();
+  });
+
   it("marks processing and active turn on turn started", () => {
     const { result, dispatch, markProcessing, setActiveTurnId } = makeOptions();
 

src/features/threads/hooks/useThreadTurnEvents.ts

@@ -149,6 +149,44 @@ export function useThreadTurnEvents({
     [dispatch, getCustomName],
   );
 
+  const onThreadArchived = useCallback(
+    (workspaceId: string, threadId: string) => {
+      if (!threadId) {
+        return;
+      }
+      dispatch({ type: "removeThread", workspaceId, threadId });
+    },
+    [dispatch],
+  );
+
+  const onThreadUnarchived = useCallback(
+    (workspaceId: string, threadId: string) => {
+      if (!threadId) {
+        return;
+      }
+      dispatch({ type: "ensureThread", workspaceId, threadId });
+      const customName = getCustomName(workspaceId, threadId);
+      if (customName) {
+        dispatch({
+          type: "setThreadName",
+          workspaceId,
+          threadId,
+          name: customName,
+        });
+      }
+      const timestamp = Date.now();
+      dispatch({
+        type: "setThreadTimestamp",
+        workspaceId,
+        threadId,
+        timestamp,
+      });
+      recordThreadActivity(workspaceId, threadId, timestamp);
+      safeMessageActivity();
+    },
+    [dispatch, getCustomName, recordThreadActivity, safeMessageActivity],
+  );
+
   const onTurnStarted = useCallback(
     (workspaceId: string, threadId: string, turnId: string) => {
       dispatch({
@@ -293,6 +331,8 @@ export function useThreadTurnEvents({
   return {
     onThreadStarted,
     onThreadNameUpdated,
+    onThreadArchived,
+    onThreadUnarchived,
     onTurnStarted,
     onTurnCompleted,
     onTurnPlanUpdated,

src/features/threads/hooks/useThreads.ts

@@ -402,16 +402,35 @@ export function useThreads({
     [onSubagentThreadDetected, threadHandlers, updateThreadParent],
   );
 
+  const handleThreadArchived = useCallback(
+    (workspaceId: string, threadId: string) => {
+      threadHandlers.onThreadArchived?.(workspaceId, threadId);
+      unpinThread(workspaceId, threadId);
+    },
+    [threadHandlers, unpinThread],
+  );
+
+  const handleThreadUnarchived = useCallback(
+    (workspaceId: string, threadId: string) => {
+      threadHandlers.onThreadUnarchived?.(workspaceId, threadId);
+    },
+    [threadHandlers],
+  );
+
   const handlers = useMemo(
     () => ({
       ...threadHandlers,
       onThreadStarted: handleThreadStarted,
+      onThreadArchived: handleThreadArchived,
+      onThreadUnarchived: handleThreadUnarchived,
       onAccountUpdated: handleAccountUpdated,
       onAccountLoginCompleted: handleAccountLoginCompleted,
     }),
     [
       threadHandlers,
       handleThreadStarted,
+      handleThreadArchived,
+      handleThreadUnarchived,
       handleAccountUpdated,
       handleAccountLoginCompleted,
     ],

src/utils/appServerEvents.ts

@@ -20,9 +20,11 @@ export const SUPPORTED_APP_SERVER_METHODS = [
   "item/reasoning/textDelta",
   "item/started",
   "item/tool/requestUserInput",
+  "thread/archived",
   "thread/name/updated",
   "thread/started",
   "thread/tokenUsage/updated",
+  "thread/unarchived",
   "turn/completed",
   "turn/diff/updated",
   "turn/plan/updated",