feat: support multiple branches per repo and display actual checked-out branch

Implements the remaining functionality from the git repo context feature:

1. **Fix 2nd branch checkout issue (Runner)**:
   - Modified `clone_repo_at_runtime()` in main.py to handle branch switching
   - When repo already exists, now fetches and checks out the requested branch
   - Previously skipped clone entirely if repo directory existed

2. **Add /repos/status endpoint (Runner)**:
   - New GET endpoint to query actual checked-out branches
   - Returns list of repos with current branch info from git
   - Used by operator to sync actual state to status

3. **Fetch and store current branch (Operator)**:
   - Added `fetchActualBranchesFromRunner()` helper function
   - Calls runner's /repos/status endpoint during reconciliation
   - Updates status.reconciledRepos with both intended and actual branch
   - New field: `currentBranch` alongside existing `branch` field

4. **Display actual branch (Frontend)**:
   - Updated RepositoriesAccordion to support `currentBranch` field
   - Changed data source from spec.repos to status.reconciledRepos
   - Badge now shows actual checked-out branch from runner

**User Impact**:
- Can now add same repo with different branches as context
- Context Modal displays the actual checked-out branch
- Runner properly switches branches when user adds 2nd branch
- System maintains both intended (spec) and actual (status) branch info

Fixes the issue described in PR ambient-code#498 where adding a 2nd branch for the
same repo would show in UI but not actually checkout in the runner pod.

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

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: sallyom

components/frontend/src/app/projects/[name]/sessions/[sessionName]/components/accordions/repositories-accordion.tsx

