fix: isolate project CTO from mobile rosters

apps/ade-cli/src/services/push/attentionItemBuilder.ts

@@ -106,14 +106,8 @@ export type PushPrNotification = {
   repoName?: string | null;
 };
 
-/**
- * A roster chat as the publisher reads it. `identityKey` is an additive label
- * rosterBuilder stamps on CTO/identity chats. It stays optional so any roster
- * provider that never sets it still satisfies this contract — the sync roster
- * keeps carrying identity rows for the mobile hub, and only this feed drops
- * them, mirroring what the desktop sidebar already does.
- */
-export type ActivityRosterChat = SyncRosterChat & { identityKey?: string | null };
+/** A roster chat as the publisher reads it; identity rows are filtered upstream. */
+export type ActivityRosterChat = SyncRosterChat;
 export type ActivityRosterProject = Omit<SyncRosterProject, "chats"> & {
   chats: ActivityRosterChat[];
 };

apps/ade-cli/src/services/sync/rosterBuilder.test.ts

@@ -359,10 +359,7 @@ describe("buildRosterSnapshot", () => {
     expect(projects[0]!.runningCount).toBe(0);
   });
 
-  it("labels CTO/identity chats without dropping them from the roster", async () => {
-    // The mobile hub consumes this roster and renders identity chats, so the
-    // roster must keep the rows. It only labels them; excluding them is the
-    // Activity publisher's job (see pushPublisherService).
+  it("excludes CTO/identity chats from the roster and its counts", async () => {
     // Disk path: the persisted sidecar is the only identity signal available
     // for an un-booted project.
     fs.writeFileSync(
@@ -371,19 +368,18 @@ describe("buildRosterSnapshot", () => {
     );
     const fromDisk = await buildRosterSnapshot({ projectRegistry, scopeRegistry: unbootedScopes });
     const diskRow = fromDisk[0]!.chats.find((chat) => chat.id === "chat-run");
-    expect(diskRow).toBeDefined();
-    expect((diskRow as { identityKey?: string | null } | undefined)?.identityKey).toBe("cto");
+    expect(diskRow).toBeUndefined();
+    expect(fromDisk[0]!.chats.find((chat) => chat.id === "cli-end")).toBeUndefined();
+    expect(fromDisk[0]!.attentionCount).toBe(1);
 
     // Booted path: the live summary carries identityKey directly.
     const scopeRegistry = bootedScopes([
       { sessionId: "chat-await", status: "active", identityKey: "cto" },
     ]);
     const fromLive = await buildRosterSnapshot({ projectRegistry, scopeRegistry, hostProjectId: PROJECT_ID });
     const liveRow = fromLive[0]!.chats.find((chat) => chat.id === "chat-await");
-    expect(liveRow).toBeDefined();
-    expect((liveRow as { identityKey?: string | null } | undefined)?.identityKey).toBe("cto");
-    // Hub behaviour is unchanged: an awaiting identity chat still badges.
-    expect(fromLive[0]!.attentionCount).toBe(1);
+    expect(liveRow).toBeUndefined();
+    expect(fromLive[0]!.attentionCount).toBe(0);
   });
 
   it("leaves ordinary chats unlabelled", async () => {

apps/ade-cli/src/services/sync/rosterBuilder.ts

@@ -66,27 +66,20 @@ export type RosterLiveSession = {
    */
   activeBackgroundTaskCount?: number | null;
   /**
-   * Set on CTO/identity chats. The roster still carries these rows — the mobile
-   * hub renders them — but the Activity feed must not, because the desktop
-   * sidebar strips them and the two counts have to agree. The roster's job is
-   * only to label them; see `RosterChat.identityKey`.
+   * Set on CTO/identity chats. Identity sessions are deliberately omitted from
+   * the normal project roster, but this marker remains available as a
+   * defensive signal for older or alternate roster producers.
    */
   identityKey?: string | null;
 };
 
-/**
- * A roster chat plus the additive `identityKey` label. Deliberately NOT folded
- * into the shared `SyncRosterChat` wire type: this is a hint for one consumer
- * (the Activity publisher, which excludes identity chats from the feed), and
- * every other consumer — the mobile hub above all — keeps rendering the rows
- * exactly as before and simply ignores the extra field.
- */
-export type RosterChat = SyncRosterChat & { identityKey?: string | null };
+/** A roster chat with the optional identity marker retained for compatibility. */
+export type RosterChat = SyncRosterChat;
 
 export type RosterAgentChatService = {
   listSessions(
     laneId?: string,
-    options?: { includeArchived?: boolean },
+    options?: { includeArchived?: boolean; includeIdentity?: boolean },
   ): Promise<RosterLiveSession[]>;
 };
 
@@ -452,7 +445,7 @@ async function buildRosterProject(
     if (agentChatService) {
       booted = true;
       const liveSessions = await agentChatService
-        .listSessions(undefined, { includeArchived: false })
+        .listSessions(undefined, { includeArchived: false, includeIdentity: true })
         .catch(() => [] as RosterLiveSession[]);
       for (const live of liveSessions) {
         if (live?.sessionId) liveBySessionId.set(live.sessionId, live);
@@ -467,13 +460,39 @@ async function buildRosterProject(
     .sort(compareLanes);
   const visibleLaneIds = new Set(visibleLanes.map((lane) => lane.id));
 
+  const visibleRows = desktopVisibleRosterRows(disk.chats, visibleLaneIds);
+  const identitySessionIds = new Set<string>();
+  for (const row of visibleRows) {
+    const liveIdentityKey = liveBySessionId.get(row.id)?.identityKey?.trim() || null;
+    const diskIdentityKey = readChatSidecar(chatSessionsDir, row.id)?.identityKey?.trim() || null;
+    if (liveIdentityKey || diskIdentityKey) identitySessionIds.add(row.id);
+  }
+  let identityDescendantAdded = true;
+  while (identityDescendantAdded) {
+    identityDescendantAdded = false;
+    for (const row of visibleRows) {
+      const parentSessionId = normalizedParentSessionId(row);
+      if (parentSessionId
+        && identitySessionIds.has(parentSessionId)
+        && !identitySessionIds.has(row.id)) {
+        identitySessionIds.add(row.id);
+        identityDescendantAdded = true;
+      }
+    }
+  }
+
   const chats: RosterChat[] = [];
   let runningCount = 0;
   let attentionCount = 0;
-  for (const row of desktopVisibleRosterRows(disk.chats, visibleLaneIds)) {
+  for (const row of visibleRows) {
     const live = liveBySessionId.get(row.id);
     const sidecar = readChatSidecar(chatSessionsDir, row.id);
-    const identityKey = live?.identityKey ?? sidecar?.identityKey ?? null;
+    const identityKey = (live?.identityKey ?? sidecar?.identityKey ?? null)
+      ?.trim() || null;
+    // CTO/identity sessions have their own surface and attention path. They
+    // must never become ordinary project-roster rows or contribute to Hub
+    // counts, even when their sidecar is the only identity signal available.
+    if (identitySessionIds.has(row.id)) continue;
     // CLI (terminal) sessions never appear in agentChatService; on a booted
     // scope their liveness comes from the PTY table instead.
     const hasLivePty = livePtyService?.hasLivePty(row.id) === true;

apps/ade-cli/src/services/sync/syncRemoteCommandService.test.ts

@@ -1834,6 +1834,24 @@ describe("createSyncRemoteCommandService", () => {
     ]);
   });
 
+  it("forwards identity-aware chat roster reads to the chat service", async () => {
+    const listSessions = vi.fn().mockResolvedValue([{ id: "chat-1", identityKey: "project-cto" }]);
+    const { service } = createService({ agentChatService: { listSessions } });
+
+    await expect(service.execute(makePayload("chat.listSessions", {
+      laneId: " lane-1 ",
+      includeAutomation: true,
+      includeArchived: false,
+      includeIdentity: true,
+    }))).resolves.toEqual([{ id: "chat-1", identityKey: "project-cto" }]);
+
+    expect(listSessions).toHaveBeenCalledWith("lane-1", {
+      includeAutomation: true,
+      includeArchived: false,
+      includeIdentity: true,
+    });
+  });
+
   it("routes work.getSession through session enrichment and chat state projection", async () => {
     const session = { id: "session-1", status: "running", toolType: "codex-chat", ptyId: "pty-1" };
     const enrichedSession = { ...session, runtimeState: "running" };

apps/ade-cli/src/services/sync/syncRemoteCommandService.ts

@@ -2358,6 +2358,7 @@ function parseAgentChatListArgs(value: Record<string, unknown>): AgentChatListAr
     ...(asTrimmedString(value.laneId) ? { laneId: asTrimmedString(value.laneId)! } : {}),
     includeAutomation: asOptionalBoolean(value.includeAutomation),
     includeArchived: asOptionalBoolean(value.includeArchived),
+    includeIdentity: asOptionalBoolean(value.includeIdentity),
   };
 }
 
@@ -4451,6 +4452,7 @@ function registerChatRemoteCommands({ args, register }: RemoteCommandRegistratio
     return agentChatService.listSessions(parsed.laneId, {
       includeAutomation: parsed.includeAutomation,
       includeArchived: parsed.includeArchived,
+      includeIdentity: parsed.includeIdentity,
     });
   });
   register("chat.getSummary", { viewerAllowed: true }, async (payload) =>

apps/desktop/src/main/services/ipc/registerIpc.ts

@@ -7558,12 +7558,16 @@ export function registerIpc({
       return [];
     }
     const laneId = typeof arg?.laneId === "string" ? arg.laneId.trim() : "";
+    const listOptions = {
+      includeAutomation: Boolean(arg?.includeAutomation),
+      ...(arg?.includeIdentity === true ? { includeIdentity: true } : {}),
+    };
     return await (service as unknown as {
       listSessions: (
         laneId?: string,
-        options?: { includeAutomation?: boolean },
+        options?: { includeAutomation?: boolean; includeIdentity?: boolean },
       ) => Promise<AgentChatSessionSummary[]>;
-    }).listSessions(laneId || undefined, { includeAutomation: Boolean(arg?.includeAutomation) });
+    }).listSessions(laneId || undefined, listOptions);
   });
 
   ipcMain.handle(IPC.agentChatGetSummary, async (_event, arg: AgentChatGetSummaryArgs): Promise<AgentChatSessionSummary | null> => {

apps/desktop/src/preload/preload.ts

@@ -6135,7 +6135,10 @@ contextBridge.exposeInMainWorld("ade", {
       >("chat", "listSessions", {
         argsList: [
           args.laneId,
-          { includeAutomation: args.includeAutomation === true },
+          {
+            includeAutomation: args.includeAutomation === true,
+            includeIdentity: args.includeIdentity === true,
+          },
         ],
       });
       return runtime.handled

apps/desktop/src/renderer/lib/agentChatSessionListCache.test.ts

@@ -66,6 +66,23 @@ describe("agentChatSessionListCache", () => {
     expect(list).toHaveBeenCalledTimes(1);
   });
 
+  it("keeps identity-aware reads separate from the ordinary chat cache", async () => {
+    const list = vi.mocked(window.ade.agentChat.list);
+    list
+      .mockResolvedValueOnce([session("ordinary-session")])
+      .mockResolvedValueOnce([session("cto-session")]);
+
+    await expect(
+      listAgentChatSessionsCached({ laneId: "lane-1", includeIdentity: false }),
+    ).resolves.toEqual([session("ordinary-session")]);
+    await expect(
+      listAgentChatSessionsCached({ laneId: "lane-1", includeIdentity: true }),
+    ).resolves.toEqual([session("cto-session")]);
+
+    expect(list).toHaveBeenNthCalledWith(1, { laneId: "lane-1", includeIdentity: false });
+    expect(list).toHaveBeenNthCalledWith(2, { laneId: "lane-1", includeIdentity: true });
+  });
+
   it("lets a forced refresh supersede an in-flight read without stale cache overwrite", async () => {
     let resolveFirst: (rows: AgentChatSessionSummary[]) => void = () => {};
     const firstPending = new Promise<AgentChatSessionSummary[]>((resolve) => {

apps/desktop/src/renderer/lib/agentChatSessionListCache.ts

@@ -22,6 +22,7 @@ function normalizeArgs(args?: AgentChatListArgs): AgentChatListArgs {
   if (args?.laneId?.trim()) normalized.laneId = args.laneId.trim();
   if (typeof args?.includeAutomation === "boolean") normalized.includeAutomation = args.includeAutomation;
   if (typeof args?.includeArchived === "boolean") normalized.includeArchived = args.includeArchived;
+  if (typeof args?.includeIdentity === "boolean") normalized.includeIdentity = args.includeIdentity;
   return normalized;
 }
 
@@ -34,6 +35,7 @@ function cacheKey(args?: AgentChatListArgs): string {
     laneId: normalized.laneId ?? null,
     includeAutomation: normalized.includeAutomation ?? null,
     includeArchived: normalized.includeArchived ?? null,
+    includeIdentity: normalized.includeIdentity ?? null,
   });
 }
 

apps/desktop/src/shared/types/chat.ts

@@ -2413,6 +2413,8 @@ export type AgentChatListArgs = {
   laneId?: string;
   includeAutomation?: boolean;
   includeArchived?: boolean;
+  /** Include identity-bound sessions for dedicated surfaces such as CTO. */
+  includeIdentity?: boolean;
 };
 
 export type AgentChatSuggestLaneNameArgs = {

apps/desktop/src/shared/types/sync.ts

@@ -788,6 +788,11 @@ export type SyncRosterChat = {
   laneId: string;
   /** Parent chat/session id for attached shell rows. Mirrors TerminalSessionSummary.chatSessionId. */
   chatSessionId?: string | null;
+  /**
+   * Identity-session marker used to reject stale/legacy roster rows on clients.
+   * Current hosts omit identity sessions from the normal roster entirely.
+   */
+  identityKey?: string | null;
   title?: string | null;
   provider?: string | null;
   model?: string | null;