fix(tarko-agent-ui): enhance agent status monitoring after websocket removal

- Reduce status check cache TTL from 2s to 1s for more responsive updates
- Add session-specific processing state updates to prevent cross-session interference
- Implement enhanced status monitoring with different frequencies for processing vs idle states
- Add status consistency checks after send/abort operations
- Improve error handling to prevent UI state inconsistencies
- Add debug logging for agent run start/end events

Author: ulivz

multimodal/tarko/agent-ui/src/common/hooks/useSession.ts

@@ -59,7 +59,9 @@ export function useSession() {
   const checkSessionStatus = useSetAtom(checkSessionStatusAction);
 
   const statusCheckTimeoutRef = useRef<NodeJS.Timeout | null>(null);
+  const statusCheckIntervalRef = useRef<NodeJS.Timeout | null>(null);
 
+  // Initial status check when session changes
   useEffect(() => {
     if (!activeSessionId || !connectionStatus.connected || isReplayMode) return;
 
@@ -80,6 +82,40 @@ export function useSession() {
     };
   }, [activeSessionId, connectionStatus.connected, checkSessionStatus, isReplayMode]);
 
+  // Enhanced status monitoring when processing
+  useEffect(() => {
+    if (!activeSessionId || !connectionStatus.connected || isReplayMode) {
+      if (statusCheckIntervalRef.current) {
+        clearInterval(statusCheckIntervalRef.current);
+        statusCheckIntervalRef.current = null;
+      }
+      return;
+    }
+
+    if (isProcessing) {
+      // More frequent checks when processing (every 500ms)
+      statusCheckIntervalRef.current = setInterval(() => {
+        if (activeSessionId && connectionStatus.connected && !isReplayMode) {
+          checkSessionStatus(activeSessionId);
+        }
+      }, 500);
+    } else {
+      // Less frequent checks when idle (every 3 seconds)
+      statusCheckIntervalRef.current = setInterval(() => {
+        if (activeSessionId && connectionStatus.connected && !isReplayMode) {
+          checkSessionStatus(activeSessionId);
+        }
+      }, 3000);
+    }
+
+    return () => {
+      if (statusCheckIntervalRef.current) {
+        clearInterval(statusCheckIntervalRef.current);
+        statusCheckIntervalRef.current = null;
+      }
+    };
+  }, [activeSessionId, connectionStatus.connected, isReplayMode, isProcessing, checkSessionStatus]);
+
   const sessionState = useMemo(
     () => ({
       sessions,

multimodal/tarko/agent-ui/src/common/state/actions/eventProcessors/handlers/AgentRunHandler.ts

@@ -1,4 +1,5 @@
 import { isProcessingAtom } from '@/common/state/atoms/ui';
+import { activeSessionIdAtom } from '@/common/state/atoms/session';
 import { AgentEventStream } from '@/common/types';
 import { EventHandler, EventHandlerContext } from '../types';
 import { shouldUpdateProcessingState } from '../utils/panelContentUpdater';
@@ -13,11 +14,13 @@ export class AgentRunStartHandler implements EventHandler<AgentEventStream.Agent
     sessionId: string,
     event: AgentEventStream.AgentRunStartEvent,
   ): void {
-    const { set } = context;
+    const { get, set } = context;
 
-    // Update processing state
-    if (shouldUpdateProcessingState(sessionId)) {
+    // Only update processing state for the active session
+    const activeSessionId = get(activeSessionIdAtom);
+    if (shouldUpdateProcessingState(sessionId) && sessionId === activeSessionId) {
       set(isProcessingAtom, true);
+      console.debug(`Agent run started for session ${sessionId}`);
     }
   }
 }
@@ -28,11 +31,13 @@ export class AgentRunEndHandler implements EventHandler<AgentEventStream.Event>
   }
 
   handle(context: EventHandlerContext, sessionId: string, event: AgentEventStream.Event): void {
-    const { set } = context;
+    const { get, set } = context;
 
-    // Update processing state
-    if (shouldUpdateProcessingState(sessionId)) {
+    // Only update processing state for the active session
+    const activeSessionId = get(activeSessionIdAtom);
+    if (shouldUpdateProcessingState(sessionId) && sessionId === activeSessionId) {
       set(isProcessingAtom, false);
+      console.debug(`Agent run ended for session ${sessionId}`);
     }
   }
 }

multimodal/tarko/agent-ui/src/common/state/actions/sessionActions.ts

@@ -371,6 +371,14 @@ export const sendMessageAction = atom(
       console.error('Error sending message:', error);
       // Set processing to false on error
       set(isProcessingAtom, false);
+
+      // Trigger a status check to ensure state consistency
+      setTimeout(() => {
+        if (get(activeSessionIdAtom) === activeSessionId) {
+          set(checkSessionStatusAction, activeSessionId);
+        }
+      }, 100);
+
       throw error;
     }
   },
@@ -391,18 +399,33 @@ export const abortQueryAction = atom(null, async (get, set) => {
       set(isProcessingAtom, false);
     }
 
+    // Always check status after abort attempt to ensure consistency
+    setTimeout(() => {
+      if (get(activeSessionIdAtom) === activeSessionId) {
+        set(checkSessionStatusAction, activeSessionId);
+      }
+    }, 100);
+
     return success;
   } catch (error) {
     console.error('Error aborting query:', error);
     // Also set processing to false on error to ensure UI consistency
     set(isProcessingAtom, false);
+
+    // Check status even on error to ensure consistency
+    setTimeout(() => {
+      if (get(activeSessionIdAtom) === activeSessionId) {
+        set(checkSessionStatusAction, activeSessionId);
+      }
+    }, 100);
+
     return false;
   }
 });
 
 // Cache to prevent frequent status checks for the same session
 const statusCheckCache = new Map<string, { timestamp: number; promise?: Promise<any> }>();
-const STATUS_CACHE_TTL = 2000; // 2 seconds cache
+const STATUS_CACHE_TTL = 1000; // Reduced to 1 second cache for more responsive updates
 
 export const checkSessionStatusAction = atom(null, async (get, set, sessionId: string) => {
   if (!sessionId) return;
@@ -429,8 +452,11 @@ export const checkSessionStatusAction = atom(null, async (get, set, sessionId: s
 
     const status = await promise;
 
-    // Update simple processing state
-    set(isProcessingAtom, status.isProcessing);
+    // Only update processing state if this is the active session
+    const activeSessionId = get(activeSessionIdAtom);
+    if (sessionId === activeSessionId) {
+      set(isProcessingAtom, status.isProcessing);
+    }
 
     // Clear the promise and update timestamp
     statusCheckCache.set(sessionId, { timestamp: now });
@@ -440,5 +466,7 @@ export const checkSessionStatusAction = atom(null, async (get, set, sessionId: s
     console.error('Failed to check session status:', error);
     // Clear the failed request
     statusCheckCache.delete(sessionId);
+    // Don't throw to prevent breaking the UI
+    return null;
   }
 });