scope builder sessions to the auth identity

Author: charlesvien

packages/ui/src/features/loops/components/LoopsListView.stories.tsx

@@ -181,11 +181,13 @@ export const WithBuilderSessions: Story = {
         taskId: "builder-task-1",
         prompt: "Summarize my open PRs every weekday morning",
         startedAt: 1752000000000,
+        identity: "us:2",
       },
       {
         taskId: "builder-task-2",
         prompt: "Build a loop",
         startedAt: 1752000600000,
+        identity: "us:2",
       },
     ],
     onResumeBuilderSession: () => {},

packages/ui/src/features/loops/hooks/useLoopBuilderSessions.ts

@@ -1,4 +1,8 @@
 import { useArchivedTaskIds } from "@posthog/ui/features/archive/useArchivedTaskIds";
+import {
+  getAuthIdentity,
+  useAuthStateValue,
+} from "@posthog/ui/features/auth/store";
 import { useTaskSummaries } from "@posthog/ui/features/tasks/useTasks";
 import { useEffect, useMemo, useState } from "react";
 import {
@@ -12,14 +16,24 @@ import {
 } from "../loopBuilderSessionStore";
 
 /**
- * The recorded builder sessions whose cloud run is still alive. Sessions whose
- * sandbox has shut down (run completed, failed, cancelled, or task archived or
- * deleted) are pruned from the persisted store as their status comes in, so the
- * "in progress" list never offers a resume into a dead session. The liveness
- * decision itself is the pure `isBuilderSessionEnded`.
+ * The current identity's builder sessions whose cloud run is still alive.
+ * Sessions whose sandbox has shut down (run completed, failed, cancelled, or
+ * task archived or deleted) are pruned from the persisted store as their status
+ * comes in, so the "in progress" list never offers a resume into a dead
+ * session. Other identities' sessions are never shown or pruned: the summaries
+ * this hook queries are only authoritative for the signed-in account. The
+ * liveness decision itself is the pure `isBuilderSessionEnded`.
  */
 export function useLoopBuilderSessions(): LoopBuilderSession[] {
-  const sessions = useLoopBuilderSessionStore((state) => state.sessions);
+  const identity = useAuthStateValue(getAuthIdentity);
+  const allSessions = useLoopBuilderSessionStore((state) => state.sessions);
+  const sessions = useMemo(
+    () =>
+      identity
+        ? allSessions.filter((session) => session.identity === identity)
+        : [],
+    [allSessions, identity],
+  );
   const archivedTaskIds = useArchivedTaskIds();
   const taskIds = useMemo(
     () => sessions.map((session) => session.taskId),
@@ -58,14 +72,15 @@ export function useLoopBuilderSessions(): LoopBuilderSession[] {
   }, [sessions, now]);
 
   useEffect(() => {
-    if (!summaries) return;
+    if (!summaries || !identity) return;
     const store = useLoopBuilderSessionStore.getState();
     for (const session of store.sessions) {
+      if (session.identity !== identity) continue;
       if (isBuilderSessionEnded(session, summaries, archivedTaskIds, now)) {
         store.removeSession(session.taskId);
       }
     }
-  }, [summaries, archivedTaskIds, now]);
+  }, [summaries, archivedTaskIds, now, identity]);
 
   return useMemo(() => {
     if (!summaries) {

packages/ui/src/features/loops/hooks/useLoopBuilderTask.ts

@@ -1,5 +1,6 @@
 import type { TaskCreationInput } from "@posthog/core/task-detail/taskService";
 import type { Task } from "@posthog/shared/domain-types";
+import { getAuthIdentity, useAuthStore } from "@posthog/ui/features/auth/store";
 import {
   type InboxCloudTaskInputContext,
   useInboxCloudTaskRunner,
@@ -77,10 +78,13 @@ export function useLoopBuilderTask(context?: {
   );
 
   const handleTaskCreated = useCallback((task: Task) => {
+    const identity = getAuthIdentity(useAuthStore.getState().authState);
+    if (!identity) return;
     useLoopBuilderSessionStore.getState().addSession({
       taskId: task.id,
       prompt: instructionsRef.current.trim() || "Build a loop",
       startedAt: Date.now(),
+      identity,
     });
   }, []);
 

packages/ui/src/features/loops/loopBuilderLiveness.test.ts

@@ -9,7 +9,12 @@ import type { LoopBuilderSession } from "./loopBuilderSessionStore";
 const NOW = 1_752_000_000_000;
 
 function session(ageMs: number): LoopBuilderSession {
-  return { taskId: "task-1", prompt: "prompt", startedAt: NOW - ageMs };
+  return {
+    taskId: "task-1",
+    prompt: "prompt",
+    startedAt: NOW - ageMs,
+    identity: "us:1",
+  };
 }
 
 function summaries(

packages/ui/src/features/loops/loopBuilderSessionStore.test.ts

@@ -14,8 +14,12 @@ vi.mock("@posthog/ui/shell/rendererStorage", () => ({
   flushRendererStateWrites: async () => {},
 }));
 
-function session(taskId: string, startedAt = 0): LoopBuilderSession {
-  return { taskId, prompt: `prompt ${taskId}`, startedAt };
+function session(
+  taskId: string,
+  startedAt = 0,
+  identity = "us:1",
+): LoopBuilderSession {
+  return { taskId, prompt: `prompt ${taskId}`, startedAt, identity };
 }
 
 beforeEach(() => {
@@ -35,20 +39,28 @@ it("replaces an existing session with the same task id", () => {
   const store = useLoopBuilderSessionStore.getState();
   store.addSession(session("a", 1));
   store.addSession(session("b", 2));
-  store.addSession({ taskId: "a", prompt: "updated", startedAt: 3 });
+  store.addSession({
+    taskId: "a",
+    prompt: "updated",
+    startedAt: 3,
+    identity: "us:1",
+  });
   const sessions = useLoopBuilderSessionStore.getState().sessions;
   expect(sessions.map((s) => s.taskId)).toEqual(["a", "b"]);
   expect(sessions[0]?.prompt).toBe("updated");
 });
 
-it("caps the list at the max session count", () => {
+it("caps sessions per identity without evicting other identities", () => {
   const store = useLoopBuilderSessionStore.getState();
+  store.addSession(session("other", 0, "eu:2"));
   for (let i = 0; i < MAX_BUILDER_SESSIONS + 2; i++) {
     store.addSession(session(`task-${i}`, i));
   }
   const sessions = useLoopBuilderSessionStore.getState().sessions;
-  expect(sessions).toHaveLength(MAX_BUILDER_SESSIONS);
-  expect(sessions[0]?.taskId).toBe(`task-${MAX_BUILDER_SESSIONS + 1}`);
+  const mine = sessions.filter((s) => s.identity === "us:1");
+  expect(mine).toHaveLength(MAX_BUILDER_SESSIONS);
+  expect(mine[0]?.taskId).toBe(`task-${MAX_BUILDER_SESSIONS + 1}`);
+  expect(sessions.some((s) => s.taskId === "other")).toBe(true);
 });
 
 it.each([

packages/ui/src/features/loops/loopBuilderSessionStore.ts

@@ -9,6 +9,10 @@ export interface LoopBuilderSession {
   taskId: string;
   prompt: string;
   startedAt: number;
+  /** Auth identity (`getAuthIdentity`) the session belongs to. Sessions are
+   * only shown, pruned and capped within their own identity, so prompts never
+   * leak across accounts or projects sharing a device. */
+  identity: string;
 }
 
 export const MAX_BUILDER_SESSIONS = 5;
@@ -26,12 +30,19 @@ export const useLoopBuilderSessionStore = create<LoopBuilderSessionState>()(
       // Flushed immediately: adding is followed by navigating away, and a lost
       // debounced write is exactly the "can't find my builder" bug again.
       addSession: (session) => {
-        set((state) => ({
-          sessions: [
+        set((state) => {
+          const others = state.sessions.filter(
+            (s) => s.identity !== session.identity,
+          );
+          const mine = [
             session,
-            ...state.sessions.filter((s) => s.taskId !== session.taskId),
-          ].slice(0, MAX_BUILDER_SESSIONS),
-        }));
+            ...state.sessions.filter(
+              (s) =>
+                s.identity === session.identity && s.taskId !== session.taskId,
+            ),
+          ].slice(0, MAX_BUILDER_SESSIONS);
+          return { sessions: [...mine, ...others] };
+        });
         void flushRendererStateWrites();
       },
       removeSession: (taskId) => {
@@ -45,6 +56,9 @@ export const useLoopBuilderSessionStore = create<LoopBuilderSessionState>()(
       name: "posthog-code-loop-builder-sessions",
       storage: electronStorage,
       partialize: (state) => ({ sessions: state.sessions }),
+      // v0 entries had no identity and can't be attributed; drop them.
+      version: 1,
+      migrate: () => ({ sessions: [] as LoopBuilderSession[] }),
     },
   ),
 );