feat: real-time repo status polling and shorter session names

Architecture changes:
- Frontend now polls runner directly via backend API for real-time branch info
- Removed operator polling of runner (was never working)
- Session names changed from 'agentic-session-{timestamp}' to 'ambient-{xxxx}'

Backend:
- Added GetReposStatus handler that proxies runner's /repos/status endpoint
- New route: GET /repos/status returns real-time git branch information

Frontend:
- Added getReposStatus API function and useReposStatus hook
- 30-second polling for real-time branch updates
- Updated page.tsx to use real-time status for File Explorer and Context Modal
- Branch badges now update within 30 seconds of git changes

Operator:
- Simplified repo reconciliation (no more polling runner for branch info)
- Shortened session name format to ambient-{last-4-digits}

Benefits:
- Branch badges update in ~30 seconds (previously never worked)
- No truncation of repo names (shorter branch names)
- Less operator overhead
- More responsive UI

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <[email protected]>

Author: sallyom

components/backend/handlers/sessions.go

@@ -555,7 +555,7 @@ func CreateSession(c *gin.Context) {
 
 	// Generate unique name
 	timestamp := time.Now().Unix()
-	name := fmt.Sprintf("agentic-session-%d", timestamp)
+	name := fmt.Sprintf("ambient-%d", timestamp%10000)
 
 	// Create the custom resource
 	// Metadata
@@ -3069,6 +3069,58 @@ func DiffSessionRepo(c *gin.Context) {
 	c.Data(resp.StatusCode, resp.Header.Get("Content-Type"), bodyBytes)
 }
 
+// GetReposStatus returns current status of all repositories (branches, current branch, etc.)
+// GET /api/projects/:projectName/agentic-sessions/:sessionName/repos/status
+func GetReposStatus(c *gin.Context) {
+	project := c.Param("projectName")
+	session := c.Param("sessionName")
+
+	k8sClt, _ := GetK8sClientsForRequest(c)
+	if k8sClt == nil {
+		c.JSON(http.StatusUnauthorized, gin.H{"error": "Invalid or missing token"})
+		c.Abort()
+		return
+	}
+
+	// Call runner's /repos/status endpoint directly
+	runnerURL := fmt.Sprintf("http://session-%s.%s.svc.cluster.local:8000/repos/status", session, project)
+
+	req, err := http.NewRequestWithContext(c.Request.Context(), http.MethodGet, runnerURL, nil)
+	if err != nil {
+		log.Printf("GetReposStatus: failed to create HTTP request: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create request"})
+		return
+	}
+	if v := c.GetHeader("Authorization"); v != "" {
+		req.Header.Set("Authorization", v)
+	}
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("GetReposStatus: runner not reachable: %v", err)
+		// Return empty repos list instead of error for better UX
+		c.JSON(http.StatusOK, gin.H{"repos": []interface{}{}})
+		return
+	}
+	defer resp.Body.Close()
+
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Printf("GetReposStatus: failed to read response body: %v", err)
+		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to read response from runner"})
+		return
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		log.Printf("GetReposStatus: runner returned status %d", resp.StatusCode)
+		c.JSON(http.StatusOK, gin.H{"repos": []interface{}{}})
+		return
+	}
+
+	c.Data(http.StatusOK, "application/json", bodyBytes)
+}
+
 // GetGitStatus returns git status for a directory in the workspace
 // GET /api/projects/:projectName/agentic-sessions/:sessionName/git/status?path=artifacts
 func GetGitStatus(c *gin.Context) {

components/backend/routes.go

@@ -66,6 +66,7 @@ func registerRoutes(r *gin.Engine) {
 			projectGroup.GET("/agentic-sessions/:sessionName/workflow/metadata", handlers.GetWorkflowMetadata)
 			projectGroup.POST("/agentic-sessions/:sessionName/repos", handlers.AddRepo)
 			projectGroup.DELETE("/agentic-sessions/:sessionName/repos/:repoName", handlers.RemoveRepo)
+			projectGroup.GET("/agentic-sessions/:sessionName/repos/status", handlers.GetReposStatus)
 			projectGroup.PUT("/agentic-sessions/:sessionName/displayname", handlers.UpdateSessionDisplayName)
 
 			// OAuth integration - requires user auth like all other session endpoints

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

@@ -81,6 +81,7 @@ import {
   useStopSession,
   useDeleteSession,
   useContinueSession,
+  useReposStatus,
 } from "@/services/queries";
 import {
   useWorkspaceList,
@@ -190,6 +191,13 @@ export default function ProjectSessionDetailPage({
   // Extract phase for sidebar state management
   const phase = session?.status?.phase || "Pending";
 
+  // Fetch repos status directly from runner (real-time branch info)
+  const { data: reposStatus } = useReposStatus(
+    projectName,
+    sessionName,
+    phase === "Running" // Only poll when session is running
+  );
+
   // AG-UI streaming hook - replaces useSessionMessages and useSendChatMessage
   // Note: autoConnect is intentionally false to avoid SSR hydration mismatch
   // Connection is triggered manually in useEffect after client hydration
@@ -605,9 +613,8 @@ export default function ProjectSessionDetailPage({
       { type: "file-uploads", name: "File Uploads", path: "file-uploads" },
     ];
 
-    // Use reconciledRepos when available (contains current active branch info),
-    // otherwise fall back to spec.repos
-    const reposToDisplay = session?.status?.reconciledRepos || session?.spec?.repos || [];
+    // Use real-time repos status from runner when available, otherwise fall back to CR status
+    const reposToDisplay = reposStatus?.repos || session?.status?.reconciledRepos || session?.spec?.repos || [];
 
     // Deduplicate repos by name - only show one entry per repo directory
     const seenRepos = new Set<string>();
@@ -642,7 +649,7 @@ export default function ProjectSessionDetailPage({
     }
 
     return options;
-  }, [session, workflowManagement.activeWorkflow]);
+  }, [session, workflowManagement.activeWorkflow, reposStatus]);
 
   // Workflow change handler
   const handleWorkflowChange = (value: string) => {
@@ -1544,7 +1551,7 @@ export default function ProjectSessionDetailPage({
                     />
 
                     <RepositoriesAccordion
-                      repositories={session?.status?.reconciledRepos || session?.spec?.repos || []}
+                      repositories={reposStatus?.repos || session?.status?.reconciledRepos || session?.spec?.repos || []}
                       uploadedFiles={fileUploadsList.map((f) => ({
                         name: f.name,
                         path: f.path,
@@ -1644,10 +1651,13 @@ export default function ProjectSessionDetailPage({
                               </SelectTrigger>
                               <SelectContent>
                                 {directoryOptions.map((opt) => {
-                                  // Find branch info for repo directories
+                                  // Find branch info for repo directories from real-time status
                                   let branchName: string | undefined;
                                   if (opt.type === "repo") {
-                                    const repo = session?.status?.reconciledRepos?.find(
+                                    // Try real-time repos status first, then fall back to CR status
+                                    const repo = reposStatus?.repos?.find(
+                                      (r) => r.name === opt.path
+                                    ) || session?.status?.reconciledRepos?.find(
                                       (r: ReconciledRepo) => {
                                         const repoName = r.name || r.url?.split("/").pop()?.replace(".git", "");
                                         return opt.path === repoName;

components/frontend/src/services/api/sessions.ts

@@ -221,3 +221,28 @@ export async function getMcpStatus(
     `/projects/${projectName}/agentic-sessions/${sessionName}/mcp/status`
   );
 }
+
+export type RepoStatus = {
+  url: string;
+  name: string;
+  branches: string[];
+  currentActiveBranch: string;
+  defaultBranch: string;
+};
+
+export type ReposStatusResponse = {
+  repos: RepoStatus[];
+};
+
+/**
+ * Get current status of all repositories (branches, current branch, etc.)
+ * Fetches directly from runner for real-time updates
+ */
+export async function getReposStatus(
+  projectName: string,
+  sessionName: string
+): Promise<ReposStatusResponse> {
+  return apiClient.get<ReposStatusResponse>(
+    `/projects/${projectName}/agentic-sessions/${sessionName}/repos/status`
+  );
+}

components/frontend/src/services/queries/use-sessions.ts

@@ -27,6 +27,8 @@ export const sessionKeys = {
     [...sessionKeys.detail(projectName, sessionName), 'messages'] as const,
   export: (projectName: string, sessionName: string) =>
     [...sessionKeys.detail(projectName, sessionName), 'export'] as const,
+  reposStatus: (projectName: string, sessionName: string) =>
+    [...sessionKeys.detail(projectName, sessionName), 'repos-status'] as const,
 };
 
 /**
@@ -322,3 +324,17 @@ export function useSessionExport(projectName: string, sessionName: string, enabl
     staleTime: 60000, // Cache for 1 minute
   });
 }
+
+/**
+ * Hook to fetch repository status (branches, current branch) from runner
+ * Polls every 30 seconds for real-time updates
+ */
+export function useReposStatus(projectName: string, sessionName: string, enabled: boolean = true) {
+  return useQuery({
+    queryKey: sessionKeys.reposStatus(projectName, sessionName),
+    queryFn: () => sessionsApi.getReposStatus(projectName, sessionName),
+    enabled: enabled && !!projectName && !!sessionName,
+    refetchInterval: 30000, // Poll every 30 seconds
+    staleTime: 25000, // Consider stale after 25 seconds
+  });
+}

components/operator/internal/handlers/sessions.go

@@ -1606,51 +1606,17 @@ func reconcileSpecReposWithPatch(sessionNamespace, sessionName string, spec map[
 		}
 	}
 
-	// Poll runner for actual repository status (branches, currentActiveBranch, etc.)
-	// Note: This may return empty if runner is not ready or repos are still being cloned
-	actualRepos := pollRunnerReposStatus(runnerBaseURL)
-
-	// Update status to reflect the reconciled state with actual filesystem data
+	// Build simple reconciled status (frontend now polls runner directly for real-time branch info)
 	reconciled := make([]interface{}, 0, len(specRepos))
 	for _, repo := range specRepos {
 		repoName := deriveRepoNameFromURL(repo["url"])
-
-		// Find matching actual repo status from runner
-		var actualRepo map[string]interface{}
-		for _, actual := range actualRepos {
-			if actualName, ok := actual["name"].(string); ok && actualName == repoName {
-				actualRepo = actual
-				break
-			}
-		}
-
-		// Build reconciled entry with actual data if available
 		reconciledEntry := map[string]interface{}{
 			"url":      repo["url"],
 			"name":     repoName,
 			"branch":   repo["branch"], // Intended branch from spec (deprecated)
 			"clonedAt": time.Now().UTC().Format(time.RFC3339),
+			"status":   "Ready", // Simplified - frontend polls runner for detailed status
 		}
-
-		// Set status based on whether we have actual repo data
-		if actualRepo != nil {
-			reconciledEntry["status"] = "Ready"
-			// Add actual branch information from runner
-			if branches, ok := actualRepo["branches"].([]interface{}); ok {
-				reconciledEntry["branches"] = branches
-			}
-			if currentBranch, ok := actualRepo["currentActiveBranch"].(string); ok {
-				reconciledEntry["currentActiveBranch"] = currentBranch
-			}
-			if defaultBranch, ok := actualRepo["defaultBranch"].(string); ok {
-				reconciledEntry["defaultBranch"] = defaultBranch
-			}
-		} else {
-			// Repo not found in runner status - may still be cloning
-			reconciledEntry["status"] = "Cloning"
-			log.Printf("[Reconcile] Repo '%s' not found in runner status, marking as Cloning", repoName)
-		}
-
 		reconciled = append(reconciled, reconciledEntry)
 	}
 	statusPatch.SetField("reconciledRepos", reconciled)
@@ -2335,39 +2301,8 @@ func deriveRepoNameFromURL(repoURL string) string {
 	return "repo"
 }
 
-// pollRunnerReposStatus queries the runner's /repos/status endpoint to get actual filesystem state.
-// Returns array of repo status objects with branches, currentActiveBranch, defaultBranch.
-func pollRunnerReposStatus(runnerBaseURL string) []map[string]interface{} {
-	req, err := http.NewRequest("GET", runnerBaseURL+"/repos/status", nil)
-	if err != nil {
-		log.Printf("[PollRepos] Failed to create request: %v", err)
-		return []map[string]interface{}{}
-	}
-
-	client := &http.Client{Timeout: 5 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		log.Printf("[PollRepos] Failed to poll runner: %v", err)
-		return []map[string]interface{}{}
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode != http.StatusOK {
-		log.Printf("[PollRepos] Runner returned status %d", resp.StatusCode)
-		return []map[string]interface{}{}
-	}
-
-	var result struct {
-		Repos []map[string]interface{} `json:"repos"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
-		log.Printf("[PollRepos] Failed to decode response: %v", err)
-		return []map[string]interface{}{}
-	}
-
-	log.Printf("[PollRepos] Successfully polled %d repos from runner", len(result.Repos))
-	return result.Repos
-}
+// pollRunnerReposStatus removed - frontend now polls runner directly via backend API
+// for real-time branch information. Operator no longer needs to maintain this in CR status.
 
 // regenerateRunnerToken provisions a fresh ServiceAccount, Role, RoleBinding, and token Secret for a session.
 // This is called when restarting sessions to ensure fresh tokens.