@@ -9,6 +9,7 @@ import { Button } from "@/components/ui/button";
 type Repository = {
   url: string;
   branch?: string;
+  currentBranch?: string; // Actual checked-out branch from status
 };
 
 type UploadedFile = {
@@ -104,9 +105,13 @@ export function RepositoriesAccordion({
                     <div className="flex-1 min-w-0">
                       <div className="flex items-center gap-2">
                         <div className="text-sm font-medium truncate">{repoName}</div>
-                        {repo.branch && (
-                          <Badge variant="outline" className="text-xs px-1.5 py-0 h-5 flex-shrink-0">
-                            {repo.branch}
+                        {/* Show current branch (actual checked-out) or fallback to intended branch */}
+                        {(repo.currentBranch || repo.branch) && (
+                          <Badge
+                            variant="outline"
+                            className="text-xs px-1.5 py-0 h-5 flex-shrink-0"
+                          >
+                            {repo.currentBranch || repo.branch}
                           </Badge>
                         )}
                       </div>

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

@@ -1552,7 +1552,7 @@ export default function ProjectSessionDetailPage({
                     />
 
                     <RepositoriesAccordion
-                      repositories={session?.spec?.repos || []}
+                      repositories={session?.status?.reconciledRepos || session?.spec?.repos || []}
                       uploadedFiles={fileUploadsList.map((f) => ({
                         name: f.name,
                         path: f.path,

components/operator/internal/handlers/sessions.go

@@ -1552,14 +1552,26 @@ func reconcileSpecReposWithPatch(sessionNamespace, sessionName string, spec map[
 		}
 	}
 
+	// Fetch actual current branch info from runner
+	actualBranches := fetchActualBranchesFromRunner(runnerBaseURL)
+
 	// Update status to reflect the reconciled state (via statusPatch)
 	reconciled := make([]interface{}, 0, len(specRepos))
 	for _, repo := range specRepos {
+		repoName := deriveRepoNameFromURL(repo["url"])
+
+		// Get actual current branch from runner if available
+		currentBranch := repo["branch"] // Default to spec branch
+		if actualInfo, found := actualBranches[repoName]; found {
+			currentBranch = actualInfo.CurrentBranch
+		}
+
 		reconciled = append(reconciled, map[string]interface{}{
-			"url":      repo["url"],
-			"branch":   repo["branch"],
-			"status":   "Ready",
-			"clonedAt": time.Now().UTC().Format(time.RFC3339),
+			"url":           repo["url"],
+			"branch":        repo["branch"],        // Intended branch from spec
+			"currentBranch": currentBranch,         // Actual checked-out branch
+			"status":        "Ready",
+			"clonedAt":      time.Now().UTC().Format(time.RFC3339),
 		})
 	}
 	statusPatch.SetField("reconciledRepos", reconciled)
@@ -2230,6 +2242,66 @@ func deleteAmbientLangfuseSecret(ctx context.Context, namespace string) error {
 // LEGACY: getBackendAPIURL removed - AG-UI migration
 // Workflow and repo changes now call runner's REST endpoints directly
 
+// RepoStatusInfo holds the current branch information for a repository
+type RepoStatusInfo struct {
+	Name          string
+	CurrentBranch string
+	URL           string
+}
+
+// fetchActualBranchesFromRunner queries the runner's /repos/status endpoint
+// to get the actual checked-out branch for each repository
+func fetchActualBranchesFromRunner(runnerBaseURL string) map[string]RepoStatusInfo {
+	result := make(map[string]RepoStatusInfo)
+
+	// Call runner's /repos/status endpoint
+	req, err := http.NewRequest("GET", runnerBaseURL+"/repos/status", nil)
+	if err != nil {
+		log.Printf("[RepoStatus] Failed to create request: %v", err)
+		return result
+	}
+
+	client := &http.Client{Timeout: 5 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("[RepoStatus] Failed to fetch from runner: %v", err)
+		return result
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		log.Printf("[RepoStatus] Runner returned %d for /repos/status", resp.StatusCode)
+		return result
+	}
+
+	// Parse response
+	var statusResp struct {
+		Repos []struct {
+			Name          string `json:"name"`
+			CurrentBranch string `json:"currentBranch"`
+			URL           string `json:"url"`
+		} `json:"repos"`
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	if err := json.Unmarshal(body, &statusResp); err != nil {
+		log.Printf("[RepoStatus] Failed to parse response: %v", err)
+		return result
+	}
+
+	// Index by repo name for quick lookup
+	for _, repo := range statusResp.Repos {
+		result[repo.Name] = RepoStatusInfo{
+			Name:          repo.Name,
+			CurrentBranch: repo.CurrentBranch,
+			URL:           repo.URL,
+		}
+	}
+
+	log.Printf("[RepoStatus] Fetched status for %d repos", len(result))
+	return result
+}
+
 // deriveRepoNameFromURL extracts the repository name from a git URL
 func deriveRepoNameFromURL(repoURL string) string {
 	// Remove .git suffix

components/runners/claude-code-runner/main.py

@@ -575,11 +575,41 @@ async def clone_repo_at_runtime(git_url: str, branch: str, name: str) -> tuple[b
     repo_final = repos_dir / name
 
     logger.info(f"Cloning repo '{name}' from {git_url}@{branch}")
-    
-    # Skip if already cloned
+
+    # If repo already exists, check out the requested branch instead of skipping
     if repo_final.exists():
-        logger.info(f"Repo '{name}' already exists at {repo_final}, skipping clone")
-        return True, str(repo_final)
+        logger.info(f"Repo '{name}' already exists at {repo_final}, checking out branch '{branch}'")
+        try:
+            # Fetch the latest changes first (in case branch doesn't exist locally)
+            process = await asyncio.create_subprocess_exec(
+                "git", "-C", str(repo_final), "fetch", "origin", branch,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await process.communicate()
+
+            if process.returncode != 0:
+                logger.warning(f"Failed to fetch branch {branch}: {stderr.decode()}")
+
+            # Checkout the requested branch
+            process = await asyncio.create_subprocess_exec(
+                "git", "-C", str(repo_final), "checkout", branch,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await process.communicate()
+
+            if process.returncode != 0:
+                error_msg = stderr.decode()
+                logger.error(f"Failed to checkout branch {branch}: {error_msg}")
+                return False, ""
+
+            logger.info(f"Successfully checked out branch '{branch}' in {repo_final}")
+            return True, str(repo_final)
+
+        except Exception as e:
+            logger.error(f"Error checking out branch: {e}")
+            return False, ""
 
     # Create temp directory for clone
     temp_dir = Path(tempfile.mkdtemp(prefix="repo-clone-"))
@@ -819,39 +849,103 @@ async def trigger_repo_added_notification(repo_name: str, repo_url: str):
 async def remove_repo(request: Request):
     """
     Remove repository - triggers Claude SDK client restart.
-    
+
     Accepts: {"name": "..."}
     """
     global _adapter_initialized
-    
+
     if not adapter:
         raise HTTPException(status_code=503, detail="Adapter not initialized")
-    
+
     body = await request.json()
     repo_name = body.get("name", "")
     logger.info(f"Remove repo request: {repo_name}")
-    
+
     # Update REPOS_JSON env var
     repos_json = os.getenv("REPOS_JSON", "[]")
     try:
         repos = json.loads(repos_json) if repos_json else []
     except:
         repos = []
-    
+
     # Remove repo by name
     repos = [r for r in repos if r.get("name") != repo_name]
-    
+
     os.environ["REPOS_JSON"] = json.dumps(repos)
-    
+
     # Reset adapter state
     _adapter_initialized = False
     adapter._first_run = True
-    
+
     logger.info(f"Repo removed, adapter will reinitialize on next run")
-    
+
     return {"message": "Repository removed"}
 
 
+@app.get("/repos/status")
+async def get_repos_status():
+    """
+    Get status of all checked-out repositories including actual current branch.
+
+    Returns:
+        List of repositories with their current branch information
+    """
+    from pathlib import Path
+
+    workspace_path = os.getenv("WORKSPACE_PATH", "/workspace")
+    repos_dir = Path(workspace_path) / "repos"
+
+    if not repos_dir.exists():
+        return {"repos": []}
+
+    repos_status = []
+
+    # Iterate through all directories in repos/
+    for repo_path in repos_dir.iterdir():
+        if not repo_path.is_dir():
+            continue
+
+        # Check if it's a git repository
+        git_dir = repo_path / ".git"
+        if not git_dir.exists():
+            continue
+
+        try:
+            # Get current branch name
+            process = await asyncio.create_subprocess_exec(
+                "git", "-C", str(repo_path), "rev-parse", "--abbrev-ref", "HEAD",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE
+            )
+            stdout, stderr = await process.communicate()
+
+            if process.returncode == 0:
+                current_branch = stdout.decode().strip()
+
+                # Get remote URL
+                process = await asyncio.create_subprocess_exec(
+                    "git", "-C", str(repo_path), "config", "--get", "remote.origin.url",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                stdout, stderr = await process.communicate()
+                remote_url = stdout.decode().strip() if process.returncode == 0 else ""
+
+                repos_status.append({
+                    "name": repo_path.name,
+                    "path": str(repo_path),
+                    "currentBranch": current_branch,
+                    "url": remote_url
+                })
+            else:
+                logger.warning(f"Failed to get branch for {repo_path.name}: {stderr.decode()}")
+
+        except Exception as e:
+            logger.error(f"Error getting status for {repo_path.name}: {e}")
+
+    return {"repos": repos_status}
+
+
 @app.get("/health")
 async def health():
     """Health check endpoint."""