fix: derive agentStatus from event log and fix AskUserQuestion UI

- Derive agentStatus at query time from persisted event log instead of
  caching on the CR (eliminates goroutine race condition)
- Fix useAgentStatus hook to read raw AG-UI PlatformMessage format
  instead of processed ToolUseMessages (fixes detail page status)
- Emit TOOL_CALL_RESULT on next run for halted AskUserQuestion tool
  calls so frontend marks questions as answered
- Remove agentStatus field from CRD and CR update logic
- Remove animate-pulse from Running dot and waiting_input badge
- Add AgentStatus constants to types/agui.go

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Gkrumbach07

Makefile

@@ -734,9 +734,9 @@ kind-port-forward: check-kubectl check-local-context ## Port-forward kind servic
 	@echo ""
 	@echo "$(COLOR_YELLOW)Press Ctrl+C to stop$(COLOR_RESET)"
 	@echo ""
-	@trap 'echo ""; echo "$(COLOR_GREEN)✓$(COLOR_RESET) Port forwarding stopped"; exit 0' INT; \
-	(kubectl port-forward -n ambient-code svc/frontend-service $(KIND_FWD_FRONTEND_PORT):3000 >/dev/null 2>&1 &); \
-	(kubectl port-forward -n ambient-code svc/backend-service $(KIND_FWD_BACKEND_PORT):8080 >/dev/null 2>&1 &); \
+	@trap 'kill 0; echo ""; echo "$(COLOR_GREEN)✓$(COLOR_RESET) Port forwarding stopped"; exit 0' INT; \
+	kubectl port-forward -n ambient-code svc/frontend-service $(KIND_FWD_FRONTEND_PORT):3000 >/dev/null 2>&1 & \
+	kubectl port-forward -n ambient-code svc/backend-service $(KIND_FWD_BACKEND_PORT):8080 >/dev/null 2>&1 & \
 	wait
 
 dev-bootstrap: check-kubectl check-local-context ## Bootstrap developer workspace with API key and integrations

components/backend/handlers/sessions.go

@@ -41,6 +41,9 @@ var (
 	GetGitHubToken                    func(context.Context, kubernetes.Interface, dynamic.Interface, string, string) (string, error)
 	GetGitLabToken                    func(context.Context, kubernetes.Interface, string, string) (string, error)
 	DeriveRepoFolderFromURL           func(string) string
+	// DeriveAgentStatusFromEvents derives agentStatus from the persisted event log.
+	// Set by the websocket package at init to avoid circular imports.
+	DeriveAgentStatusFromEvents func(sessionID string) string
 	// LEGACY: SendMessageToSession removed - AG-UI server uses HTTP/SSE instead of WebSocket
 )
 
@@ -245,10 +248,6 @@ func parseStatus(status map[string]interface{}) *types.AgenticSessionStatus {
 		result.LastActivityTime = types.StringPtr(lastActivityTime)
 	}
 
-	if agentStatus, ok := status["agentStatus"].(string); ok && agentStatus != "" {
-		result.AgentStatus = types.StringPtr(agentStatus)
-	}
-
 	if stoppedReason, ok := status["stoppedReason"].(string); ok && stoppedReason != "" {
 		result.StoppedReason = types.StringPtr(stoppedReason)
 	}
