Merge pull request #3289 from bobleer/bob/fix-draft-session-status

fix(web-ui): avoid unavailable status on new session drafts

Author: bobleer

src/web-ui/src/flow_chat/services/sessionNavStatusService.test.ts

@@ -114,6 +114,41 @@ const install = (...ids: string[]) => {
 };
 
 describe('navigation status synchronization', () => {
+  it.each(['editing', 'creating'] as const)(
+    'does not query persisted activity for an unmaterialized %s draft', async phase => {
+      const id = `draft-${phase}`;
+      sources.sessions.set(id, { ...row(id), historyState: 'new', isHistorical: false,
+        draft: { phase, workspaceId: 'workspace-1', turnId: 'first-turn' } });
+      sources.read.mockResolvedValue(response([]));
+      install(id);
+      await vi.advanceTimersByTimeAsync(60_000);
+      window.dispatchEvent(new Event('focus'));
+      await vi.advanceTimersByTimeAsync(100);
+      expect(sources.read).not.toHaveBeenCalled();
+      expect(sessionNavStatusService.getSnapshot(id).kind).toBe('idle');
+    },
+  );
+
+  it('starts activity synchronization as soon as a draft is materialized in its chosen workspace', async () => {
+    const id = 'materialized-draft';
+    const draft: Session = { ...row(id), historyState: 'new', isHistorical: false,
+      draft: { phase: 'creating', workspaceId: 'chosen-workspace', turnId: 'first-turn' } };
+    sources.sessions.set(id, draft);
+    sources.read.mockResolvedValue(response([activity(id, 'idle')]));
+    install(id);
+    await vi.advanceTimersByTimeAsync(100);
+    sources.sessions.set(id, { ...draft, workspaceId: 'chosen-workspace',
+      projectWorkspaceId: 'chosen-project', draft: { ...draft.draft!, phase: 'ready' } });
+    sources.storeListeners.forEach(listener => listener({ sessions: sources.sessions }));
+    await vi.advanceTimersByTimeAsync(100);
+    expect(sources.read).toHaveBeenCalledExactlyOnceWith({
+      sessionId: id, workspaceId: 'chosen-project', limit: 1, sessionIds: [id],
+    });
+    expect(sessionNavStatusService.getSnapshot(id).kind).toBe('idle');
+    sources.events.get('onDialogTurnStarted')!({ sessionId: id, turnId: 'first-turn' });
+    expect(sessionNavStatusService.getSnapshot(id).kind).toBe('running');
+  });
+
   it('keeps a local submission running across a host read that predates host acceptance', async () => {
     const id = 'local-start-race';
     const pending = { id: 'new-turn', status: 'pending', modelRounds: [] } as unknown as Session['dialogTurns'][number];

src/web-ui/src/flow_chat/services/sessionNavStatusService.ts

@@ -11,6 +11,7 @@ import { SessionExecutionState } from '../state-machine/types';
 import { driverForSession, sessionDriverNavigationStatusSources } from '../session-drivers/registry';
 import { deriveSessionNavStatus, type SessionNavStatus } from '../utils/sessionNavStatus';
 import { SessionNavOrdering } from '../utils/sessionNavOrdering';
+import { isUnmaterializedSessionDraft } from '../utils/sessionDraft';
 import type { Session } from '../types/flow-chat';
 import { ensureActivePermissionMailbox, liveSessionInteractionStore } from './liveSessionInteractionStore';
 import { SessionActivitySync, type ActivityTarget } from './sessionActivitySync';
@@ -80,7 +81,9 @@ function publish(sessionId: string): void {
 
 function targetFor(sessionId: string): ActivityTarget | undefined {
   const session = flowChatStore.getState().sessions.get(sessionId);
-  if (!session || session.isTransient || session.config.dispatchJobId) return;
+  // Draft IDs are reserved by the view before the host has a persisted Session.
+  // An absent activity during editing/creation is expected, not a failed read.
+  if (!session || session.isTransient || session.config.dispatchJobId || isUnmaterializedSessionDraft(session)) return;
   const workspaceId = session.projectWorkspaceId || session.workspaceId || session.config.workspaceId;
   if (!workspaceId) return;
   return { sessionId, workspaceId };
@@ -205,7 +208,9 @@ export function installSessionNavStatusService(): () => void {
       if (prior?.needsUserAttention !== session?.needsUserAttention) {
         sessionActivityStore.invalidate(sessionId);
       }
-      if (!prior && session) refresh(sessionId);
+      if (!prior || (isUnmaterializedSessionDraft(prior) && !isUnmaterializedSessionDraft(session))) {
+        refresh(sessionId);
+      }
     }
   }));
   const machineTurns = new Map<string, string>();