fix(threads): hide memory consolidation subagent threads from sidebar

Author: Dimillian

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

@@ -1185,6 +1185,48 @@ describe("useThreadActions", () => {
     });
   });
 
+  it("hides memory consolidation subagent threads from thread/list", async () => {
+    vi.mocked(listThreads).mockResolvedValue({
+      result: {
+        data: [
+          {
+            id: "memory-thread",
+            cwd: "/tmp/codex",
+            preview: "Memory helper",
+            updated_at: 4500,
+            source: {
+              subagent: "memory_consolidation",
+            },
+          },
+        ],
+        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();
+
+    await act(async () => {
+      await result.current.listThreadsForWorkspace(workspace);
+    });
+
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "hideThread",
+      workspaceId: "ws-1",
+      threadId: "memory-thread",
+    });
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "setThreads",
+      workspaceId: "ws-1",
+      sortKey: "updated_at",
+      preserveAnchors: true,
+      threads: [],
+    });
+  });
+
   it("matches windows workspace threads client-side", async () => {
     const windowsWorkspace: WorkspaceInfo = {
       ...workspace,

src/features/threads/hooks/useThreadActions.ts

@@ -32,6 +32,7 @@ import {
   getParentThreadIdFromThread,
   getResumedTurnState,
   isSubagentThreadSource,
+  shouldHideSubagentThreadFromSidebar,
 } from "@threads/utils/threadRpc";
 import { saveThreadActivity } from "@threads/utils/threadStorage";
 import type { ThreadAction, ThreadState } from "./useThreadsReducer";
@@ -522,6 +523,9 @@ export function useThreadActions({
             : preview
           : fallbackName;
       const metadata = extractThreadCodexMetadata(thread);
+      if (shouldHideSubagentThreadFromSidebar(thread.source)) {
+        return null;
+      }
       const isSubagent = isSubagentThreadSource(thread.source);
       return {
         id,
@@ -633,8 +637,12 @@ export function useThreadActions({
             if (!workspaceId) {
               return;
             }
-            matchingThreadsByWorkspace[workspaceId]?.push(thread);
             const threadId = String(thread?.id ?? "");
+            if (threadId && shouldHideSubagentThreadFromSidebar(thread.source)) {
+              dispatch({ type: "hideThread", workspaceId, threadId });
+              return;
+            }
+            matchingThreadsByWorkspace[workspaceId]?.push(thread);
             if (!threadId) {
               return;
             }
@@ -915,7 +923,15 @@ export function useThreadActions({
                   workspacePathLookup,
                   allowedWorkspaceIds,
                 );
-                return workspaceId === workspace.id;
+                if (workspaceId !== workspace.id) {
+                  return false;
+                }
+                const threadId = String(thread?.id ?? "");
+                if (threadId && shouldHideSubagentThreadFromSidebar(thread.source)) {
+                  dispatch({ type: "hideThread", workspaceId, threadId });
+                  return false;
+                }
+                return true;
               },
             ),
           );

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

@@ -174,7 +174,7 @@ describe("useThreadTurnEvents", () => {
     expect(safeMessageActivity).not.toHaveBeenCalled();
   });
 
-  it("ignores parentless subagent thread started events without hiding them", () => {
+  it("hides memory consolidation thread started events", () => {
     const { result, dispatch, recordThreadActivity, safeMessageActivity } =
       makeOptions();
 
@@ -194,13 +194,11 @@ describe("useThreadTurnEvents", () => {
         threadId: "thread-subagent-orphan",
       }),
     );
-    expect(dispatch).not.toHaveBeenCalledWith(
-      expect.objectContaining({
-        type: "hideThread",
-        workspaceId: "ws-1",
-        threadId: "thread-subagent-orphan",
-      }),
-    );
+    expect(dispatch).toHaveBeenCalledWith({
+      type: "hideThread",
+      workspaceId: "ws-1",
+      threadId: "thread-subagent-orphan",
+    });
     expect(recordThreadActivity).not.toHaveBeenCalled();
     expect(safeMessageActivity).not.toHaveBeenCalled();
   });

src/features/threads/hooks/useThreadTurnEvents.ts

@@ -13,6 +13,7 @@ import { looksAutoGeneratedThreadName } from "@threads/utils/threadNaming";
 import {
   getParentThreadIdFromThread,
   isSubagentThreadSource,
+  shouldHideSubagentThreadFromSidebar,
 } from "@threads/utils/threadRpc";
 import type { ThreadAction } from "./useThreadsReducer";
 
@@ -121,6 +122,10 @@ export function useThreadTurnEvents({
       if (isThreadHidden(workspaceId, threadId)) {
         return;
       }
+      if (shouldHideSubagentThreadFromSidebar(thread.source)) {
+        dispatch({ type: "hideThread", workspaceId, threadId });
+        return;
+      }
       const sourceParentId = getParentThreadIdFromThread(thread);
       if (isSubagentThreadSource(thread.source) && !sourceParentId) {
         // Some thread/started payloads omit parent metadata initially.
@@ -242,7 +247,13 @@ export function useThreadTurnEvents({
         setActiveTurnId(threadId, turnId);
       }
     },
-    [dispatch, getActiveTurnId, markProcessing, pendingInterruptsRef, setActiveTurnId],
+    [
+      dispatch,
+      getActiveTurnId,
+      markProcessing,
+      pendingInterruptsRef,
+      setActiveTurnId,
+    ],
   );
 
   const onTurnCompleted = useCallback(

src/features/threads/utils/threadRpc.test.ts

@@ -4,6 +4,7 @@ import {
   getResumedActiveTurnId,
   getResumedTurnState,
   isSubagentThreadSource,
+  shouldHideSubagentThreadFromSidebar,
 } from "./threadRpc";
 
 describe("threadRpc", () => {
@@ -127,4 +128,20 @@ describe("threadRpc", () => {
     expect(isSubagentThreadSource("vscode")).toBe(false);
     expect(isSubagentThreadSource({})).toBe(false);
   });
+
+  it("hides only memory consolidation subagents from sidebar", () => {
+    expect(
+      shouldHideSubagentThreadFromSidebar({ subagent: "memory_consolidation" }),
+    ).toBe(true);
+    expect(
+      shouldHideSubagentThreadFromSidebar({ subAgent: { memory_consolidation: true } }),
+    ).toBe(true);
+    expect(shouldHideSubagentThreadFromSidebar("subagent_memory_consolidation")).toBe(
+      true,
+    );
+    expect(shouldHideSubagentThreadFromSidebar({ subAgent: { review: true } })).toBe(
+      false,
+    );
+    expect(shouldHideSubagentThreadFromSidebar("subagent_review")).toBe(false);
+  });
 });

src/features/threads/utils/threadRpc.ts

@@ -1,12 +1,72 @@
 import { asString } from "./threadNormalize";
 
+const SIDEBAR_HIDDEN_SUBAGENT_KINDS = new Set(["memory_consolidation"]);
+
 function asRecord(value: unknown): Record<string, unknown> | null {
   if (!value || typeof value !== "object") {
     return null;
   }
   return value as Record<string, unknown>;
 }
 
+function normalizeSubagentKind(value: string): string {
+  const normalized = value
+    .trim()
+    .toLowerCase()
+    .replace(/[\s-]/g, "_");
+  if (normalized.startsWith("subagent_")) {
+    return normalized.slice("subagent_".length);
+  }
+  if (normalized.startsWith("sub_agent_")) {
+    return normalized.slice("sub_agent_".length);
+  }
+  return normalized;
+}
+
+function getSubagentKind(source: unknown): string | null {
+  if (typeof source === "string") {
+    const normalized = normalizeSubagentKind(source);
+    return normalized || null;
+  }
+
+  const sourceRecord = asRecord(source);
+  if (!sourceRecord) {
+    return null;
+  }
+
+  const subAgentRaw =
+    sourceRecord.subAgent ?? sourceRecord.sub_agent ?? sourceRecord.subagent;
+  if (typeof subAgentRaw === "string") {
+    const normalized = normalizeSubagentKind(subAgentRaw);
+    return normalized || null;
+  }
+
+  const subAgentRecord = asRecord(subAgentRaw);
+  if (!subAgentRecord) {
+    return null;
+  }
+
+  const explicitKind = asString(
+    subAgentRecord.kind ??
+      subAgentRecord.type ??
+      subAgentRecord.name ??
+      subAgentRecord.id,
+  );
+  if (explicitKind) {
+    const normalized = normalizeSubagentKind(explicitKind);
+    return normalized || null;
+  }
+
+  const candidateKeys = Object.keys(subAgentRecord).filter(
+    (key) => key !== "thread_spawn" && key !== "threadSpawn",
+  );
+  if (candidateKeys.length !== 1) {
+    return null;
+  }
+  const normalized = normalizeSubagentKind(candidateKeys[0] ?? "");
+  return normalized || null;
+}
+
 export function isSubagentThreadSource(source: unknown): boolean {
   if (typeof source === "string") {
     const normalized = source.trim().toLowerCase();
@@ -29,6 +89,14 @@ export function isSubagentThreadSource(source: unknown): boolean {
   return typeof subAgent === "object";
 }
 
+export function shouldHideSubagentThreadFromSidebar(source: unknown): boolean {
+  const subagentKind = getSubagentKind(source);
+  if (!subagentKind) {
+    return false;
+  }
+  return SIDEBAR_HIDDEN_SUBAGENT_KINDS.has(subagentKind);
+}
+
 export function getParentThreadIdFromSource(source: unknown): string | null {
   const sourceRecord = asRecord(source);
   if (!sourceRecord) {