@@ -365,6 +364,25 @@ func parseStatus(status map[string]interface{}) *types.AgenticSessionStatus {
 
 // V2 API Handlers - Multi-tenant session management
 
+// enrichAgentStatus derives agentStatus from the persisted event log for
+// Running sessions.  This is the source of truth — it replaces the stale
+// CR-cached value which was subject to goroutine race conditions.
+func enrichAgentStatus(session *types.AgenticSession) {
+	if session.Status == nil || session.Status.Phase != "Running" {
+		return
+	}
+	if DeriveAgentStatusFromEvents == nil {
+		return
+	}
+	name, _ := session.Metadata["name"].(string)
+	if name == "" {
+		return
+	}
+	if derived := DeriveAgentStatusFromEvents(name); derived != "" {
+		session.Status.AgentStatus = types.StringPtr(derived)
+	}
+}
+
 func ListSessions(c *gin.Context) {
 	project := c.GetString("project")
 
@@ -418,6 +436,9 @@ func ListSessions(c *gin.Context) {
 			session.Status = parseStatus(status)
 		}
 
+		// Derive agentStatus from event log (source of truth) for running sessions
+		enrichAgentStatus(&session)
+
 		session.AutoBranch = ComputeAutoBranch(item.GetName())
 
 		sessions = append(sessions, session)
@@ -907,6 +928,9 @@ func GetSession(c *gin.Context) {
 		session.Status = parseStatus(status)
 	}
 
+	// Derive agentStatus from event log (source of truth) for running sessions
+	enrichAgentStatus(&session)
+
 	session.AutoBranch = ComputeAutoBranch(sessionName)
 
 	c.JSON(http.StatusOK, session)

components/backend/main.go

@@ -163,6 +163,7 @@ func main() {
 
 	// Initialize websocket package
 	websocket.StateBaseDir = server.StateBaseDir
+	handlers.DeriveAgentStatusFromEvents = websocket.DeriveAgentStatus
 
 	// Normal server mode
 	if err := server.Run(registerRoutes); err != nil {

components/backend/types/agui.go

@@ -69,6 +69,13 @@ const (
 	EventTypeMeta = "META"
 )
 
+// Agent status values derived from the AG-UI event stream.
+const (
+	AgentStatusWorking      = "working"
+	AgentStatusIdle         = "idle"
+	AgentStatusWaitingInput = "waiting_input"
+)
+
 // AG-UI Message Roles
 // See: https://docs.ag-ui.com/concepts/messages
 const (

components/backend/websocket/agui_proxy.go

@@ -32,7 +32,6 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
 	"k8s.io/client-go/kubernetes"
-	"k8s.io/client-go/util/retry"
 )
 
 const (
@@ -448,22 +447,8 @@ func persistStreamedEvent(sessionID, runID, threadID, jsonData string) {
 		}
 	}
 
-	// Update agentStatus on CR for status-changing events (not debounced).
-	if projectName, ok := sessionProjectMap.Load(sessionID); ok {
-		proj := projectName.(string)
-		switch eventType {
-		case types.EventTypeRunStarted:
-			updateAgentStatus(proj, sessionID, "working")
-		case types.EventTypeRunFinished:
-			updateAgentStatus(proj, sessionID, "idle")
-		case types.EventTypeRunError:
-			updateAgentStatus(proj, sessionID, "idle")
-		case types.EventTypeToolCallStart:
-			if toolName, _ := event["toolCallName"].(string); isAskUserQuestionToolCall(toolName) {
-				updateAgentStatus(proj, sessionID, "waiting_input")
-			}
-		}
-	}
+	// agentStatus is derived at query time from the event log (DeriveAgentStatus).
+	// No CR updates needed here — the persisted events ARE the source of truth.
 }
 
 // ─── POST /agui/interrupt ────────────────────────────────────────────
@@ -978,75 +963,3 @@ func isAskUserQuestionToolCall(name string) bool {
 	return clean.String() == "askuserquestion"
 }
 
-// updateAgentStatus updates the agentStatus field on the AgenticSession CR status.
-// Unlike updateLastActivityTime, this is NOT debounced because status changes are
-// infrequent (2-4 per run) and should be reflected immediately.
-// It also updates lastActivityTime in the same CR write to avoid double API calls.
-func updateAgentStatus(projectName, sessionName, newStatus string) {
-	if handlers.DynamicClient == nil {
-		log.Printf("Agent status: DynamicClient is nil, skipping update for %s/%s", projectName, sessionName)
-		return
-	}
-
-	// Bound concurrency: reuse the activity semaphore.
-	select {
-	case activityUpdateSem <- struct{}{}:
-	default:
-		log.Printf("Agent status: semaphore full, dropping update %s for %s/%s", newStatus, projectName, sessionName)
-		return
-	}
-
-	go func() {
-		defer func() { <-activityUpdateSem }()
-
-		gvr := handlers.GetAgenticSessionV1Alpha1Resource()
-		ctx, cancel := context.WithTimeout(context.Background(), activityUpdateTimeout)
-		defer cancel()
-
-		var now time.Time
-		err := retry.RetryOnConflict(retry.DefaultRetry, func() error {
-			obj, err := handlers.DynamicClient.Resource(gvr).Namespace(projectName).Get(ctx, sessionName, metav1.GetOptions{})
-			if err != nil {
-				return err
-			}
-
-			status, found, err := unstructured.NestedMap(obj.Object, "status")
-			if err != nil {
-				log.Printf("Agent status: failed to read nested status for %s/%s: %v", projectName, sessionName, err)
-				return nil // non-retryable
-			}
-			if !found || status == nil {
-				status = make(map[string]any)
-			}
-
-			// Skip RUN_FINISHED → "idle" if current status is "waiting_input".
-			// waiting_input is more informative and should persist until the next RUN_STARTED.
-			if newStatus == "idle" {
-				if current, _ := status["agentStatus"].(string); current == "waiting_input" {
-					return nil
-				}
-			}
-
-			status["agentStatus"] = newStatus
-			// Also update lastActivityTime to avoid a separate API call.
-			now = time.Now()
-			status["lastActivityTime"] = now.UTC().Format(time.RFC3339)
-
-			if err := unstructured.SetNestedField(obj.Object, status, "status"); err != nil {
-				log.Printf("Agent status: failed to set status for %s/%s: %v", projectName, sessionName, err)
-				return nil // non-retryable
-			}
-
-			_, err = handlers.DynamicClient.Resource(gvr).Namespace(projectName).UpdateStatus(ctx, obj, metav1.UpdateOptions{})
-			return err
-		})
-
-		if err != nil {
-			log.Printf("Agent status: failed to update agentStatus to %s for %s/%s: %v", newStatus, projectName, sessionName, err)
-		} else {
-			// Update lastActivity timestamp in the debounce map to avoid redundant activity updates.
-			key := projectName + "/" + sessionName
-			lastActivityUpdateTimes.Store(key, now)
-		}
-	}()
-}

components/backend/websocket/agui_store.go

@@ -194,6 +194,68 @@ func loadEvents(sessionID string) []map[string]interface{} {
 	return events
 }
 
+// DeriveAgentStatus reads a session's event log and returns the agent
+// status derived from the last significant events.
+//
+// Returns "" if the status cannot be determined (no events, file missing, etc.).
+func DeriveAgentStatus(sessionID string) string {
+	path := fmt.Sprintf("%s/sessions/%s/agui-events.jsonl", StateBaseDir, sessionID)
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return ""
+	}
+
+	lines := splitLines(data)
+
+	// Scan backwards.  We only care about lifecycle and AskUserQuestion events.
+	//   RUN_STARTED                       → "working"
+	//   RUN_FINISHED / RUN_ERROR          → "idle", unless same run had AskUserQuestion
+	//   TOOL_CALL_START (AskUserQuestion) → "waiting_input"
+	var runEndRunID string // set when we hit RUN_FINISHED/RUN_ERROR and need to look deeper
+	for i := len(lines) - 1; i >= 0; i-- {
+		if len(lines[i]) == 0 {
+			continue
+		}
+		var evt map[string]interface{}
+		if err := json.Unmarshal(lines[i], &evt); err != nil {
+			continue
+		}
+		evtType, _ := evt["type"].(string)
+
+		switch evtType {
+		case types.EventTypeRunStarted:
+			if runEndRunID != "" {
+				// We were scanning for an AskUserQuestion but hit RUN_STARTED first → idle
+				return types.AgentStatusIdle
+			}
+			return types.AgentStatusWorking
+
+		case types.EventTypeRunFinished, types.EventTypeRunError:
+			if runEndRunID == "" {
+				// First run-end seen; scan deeper within this run for AskUserQuestion
+				runEndRunID, _ = evt["runId"].(string)
+			}
+
+		case types.EventTypeToolCallStart:
+			if runEndRunID != "" {
+				// Only relevant if we're scanning within the ended run
+				if evtRunID, _ := evt["runId"].(string); evtRunID != "" && evtRunID != runEndRunID {
+					return types.AgentStatusIdle
+				}
+			}
+			if toolName, _ := evt["toolCallName"].(string); isAskUserQuestionToolCall(toolName) {
+				return types.AgentStatusWaitingInput
+			}
+		}
+	}
+
+	if runEndRunID != "" {
+		return types.AgentStatusIdle
+	}
+	return ""
+}
+
 // ─── Compaction ──────────────────────────────────────────────────────
 //
 // Go port of @ag-ui/client compactEvents.  Concatenates streaming deltas

components/frontend/src/app/projects/[name]/sessions/[sessionName]/page.tsx

@@ -781,7 +781,7 @@ export default function ProjectSessionDetailPage({
   const agentStatus = useAgentStatus(
     session?.status?.phase || "Pending",
     isRunActive,
-    aguiStream.state.messages as unknown as Array<MessageObject | ToolUseMessages>,
+    aguiStream.state.messages,
   );
 
   // Convert AG-UI messages to display format with hierarchical tool call rendering

components/frontend/src/components/agent-status-indicator.tsx

@@ -44,7 +44,7 @@ export function AgentStatusIndicator({
       return (
         <Badge
           className={cn(
-            "bg-amber-500 hover:bg-amber-500 text-white animate-pulse gap-1",
+            "bg-amber-500 hover:bg-amber-500 text-white gap-1",
             compact && "px-1.5 py-0.5 text-[10px]",
             className
           )}

components/frontend/src/components/session-status-dot.tsx

@@ -25,7 +25,6 @@ const DOT_COLORS: Record<string, string> = {
 };
 
 const DOT_ANIMATIONS: Record<string, string> = {
-  Running: "animate-pulse",
   Creating: "animate-pulse",
   Stopping: "animate-pulse",
 };

components/frontend/src/hooks/use-agent-status.ts

@@ -2,25 +2,24 @@ import { useMemo } from "react";
 import type {
   AgenticSessionPhase,
   AgentStatus,
-  MessageObject,
-  ToolUseMessages,
 } from "@/types/agentic-session";
+import type { PlatformMessage } from "@/types/agui";
 
 function isAskUserQuestionTool(name: string): boolean {
   const normalized = name.toLowerCase().replace(/[^a-z]/g, "");
   return normalized === "askuserquestion";
 }
 
 /**
- * Derive agent status from session data and message stream.
+ * Derive agent status from session data and the raw AG-UI message stream.
  *
  * For the session detail page where the full message stream is available,
  * this provides accurate status including `waiting_input` detection.
  */
 export function useAgentStatus(
   phase: AgenticSessionPhase | string,
   isRunActive: boolean,
-  messages: Array<MessageObject | ToolUseMessages>,
+  messages: PlatformMessage[],
 ): AgentStatus {
   return useMemo(() => {
     // Terminal states from session phase
@@ -31,26 +30,25 @@ export function useAgentStatus(
     // Non-running phases
     if (phase !== "Running") return "idle";
 
-    // Check if the last tool call is an unanswered AskUserQuestion
+    // Scan backwards for the last tool call to check for unanswered AskUserQuestion.
+    // Raw AG-UI messages store tool calls in msg.toolCalls[] (PlatformToolCall[]).
     for (let i = messages.length - 1; i >= 0; i--) {
       const msg = messages[i];
+      if (!msg.toolCalls || msg.toolCalls.length === 0) continue;
 
-      // Skip non-tool messages
-      if (!("toolUseBlock" in msg)) continue;
-
-      const toolMsg = msg as ToolUseMessages;
-      if (isAskUserQuestionTool(toolMsg.toolUseBlock.name)) {
-        // Check if it has a result (answered)
+      // Check the last tool call on this message
+      const lastTc = msg.toolCalls[msg.toolCalls.length - 1];
+      if (isAskUserQuestionTool(lastTc.function.name)) {
         const hasResult =
-          toolMsg.resultBlock?.content !== undefined &&
-          toolMsg.resultBlock?.content !== null &&
-          toolMsg.resultBlock?.content !== "";
+          lastTc.result !== undefined &&
+          lastTc.result !== null &&
+          lastTc.result !== "";
         if (!hasResult) {
           return "waiting_input";
         }
       }
 
-      // Only check the most recent tool call
+      // Only check the most recent message with tool calls
       break;
     }