Update app.py

app.py

@@ -137,7 +137,7 @@ class WebhookHandler(BaseHTTPRequestHandler):
 
         event = self.headers.get('X-GitHub-Event')
         delivery_id = self.headers.get('X-GitHub-Delivery')
-        logger.info(f"Received GitHub webhook event: {{}event}} (Delivery ID: {{delivery_id}})")
+        logger.info(f"Received GitHub webhook event: {{}event}}  (Delivery ID: {{delivery_id}})")
 
         if event == 'issues' and WebhookHandler.manager_instance and WebhookHandler.main_loop:
             action = payload.get('action')
@@ -158,7 +158,7 @@ class WebhookHandler(BaseHTTPRequestHandler):
         elif event == 'ping':
              logger.info("Received GitHub webhook ping.")
         else:
-            logger.warning(f"Unhandled event type: {{event}} or manager/loop not initialized.")
+            logger.warning(f"Unhandled event type: {{event}}  or manager/loop not initialized.")
 
         self.send_response(200)
         self.send_header("Content-type", "text/plain")
@@ -248,7 +248,7 @@ class IssueManager:
                 break
 
         if not found_issue:
-            logger.error(f"Could not find issue data for hash {{issue_hash}} in current state. Suggestion might be based on outdated info if generated.")
+            logger.error(f"Could not find issue data for hash {{issue_hash}}  in current state. Suggestion might be based on outdated info if generated.")
             return "Error: Issue data for this suggestion request (hash) not found in current state. The issue might have been updated or closed. Please re-select the issue."
 
         if model_key not in HF_MODELS:
@@ -282,7 +282,7 @@ class IssueManager:
         significant_change = False # Flag for changes affecting clustering/content/AI caches
 
         if action == 'closed':
-            logger.info(f"Webhook: Removing closed issue {{issue_number}} from active list.")
+            logger.info(f"Webhook: Removing closed issue {{issue_number}}  from active list.")
             if self.issues.pop(issue_number, None):
                  needs_ui_update = True
                  significant_change = True
@@ -297,7 +297,7 @@ class IssueManager:
             self.code_editors.pop(issue_number, None)
 
         elif action in ['opened', 'reopened', 'edited', 'assigned', 'unassigned', 'labeled', 'unlabeled', 'milestoned', 'demilestoned']:
-             logger.info(f"Webhook: Adding/Updating issue {{issue_number}} (action: {{action}}).")
+             logger.info(f"Webhook: Adding/Updating issue {{issue_number}}  (action: {{action}}).")
              processed_data = self._process_issue_data(issue_data)
 
              old_issue = self.issues.get(issue_number)
@@ -306,7 +306,7 @@ class IssueManager:
                 old_issue.get('title') != processed_data.get('title') or \
                 set(old_issue.get('labels', [])) != set(processed_data.get('labels', [])):
                  significant_change = True
-                 logger.info(f"Significant change detected for issue {{issue_number}} (content/labels).")
+                 logger.info(f"Significant change detected for issue {{issue_number}}  (content/labels).")
                  # Invalidate ALL precomputed AI state on significant edit
                  self.precomputed_context.pop(issue_number, None)
                  self.precomputed_summaries.pop(issue_number, None)
@@ -318,12 +318,12 @@ class IssueManager:
                 old_issue.get('updated_at') != processed_data.get('updated_at') or \
                 old_issue.get('assignee') != processed_data.get('assignee') or \
                 set(old_issue.get('labels', [])) != set(processed_data.get('labels', [])):
-                 logger.debug(f"State-related change detected for issue {{issue_number}} (update time, assignee, labels). Idle loop will re-evaluate.")
+                 logger.debug(f"State-related change detected for issue {{issue_number}}  (update time, assignee, labels). Idle loop will re-evaluate.")
 
              self.issues[issue_number] = processed_data
              needs_ui_update = True
         else:
-             logger.info(f"Ignoring webhook action '{{action}' for issue {{issue_number} (already filtered).")
+             logger.info(f"Ignoring webhook action '{{action}}' for issue {{issue_number}}  (already filtered).")
 
         # --- Track changes for idle processing ---
         if needs_ui_update:
@@ -351,7 +351,7 @@ class IssueManager:
              "body": issue_data.get('body', ''),
              "state": issue_data.get('state', 'unknown'),
              "labels": sorted([label['name'] for label in issue_data.get('labels', [])]),
-             "assignee": issue_data.get('assignee', {{}).get('login') if issue_data.get('assignee') else None,
+             "assignee": issue_data.get('assignee', {}).get('login') if issue_data.get('assignee') else None,
              "url": issue_data.get('html_url', '#'),
              "created_at": issue_data.get('created_at'),
              "updated_at": issue_data.get('updated_at'),
@@ -417,7 +417,7 @@ class IssueManager:
                         remote_url = next((r.url for r in self.repo.remotes.origin.urls), None)
                         expected_urls = [self.repo_url, self.repo_url + ".git"]
                         if remote_url not in expected_urls:
-                             logger.warning(f"Existing repo path {{self.repo_local_path} has different remote URL ('{{remote_url}' vs '{{self.repo_url}'). Re-cloning.")
+                             logger.warning(f"Existing repo path {{self.repo_local_path}} has different remote URL ('{{remote_url}' vs '{{self.repo_url}'). Re-cloning.")
                              shutil.rmtree(self.repo_local_path)
                              self.repo = Repo.clone_from(self.repo_url, self.repo_local_path, progress=lambda op, cur, tot, msg: logger.debug(f"Clone progress: {{msg}}"))
                         else:
@@ -428,7 +428,7 @@ class IssueManager:
                                  logger.info("Repository is shallow, unshallowing...")
                                  self.repo.git.fetch('--unshallow')
                     else:
-                        logger.warning(f"Existing repo at {{self.repo_local_path}} has no remotes defined. Re-cloning.")
+                        logger.warning(f"Existing repo at {{self.repo_local_path}}  has no remotes defined. Re-cloning.")
                         shutil.rmtree(self.repo_local_path)
                         self.repo = Repo.clone_from(self.repo_url, self.repo_local_path, progress=lambda op, cur, tot, msg: logger.debug(f"Clone progress: {{msg}}"))
 
@@ -442,7 +442,7 @@ class IssueManager:
                         try: self.repo = Repo(self.repo_local_path)
                         except Exception: logger.error("Failed to even load existing repo after pull error.")
             else:
-                logger.info(f"Cloning repository {{self.repo_url}} to {{self.repo_local_path}}")
+                logger.info(f"Cloning repository {{self.repo_url}}  to {{self.repo_local_path}}")
                 self.repo = Repo.clone_from(self.repo_url, self.repo_local_path, progress=lambda op, cur, tot, msg: logger.debug(f"Clone progress: {{msg}}"))
 
             logger.info("Repository clone/update process finished.")
@@ -482,7 +482,7 @@ class IssueManager:
                         issues_page_data = await response.json()
                         if not issues_page_data: break
 
-                        logger.info(f"Fetched page {{page}} with {{len(issues_page_data)}} items.")
+                        logger.info(f"Fetched page {{page}}  with {{len(issues_page_data)}}  items.")
                         all_issues_data.extend(issues_page_data)
 
                         link_header = response.headers.get('Link')
@@ -499,7 +499,7 @@ class IssueManager:
                 if 'pull_request' not in issue_data
             }
 
-            logger.info(f"Filtered out pull requests, {{len(self.issues)}} actual open issues remaining.")
+            logger.info(f"Filtered out pull requests, {{len(self.issues)}}  actual open issues remaining.")
 
             empty_fig = go.Figure()
             empty_fig.update_layout(title="Issue Severity Distribution", xaxis={{"visible": False}, yaxis={{"visible": False},
@@ -532,7 +532,7 @@ class IssueManager:
                     if 0 <= index < len(self.issue_list_for_clustering):
                         index_to_cluster_id[index] = cluster_id
                     else:
-                        logger.warning(f"Clustering returned invalid index {{index}} for list of length {{len(self.issue_list_for_clustering)}}")
+                        logger.warning(f"Clustering returned invalid index {{index}}  for list of length {{len(self.issue_list_for_clustering)}}")
 
             for i, issue in enumerate(self.issue_list_for_clustering):
                  severity = self._determine_severity(issue['labels'])
@@ -552,14 +552,14 @@ class IssueManager:
             self.start_broadcast_loop()
             self.start_idle_processing()
 
-            success_msg = f"Found {{len(self.issues)}} open issues. Clustered into {{len(self.issue_clusters)}} groups. Repo ready. Background analysis started."
+            success_msg = f"Found {{len(self.issues)}}  open issues. Clustered into {{len(self.issue_clusters)}}  groups. Repo ready. Background analysis started."
             logger.info(success_msg)
             # Return both plots
             return dataframe_data, stats_fig, success_msg, stats_fig #  Mypy may complain about return type mismatch if not explicitly handled
 
         except aiohttp.ClientResponseError as e:
              logger.error(f"GitHub API request failed: Status={{e.status}, Message='{{e.message}', URL='{{e.request_info.url}'")
-             error_msg = f"Error fetching issues: {{e.status}} - {{e.message}}. Check token/URL."
+             error_msg = f"Error fetching issues: {{e.status}}  - {{e.message}}. Check token/URL."
              if e.status == 404: error_msg = f"Error: Repository not found at {{self.repo_url}}."
              elif e.status == 401: error_msg = "Error: Invalid GitHub token or insufficient permissions for this repository."
              elif e.status == 403:
@@ -628,20 +628,20 @@ class IssueManager:
             return
 
         num_issues = len(self.issue_list_for_clustering)
-        logger.info(f"Generating embeddings for {{num_issues}} issues for clustering...")
+        logger.info(f"Generating embeddings for {{num_issues}}  issues for clustering...")
         try:
             texts_to_embed = [
-                f"Title: {{i.get('title','')} Body: {{i.get('body','')[:1500]}"
+                f"Title: {{i.get('title','')}} Body: {{i.get('body','')[:1500]}"
                 for i in self.issue_list_for_clustering
             ]
             embeddings = await self._generate_embeddings(texts_to_embed)
 
             if embeddings is None or not isinstance(embeddings, list) or len(embeddings) != num_issues:
-                 logger.error(f"Failed to generate valid embeddings for clustering. Expected {{num_issues}, got {{type(embeddings)} len {{len(embeddings) if embeddings else 'N/A'}.")
+                 logger.error(f"Failed to generate valid embeddings for clustering. Expected {{num_issues}, got {{type(embeddings)}} len {{len(embeddings) if embeddings else 'N/A'}.")
                  self.issue_clusters = {{}
                  return
 
-            logger.info(f"Generated {{len(embeddings)}} embeddings. Running HDBSCAN clustering...")
+            logger.info(f"Generated {{len(embeddings)}}  embeddings. Running HDBSCAN clustering...")
             clusterer = HDBSCAN(min_cluster_size=2, metric='cosine', allow_single_cluster=True, gen_min_span_tree=True)
             clusters = clusterer.fit_predict(embeddings)
 
@@ -657,7 +657,7 @@ class IssueManager:
                 new_issue_clusters[cluster_id_int].append(i)
 
             self.issue_clusters = new_issue_clusters
-            logger.info(f"Clustering complete. Found {{len(self.issue_clusters)}} clusters (min size 2) with {{noise_count}} noise points.")
+            logger.info(f"Clustering complete. Found {{len(self.issue_clusters)}}  clusters (min size 2) with {{noise_count}}  noise points.")
 
             # Reset the change counter and flag after successful clustering
             self._webhook_change_count = 0
@@ -680,7 +680,7 @@ class IssueManager:
             for i, issue in enumerate(self.issue_list_for_clustering):
                 issue_id = issue.get('id')
                 if issue_id is None:
-                    logger.warning(f"Issue at index {{i}} in clustering list is missing an ID.")
+                    logger.warning(f"Issue at index {{i}}  in clustering list is missing an ID.")
                     continue
                 index_to_id[i] = issue_id
         except Exception as e:
@@ -694,7 +694,7 @@ class IssueManager:
                     for issue_id in cluster_issue_ids:
                         self.potential_duplicates[issue_id] = [other_id for other_id in cluster_issue_ids if other_id != issue_id]
 
-        logger.info(f"Identified potential duplicates for {{len(self.potential_duplicates)}} issues based on clustering.")
+        logger.info(f"Identified potential duplicates for {{len(self.potential_duplicates)}}  issues based on clustering.")
 
     async def _generate_embeddings(self, texts: List[str]):
         """Generates sentence embeddings using Hugging Face Inference API."""
@@ -710,7 +710,7 @@ class IssueManager:
         headers = {{"Authorization": f"Bearer {{self.hf_token}}"}
         timeout = aiohttp.ClientTimeout(total=180)
 
-        logger.info(f"Requesting embeddings from {{api_url}} for {{len(texts)}} texts.")
+        logger.info(f"Requesting embeddings from {{api_url}}  for {{len(texts)}}  texts.")
         async with aiohttp.ClientSession(headers=headers, timeout=timeout) as session:
             try:
                 payload = {{"inputs": texts, "options": {{"wait_for_model": True}}
@@ -722,7 +722,7 @@ class IssueManager:
 
                     if isinstance(result, list) and all(isinstance(emb, list) and all(isinstance(f, float) for f in emb) for emb in result):
                          if len(result) == len(texts):
-                             logger.info(f"Successfully received {{len(result)}} embeddings of expected dimension.")
+                             logger.info(f"Successfully received {{len(result)}}  embeddings of expected dimension.")
                              return result
                          else:
                              logger.error(f"HF Embedding API returned wrong number of embeddings: Got {{len(result)}}, expected {{len(texts)}}.")
@@ -740,7 +740,7 @@ class IssueManager:
                  logger.error(f"HF Inference API embedding request failed: Status={{e.status}, Message='{{e.message}'. Body: {{error_body[:500]}")
                  return None
             except asyncio.TimeoutError:
-                 logger.error(f"HF Inference API embedding request timed out after {{timeout.total}} seconds.")
+                 logger.error(f"HF Inference API embedding request timed out after {{timeout.total}}  seconds.")
                  return None
             except Exception as e:
                  logger.exception(f"Unexpected error during embedding generation: {{e}}")
@@ -749,7 +749,7 @@ class IssueManager:
     async def generate_code_patch(self, issue_number: int, model_key: str) -> dict:
         """Generates a code patch suggestion using a selected AI model."""
         if issue_number not in self.issues:
-            return {{"error": f"Issue {{issue_number}} not found."}
+            return {{"error": f"Issue {{issue_number}}  not found."}
         if not self.hf_token:
             return {{"error": "Hugging Face token not set."}
         if model_key not in HF_MODELS:
@@ -759,7 +759,7 @@ class IssueManager:
 
         issue = self.issues[issue_number]
         model_id = HF_MODELS[model_key]
-        logger.info(f"Generating patch for issue {{issue_number} ('{{issue.get('title', 'N/A')[:50]}...') using model {{model_id}")
+        logger.info(f"Generating patch for issue {{issue_number}} ('{{issue.get('title', 'N/A')[:50]}...') using model {{model_id}")
 
         # --- Context Gathering ---
         context_str = "Context gathering failed or not available."
@@ -774,11 +774,11 @@ class IssueManager:
             elif context_data.get("content"):
                 context_str = context_data["content"]
                 num_files = len(context_data.get('files',[]))
-                context_source = f"Pre-computed ({{num_files}} files @ {{timestamp_str}})"
+                context_source = f"Pre-computed ({{num_files}}  files @ {{timestamp_str}})"
             else:
                 context_str = "Pre-computed context was empty or unavailable."
                 context_source = f"Pre-computed (Empty @ {{timestamp_str}})"
-            logger.info(f"Using pre-computed context for issue {{issue_number}} (Source: {{context_source}})")
+            logger.info(f"Using pre-computed context for issue {{issue_number}}  (Source: {{context_source}})")
         else:
             logger.info(f"No pre-computed context found for issue {{issue_number}}, computing now.")
             context_source = "Computed On-Demand"
@@ -788,7 +788,7 @@ class IssueManager:
                  context_source += " (Error)"
             else:
                  context_str = context_result.get("content", "No specific context found.")
-                 context_source += f" ({{len(context_result.get('files',[]))} files)"
+                 context_source += f" ({{len(context_result.get('files',[]))}} files)"
                  self.precomputed_context[issue_number] = {{
                      "content": context_str,
                      "files": context_result.get("files", []),
@@ -849,7 +849,7 @@ class IssueManager:
 
                     if result and isinstance(result, list) and 'generated_text' in result[0]:
                         generated_text = result[0].get('generated_text', '').strip()
-                        logger.info(f"Received patch suggestion from {{model_id}} ({{len(generated_text)}} chars).")
+                        logger.info(f"Received patch suggestion from {{model_id}}  ({{len(generated_text)}}  chars).")
 
                         diff_match = re.search(r"```diff\n(.*?)```", generated_text, re.DOTALL | re.IGNORECASE)
                         explanation = generated_text.split("```diff")[0].strip() if diff_match else generated_text
@@ -858,7 +858,7 @@ class IssueManager:
                         if diff_match:
                             patch_content = diff_match.group(1).strip()
                             if not re.search(r'^(--- |\+\+\+ |@@ )', patch_content, re.MULTILINE):
-                                 logger.warning(f"Generated patch for issue {{issue_number}} might lack standard diff headers or spacing.")
+                                 logger.warning(f"Generated patch for issue {{issue_number}}  might lack standard diff headers or spacing.")
                             return {{"explanation": explanation, "patch": patch_content, "model_used": model_id}
                         else:
                             if re.search(r"(insufficient context|cannot generate|unable to create patch|context required)", explanation, re.IGNORECASE):
@@ -874,7 +874,7 @@ class IssueManager:
                         logger.error(f"HF Inference API patch error for issue {{issue_number}}: {{error_msg}}" + (f" (Est: {{estimated_time}}s)" if estimated_time else ""))
                         return {{"error": f"AI model error: {{error_msg}}"}
                     else:
-                        logger.error(f"Unexpected patch response format from {{model_id}} for issue {{issue_number}}: {{str(result)[:500]}}")
+                        logger.error(f"Unexpected patch response format from {{model_id}}  for issue {{issue_number}}: {{str(result)[:500]}}")
                         return {{"error": "Unexpected response format from AI model."}
         except aiohttp.ClientResponseError as e:
             error_body = await e.response.text()
@@ -919,7 +919,7 @@ class IssueManager:
         if not potential_files:
             return {{"content": "No file paths matching common patterns found in the issue title or body.", "files": [], "error": None}
 
-        logger.info(f"Found {{len(potential_files)}} potential file references in issue {{issue_id}}: {{potential_files}}")
+        logger.info(f"Found {{len(potential_files)}}  potential file references in issue {{issue_id}}: {{potential_files}}")
         context_content = ""
         max_context_length = 6000
         files_included = []
@@ -942,13 +942,13 @@ class IssueManager:
                         context_content += content_snippet
                         files_included.append(str(relative_path))
                     else:
-                        logger.warning(f"Skipping file {{relative_path}} for context in issue {{issue_id}} due to total length limit ({{max_context_length}} chars).")
+                        logger.warning(f"Skipping file {{relative_path}}  for context in issue {{issue_id}}  due to total length limit ({{max_context_length}}  chars).")
                         files_skipped_length.append(str(relative_path))
                 except OSError as e:
-                    logger.warning(f"Could not read file {{full_path}} for issue {{issue_id}}: {{e}}")
+                    logger.warning(f"Could not read file {{full_path}}  for issue {{issue_id}}: {{e}}")
                     files_read_error.append(str(relative_path))
                 except Exception as e:
-                    logger.warning(f"Unexpected error reading file {{full_path}} for issue {{issue_id}}: {{e}}")
+                    logger.warning(f"Unexpected error reading file {{full_path}}  for issue {{issue_id}}: {{e}}")
                     files_read_error.append(str(relative_path))
             else:
                 logger.info(f"Potential path '{{relative_path}' (from '{{file_path_str}') not found or not a file in local repo for issue {{issue_id}.")
@@ -958,10 +958,10 @@ class IssueManager:
         error_status = None
         if files_included:
             final_content = context_content.strip()
-            logger.info(f"Included context from {{len(files_included)}} files for issue {{issue_id}}: {{files_included}}")
+            logger.info(f"Included context from {{len(files_included)}}  files for issue {{issue_id}}: {{files_included}}")
         else:
             final_content = "No content could be retrieved from the potential file paths found."
-            logger.warning(f"Context generation for issue {{issue_id}} resulted in no included files.")
+            logger.warning(f"Context generation for issue {{issue_id}}  resulted in no included files.")
             if potential_files: # If paths were found but none included
                  error_status = "No readable or found files among potential paths."
 
@@ -994,7 +994,7 @@ class IssueManager:
 
         model_id = HF_MODELS[model_key]
         issue_id = issue.get('id','N/A')
-        logger.info(f"Requesting resolution suggestion for issue {{issue_id} ('{{issue.get('title', 'N/A')[:50]}...') using {{model_id}")
+        logger.info(f"Requesting resolution suggestion for issue {{issue_id}} ('{{issue.get('title', 'N/A')[:50]}...') using {{model_id}")
 
         # --- Get Pre-computed Info ---
         summary_text = self._get_precomputed_text(issue_id, self.precomputed_summaries, "summary", "Summary")
@@ -1051,7 +1051,7 @@ Based on *all* the information provided above, outline a potential plan:
 
                     if result and isinstance(result, list) and 'generated_text' in result[0]:
                          suggestion = result[0].get('generated_text', 'AI Error: No suggestion text generated.').strip()
-                         logger.info(f"Received suggestion from {{model_id}} for issue {{issue_id}} ({{len(suggestion)}} chars).")
+                         logger.info(f"Received suggestion from {{model_id}}  for issue {{issue_id}}  ({{len(suggestion)}}  chars).")
                          return suggestion
                     elif isinstance(result, dict) and 'error' in result:
                          error_msg = result['error']
@@ -1059,7 +1059,7 @@ Based on *all* the information provided above, outline a potential plan:
                          logger.error(f"HF Inference API suggestion error for issue {{issue_id}}: {{error_msg}}" + (f" (Est: {{estimated_time}}s)" if estimated_time else ""))
                          return f"Error: AI model returned an error: {{error_msg}}"
                     else:
-                         logger.error(f"Unexpected suggestion response format from {{model_id}} for issue {{issue_id}}: {{str(result)[:500]}}")
+                         logger.error(f"Unexpected suggestion response format from {{model_id}}  for issue {{issue_id}}: {{str(result)[:500]}}")
                          return "Error: Received unexpected response format from AI model."
         except aiohttp.ClientResponseError as e:
             error_body = await e.response.text()
@@ -1080,16 +1080,16 @@ Based on *all* the information provided above, outline a potential plan:
             is_recent = time.time() - timestamp < self.idle_processing_interval * 2
 
             if entry.get("error"):
-                return f"{{name} Error (at {{datetime.fromtimestamp(timestamp).strftime('%H:%M:%S')}): {{entry['error']}"
+                return f"{{name}} Error (at {{datetime.fromtimestamp(timestamp).strftime('%H:%M:%S')}): {{entry['error']}"
             elif entry.get(key) is not None: # Check key exists and is not None
                 return entry[key]
             else: # No error, but key might be missing or None
                 if is_recent:
-                    return f"({{name}} computation pending...)"
+                    return f"({{name}}  computation pending...)"
                 else:
-                    return f"({{name}} not computed or result was empty)"
+                    return f"({{name}}  not computed or result was empty)"
         else:
-            return f"({{name}} not computed yet)"
+            return f"({{name}}  not computed yet)"
 
     def _get_duplicate_info_text(self, issue_id: int) -> str:
         """Formats duplicate info text."""
@@ -1120,7 +1120,7 @@ Based on *all* the information provided above, outline a potential plan:
                     try:
                          tasks.append(client.send(status_payload))
                     except (ConnectionClosed, ConnectionAbortedError, ConnectionResetError) as e:
-                         logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)} seems disconnected before send: {{e}. Marking for removal.")
+                         logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)}} seems disconnected before send: {{e}. Marking for removal.")
                          disconnected_clients.append(client)
                     except Exception as e:
                          logger.error(f"Unexpected error preparing send to client {{getattr(client, 'client_id', client.remote_address)}: {{e}. Marking for removal.")
@@ -1140,7 +1140,7 @@ Based on *all* the information provided above, outline a potential plan:
 
                 if disconnected_clients:
                     unique_disconnected = list(set(disconnected_clients))
-                    logger.info(f"Removing {{len(unique_disconnected)}} disconnected clients after broadcast.")
+                    logger.info(f"Removing {{len(unique_disconnected)}}  disconnected clients after broadcast.")
                     for client in unique_disconnected:
                         self.remove_ws_client(client)
 
@@ -1160,16 +1160,16 @@ Based on *all* the information provided above, outline a potential plan:
             logger.warning(f"Received code update for non-existent editor instance for issue {{issue_num}}. Ignoring.")
             return
         if issue_num not in self.issues:
-             logger.warning(f"Received code update for non-existent issue {{issue_num}} in manager. Ignoring.")
+             logger.warning(f"Received code update for non-existent issue {{issue_num}}  in manager. Ignoring.")
              return
 
-        logger.warning(f"Handling code editor update for issue {{issue_num}} from {{sender_client_id}}. "
+        logger.warning(f"Handling code editor update for issue {{issue_num}}  from {{sender_client_id}}. "
                        "WARNING: NO OT IMPLEMENTED - Last write wins / potential conflicts.")
 
         try:
             delta_obj = json.loads(delta_str)
             self.code_editors[issue_num].apply_delta(delta_obj)
-            logger.info(f"Applied delta for issue {{issue_num}} from client {{sender_client_id}} (Placeholder OT Logic - Revision {{self.code_editors[issue_num].revision}})")
+            logger.info(f"Applied delta for issue {{issue_num}}  from client {{sender_client_id}}  (Placeholder OT Logic - Revision {{self.code_editors[issue_num].revision}})")
 
             update_payload = json.dumps({{
                 "type": "code_update",
@@ -1192,7 +1192,7 @@ Based on *all* the information provided above, outline a potential plan:
                      try:
                          tasks.append(client.send(update_payload))
                      except (ConnectionClosed, ConnectionAbortedError, ConnectionResetError) as e:
-                         logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)} seems disconnected before send: {{e}. Marking for removal.")
+                         logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)}} seems disconnected before send: {{e}. Marking for removal.")
                          disconnected_clients.append(client)
                      except Exception as e:
                          logger.error(f"Unexpected error preparing send to client {{getattr(client, 'client_id', client.remote_address)}: {{e}. Marking for removal.")
@@ -1200,7 +1200,7 @@ Based on *all* the information provided above, outline a potential plan:
 
 
             if tasks:
-                 logger.debug(f"Broadcasting code update for issue {{issue_num}} to {{len(tasks)}} other clients.")
+                 logger.debug(f"Broadcasting code update for issue {{issue_num}}  to {{len(tasks)}}  other clients.")
                  results = await asyncio.gather(*tasks, return_exceptions=True)
                  for i, result in enumerate(results):
                      if isinstance(result, Exception):
@@ -1213,14 +1213,14 @@ Based on *all* the information provided above, outline a potential plan:
 
             if disconnected_clients:
                 unique_disconnected = list(set(disconnected_clients))
-                logger.info(f"Removing {{len(unique_disconnected)}} clients after code update broadcast failure.")
+                logger.info(f"Removing {{len(unique_disconnected)}}  clients after code update broadcast failure.")
                 for client in unique_disconnected:
                     if client: self.remove_ws_client(client)
 
         except json.JSONDecodeError:
-            logger.error(f"Received invalid JSON delta for issue {{issue_num}} from {{sender_client_id}}: {{delta_str[:200]}}")
+            logger.error(f"Received invalid JSON delta for issue {{issue_num}}  from {{sender_client_id}}: {{delta_str[:200]}}")
         except Exception as e:
-            logger.exception(f"Error handling code editor update for issue {{issue_num}} from {{sender_client_id}}: {{e}}")
+            logger.exception(f"Error handling code editor update for issue {{issue_num}}  from {{sender_client_id}}: {{e}}")
 
     async def broadcast_issue_update(self):
          """Notifies clients that the issue list/data has changed (e.g., due to webhook)."""
@@ -1240,7 +1240,7 @@ Based on *all* the information provided above, outline a potential plan:
              try:
                  tasks.append(client.send(update_payload))
              except (ConnectionClosed, ConnectionAbortedError, ConnectionResetError) as e:
-                 logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)} seems disconnected before send: {{e}. Marking for removal.")
+                 logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)}} seems disconnected before send: {{e}. Marking for removal.")
                  disconnected_clients.append(client)
              except Exception as e:
                  logger.error(f"Unexpected error preparing send to client {{getattr(client, 'client_id', client.remote_address)}: {{e}. Marking for removal.")
@@ -1260,7 +1260,7 @@ Based on *all* the information provided above, outline a potential plan:
 
          if disconnected_clients:
              unique_disconnected = list(set(disconnected_clients))
-             logger.info(f"Removing {{len(unique_disconnected)}} clients after issue update broadcast.")
+             logger.info(f"Removing {{len(unique_disconnected)}}  clients after issue update broadcast.")
              for client in unique_disconnected:
                  self.remove_ws_client(client)
 
@@ -1268,16 +1268,16 @@ Based on *all* the information provided above, outline a potential plan:
         """Safely removes a client from the list and collaborator dict."""
         client_id = getattr(client_to_remove, 'client_id', None)
         client_addr = client_to_remove.remote_address
-        client_desc = f"{{client_id or 'Unknown ID'} ({{client_addr})"
+        client_desc = f"{{client_id or 'Unknown ID'}} ({{client_addr})"
         removed_from_list = False
         removed_from_collab = False
 
         try:
             self.ws_clients.remove(client_to_remove)
             removed_from_list = True
-            logger.info(f"Removed WebSocket client from list: {{client_desc}} (Remaining: {{len(self.ws_clients)}})")
+            logger.info(f"Removed WebSocket client from list: {{client_desc}}  (Remaining: {{len(self.ws_clients)}})")
         except ValueError:
-            logger.debug(f"Client {{client_desc}} already removed from list or not found.")
+            logger.debug(f"Client {{client_desc}}  already removed from list or not found.")
             pass
 
         if client_id and client_id in self.collaborators:
@@ -1302,7 +1302,7 @@ Based on *all* the information provided above, outline a potential plan:
                  try:
                      tasks.append(client.send(status_payload))
                  except (ConnectionClosed, ConnectionAbortedError, ConnectionResetError) as e:
-                     logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)} seems disconnected before send: {{e}. Marking for removal.")
+                     logger.warning(f"Client {{getattr(client, 'client_id', client.remote_address)}} seems disconnected before send: {{e}. Marking for removal.")
                      disconnected_clients.append(client)
                  except Exception as e:
                      logger.error(f"Unexpected error preparing send to client {{getattr(client, 'client_id', client.remote_address)}: {{e}. Marking for removal.")
@@ -1324,7 +1324,7 @@ Based on *all* the information provided above, outline a potential plan:
 
          if disconnected_clients:
              unique_disconnected = list(set(disconnected_clients))
-             logger.info(f"Removing {{len(unique_disconnected)}} clients found disconnected during single broadcast.")
+             logger.info(f"Removing {{len(unique_disconnected)}}  clients found disconnected during single broadcast.")
              for client in unique_disconnected:
                  self.remove_ws_client(client)
 
@@ -1343,7 +1343,7 @@ Based on *all* the information provided above, outline a potential plan:
                         self.stale_issues.append(issue_id)
                 except (ValueError, TypeError) as e:
                     logger.warning(f"Could not parse 'updated_at' ('{{updated_at_str}') for issue {{issue_id}: {{e}")
-        logger.info(f"Identified {{len(self.stale_issues)}} potentially stale issues (updated > {{self.stale_issue_threshold_days}} days ago).")
+        logger.info(f"Identified {{len(self.stale_issues)}}  potentially stale issues (updated > {{self.stale_issue_threshold_days}}  days ago).")
 
     def _identify_high_priority_candidates(self):
         """Identifies high-priority issues (e.g., Critical/High severity)."""
@@ -1352,7 +1352,7 @@ Based on *all* the information provided above, outline a potential plan:
             severity = self._determine_severity(issue_data.get('labels', []))
             if severity in ["Critical", "High"]:
                  self.high_priority_candidates.append(issue_id)
-        logger.info(f"Identified {{len(self.high_priority_candidates)}} high-priority candidates (Critical/High severity).")
+        logger.info(f"Identified {{len(self.high_priority_candidates)}}  high-priority candidates (Critical/High severity).")
 
     async def _compute_and_store_summary(self, issue_id: int):
         """Generates and stores a summary for a given issue using an LLM (Idle Task)."""
@@ -1366,7 +1366,7 @@ Based on *all* the information provided above, outline a potential plan:
         try:
             issue = self.issues[issue_id]
             model_id = DEFAULT_IDLE_MODEL_ID # Use designated idle model
-            logger.info(f"Idle Task: Generating summary for issue {{issue_id}} using {{model_id}}")
+            logger.info(f"Idle Task: Generating summary for issue {{issue_id}}  using {{model_id}}")
             start_time = time.time()
             prompt = f"""Concisely summarize the following GitHub issue in 1-2 sentences. Focus on the core problem or request reported by the user.
 Issue Title: {{issue.get('title', 'N/A')}
@@ -1391,7 +1391,7 @@ Summary:"""
                     if result and isinstance(result, list) and 'generated_text' in result[0]:
                         summary = result[0].get('generated_text', '').strip() or "(AI generated empty summary)"
                         self.precomputed_summaries[issue_id] = {{"summary": summary, "error": None, "timestamp": time.time()}
-                        logger.info(f"Stored summary for issue {{issue_id}} (took {{duration:.2f}}s).")
+                        logger.info(f"Stored summary for issue {{issue_id}}  (took {{duration:.2f}}s).")
                     elif isinstance(result, dict) and 'error' in result:
                         raise ValueError(f"API Error: {{result['error']}")
                     else:
@@ -1412,7 +1412,7 @@ Summary:"""
         try:
             issue = self.issues[issue_id]
             model_id = DEFAULT_IDLE_MODEL_ID # Use cheap model
-            logger.info(f"Idle Task: Identifying missing info for issue {{issue_id}} using {{model_id}}")
+            logger.info(f"Idle Task: Identifying missing info for issue {{issue_id}}  using {{model_id}}")
             start_time = time.time()
 
             prompt = f"""Analyze the following GitHub issue description. Identify critical information potentially missing for effective debugging or resolution. List the missing items concisely (e.g., "Steps to reproduce", "Error logs", "Expected vs. Actual behavior", "Environment details"). If the description seems reasonably complete, respond with ONLY the word "None".
@@ -1441,7 +1441,7 @@ Missing Information:"""
                         if info_needed.lower() == "none" or not info_needed:
                             info_needed = "None needed."
                         self.precomputed_missing_info[issue_id] = {{"info_needed": info_needed, "error": None, "timestamp": time.time()}
-                        logger.info(f"Stored missing info analysis for issue {{issue_id} (took {{duration:.2f}s): '{{info_needed[:50]}...'")
+                        logger.info(f"Stored missing info analysis for issue {{issue_id}} (took {{duration:.2f}s): '{{info_needed[:50]}...'")
                     elif isinstance(result, dict) and 'error' in result:
                         raise ValueError(f"API Error: {{result['error']}")
                     else:
@@ -1462,7 +1462,7 @@ Missing Information:"""
         try:
             issue = self.issues[issue_id]
             model_id = DEFAULT_IDLE_MODEL_ID # Use cheap model
-            logger.info(f"Idle Task: Generating preliminary analysis for issue {{issue_id}} using {{model_id}}")
+            logger.info(f"Idle Task: Generating preliminary analysis for issue {{issue_id}}  using {{model_id}}")
             start_time = time.time()
 
             prompt = f"""Analyze the GitHub issue below. Provide a single, concise sentence hypothesizing the root cause OR the main goal. Start with "Hypothesis:". If unsure, respond ONLY with "Hypothesis: Further investigation needed.".
@@ -1494,7 +1494,7 @@ Response:"""
                              hypothesis = "Hypothesis: (Analysis failed or too short)"
 
                         self.precomputed_analysis[issue_id] = {{"hypothesis": hypothesis, "error": None, "timestamp": time.time()}
-                        logger.info(f"Stored preliminary analysis for issue {{issue_id} (took {{duration:.2f}s): '{{hypothesis[:60]}...'")
+                        logger.info(f"Stored preliminary analysis for issue {{issue_id}} (took {{duration:.2f}s): '{{hypothesis[:60]}...'")
                     elif isinstance(result, dict) and 'error' in result:
                         raise ValueError(f"API Error: {{result['error']}")
                     else:
@@ -1583,7 +1583,7 @@ Response:"""
                         cycle_tasks.append(self._compute_and_store_context(issue_id))
                         context_computed_count += 1
                     else: break
-                if context_computed_count > 0: logger.info(f"Scheduled {{context_computed_count}} context computations.")
+                if context_computed_count > 0: logger.info(f"Scheduled {{context_computed_count}}  context computations.")
 
                 # 4. Schedule Summary Generation (LLM - Medium Cost)
                 summary_computed_count = 0
@@ -1592,7 +1592,7 @@ Response:"""
                          cycle_tasks.append(self._compute_and_store_summary(issue_id))
                          summary_computed_count += 1
                      else: break
-                if summary_computed_count > 0: logger.info(f"Scheduled {{summary_computed_count}} summary computations.")
+                if summary_computed_count > 0: logger.info(f"Scheduled {{summary_computed_count}}  summary computations.")
 
                 # 5. Schedule Missing Info Analysis (LLM - Low Cost)
                 missing_info_count = 0
@@ -1601,7 +1601,7 @@ Response:"""
                         cycle_tasks.append(self._compute_and_store_missing_info(issue_id))
                         missing_info_count += 1
                     else: break
-                if missing_info_count > 0: logger.info(f"Scheduled {{missing_info_count}} missing info analyses.")
+                if missing_info_count > 0: logger.info(f"Scheduled {{missing_info_count}}  missing info analyses.")
 
                 # 6. Schedule Preliminary Analysis (LLM - Low Cost)
                 analysis_count = 0
@@ -1610,11 +1610,11 @@ Response:"""
                         cycle_tasks.append(self._compute_and_store_preliminary_analysis(issue_id))
                         analysis_count += 1
                     else: break
-                if analysis_count > 0: logger.info(f"Scheduled {{analysis_count}} preliminary analyses.")
+                if analysis_count > 0: logger.info(f"Scheduled {{analysis_count}}  preliminary analyses.")
 
                 # --- Execute Scheduled Async Tasks ---
                 if cycle_tasks:
-                    logger.info(f"Executing {{len(cycle_tasks)}} async idle tasks for this cycle...")
+                    logger.info(f"Executing {{len(cycle_tasks)}}  async idle tasks for this cycle...")
                     results = await asyncio.gather(*cycle_tasks, return_exceptions=True)
                     num_errors = 0
                     for i, result in enumerate(results):
@@ -1622,7 +1622,7 @@ Response:"""
                             num_errors += 1
                             logger.error(f"Error encountered in background idle task {{i+1}}/{{len(cycle_tasks)}}: {{result}}", exc_info=False) # Keep log cleaner
                     cycle_duration = time.time() - start_time_cycle
-                    logger.info(f"Idle processing cycle finished in {{cycle_duration:.2f}} seconds. {{len(results)}} tasks processed ({{num_errors}} errors).")
+                    logger.info(f"Idle processing cycle finished in {{cycle_duration:.2f}}  seconds. {{len(results)}}  tasks processed ({{num_errors}}  errors).")
                 else:
                     logger.info("No async idle tasks to perform in this cycle.")
                 logger.info(f"--- Finished idle processing cycle ---")
@@ -1655,13 +1655,13 @@ Response:"""
             }
             self.precomputed_context[issue_id] = computed_data
 
-            log_msg = f"Stored context result for issue {{issue_id} (found {{len(computed_data['files'])} files, took {{duration:.2f}s)."
+            log_msg = f"Stored context result for issue {{issue_id}} (found {{len(computed_data['files'])}} files, took {{duration:.2f}s)."
             if computed_data['error']:
                 log_msg += f" Error: {{computed_data['error']}"
             logger.info(log_msg)
 
         except Exception as e:
-            logger.exception(f"Failed to compute context for issue {{issue_id}} in background task: {{e}}")
+            logger.exception(f"Failed to compute context for issue {{issue_id}}  in background task: {{e}}")
             self.precomputed_context[issue_id] = {{"error": f"Unexpected computation error: {{e}}", "timestamp": time.time(), "content": None, "files": []}
 
     async def _run_clustering_and_duplicates_async(self):
@@ -1707,7 +1707,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
 
             status_indicators = []
             if issue_num in manager.stale_issues:
-                status_indicators.append(f"<span title='No updates in >{{manager.stale_issue_threshold_days} days' style='color: #b91c1c; font-weight: bold; font-size: 0.9em; background-color: #fee2e2; padding: 1px 4px; border-radius: 3px;'>[Stale]</span>")
+                status_indicators.append(f"<span title='No updates in >{{manager.stale_issue_threshold_days}} days' style='color: #b91c1c; font-weight: bold; font-size: 0.9em; background-color: #fee2e2; padding: 1px 4px; border-radius: 3px;'>[Stale]</span>")
             if issue_num in manager.high_priority_candidates:
                  severity = manager._determine_severity(issue.get('labels', []))
                  if severity == "Critical": color, bgcolor = "#ef4444", "#fee2e2"
@@ -1761,7 +1761,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
 
             if duplicate_text:
                  dup_ids = manager.potential_duplicates.get(issue_num, [])
-                 dup_links = ", ".join([f"<span style='cursor: help; color: #4338ca; text-decoration: underline dotted;' title='Issue #{{dup_id} has similar content'>#{{dup_id}</span>" for dup_id in dup_ids])
+                 dup_links = ", ".join([f"<span style='cursor: help; color: #4338ca; text-decoration: underline dotted;' title='Issue #{{dup_id}} has similar content'>#{{dup_id}</span>" for dup_id in dup_ids])
                  ai_sections.append(f"""
                  <div style="font-size: 0.9em; margin-top: 8px; background-color: #fffbeb; padding: 6px 10px; border-radius: 4px; border: 1px solid #fef3c7;">
                      <strong style="color: #d97706;">⚠️ Potential Duplicates:</strong> {{dup_links}
@@ -1773,8 +1773,8 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
             preview_html = f"""
             <div style="border: 1px solid #e5e7eb; padding: 15px; border-radius: 8px; background-color: #ffffff; font-family: 'Inter', sans-serif; display: flex; flex-direction: column; max-height: 80vh;">
                 <h4 style="margin-top: 0; margin-bottom: 10px; font-size: 1.1em; display: flex; justify-content: space-between; align-items: center;">
-                    <a href='{{issue.get('url', '#')}' target='_blank' style='color: #6d28d9; text-decoration: none; font-weight: 600;' title="Open issue #{{issue['id']} on GitHub">
-                        #{{issue['id']} - {{gr.Textbox.sanitize_html(issue.get('title', 'N/A'))}
+                    <a href='{{issue.get('url', '#')}' target='_blank' style='color: #6d28d9; text-decoration: none; font-weight: 600;' title="Open issue #{{issue['id']}} on GitHub">
+                        #{{issue['id']}} - {{gr.Textbox.sanitize_html(issue.get('title', 'N/A'))}
                     </a>
                     <span style="margin-left: 10px; flex-shrink: 0;">{{status_html}</span>
                 </h4>
@@ -1811,7 +1811,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
 
          issue = manager.issues[issue_num]
          issue_hash = manager._get_issue_hash(issue)
-         logger.info(f"Requesting suggestion for issue {{issue_num}} (hash: {{issue_hash}}) using model {{model_key}}.")
+         logger.info(f"Requesting suggestion for issue {{issue_num}}  (hash: {{issue_hash}}) using model {{model_key}}.")
 
          try:
              progress(0.3, desc=f"Querying {{model_key}}...")
@@ -1835,10 +1835,10 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
          if not manager.repo:
              return "❌ Error: Repository not loaded. Please scan the repository first."
 
-         logger.info(f"Requesting patch for issue {{issue_num}} using model {{model_key}}.")
+         logger.info(f"Requesting patch for issue {{issue_num}}  using model {{model_key}}.")
          progress(0.1, desc="Gathering code context (using cache if available)...")
          try:
-             progress(0.4, desc=f"Querying {{model_key}} for patch...")
+             progress(0.4, desc=f"Querying {{model_key}}  for patch...")
              result = await manager.generate_code_patch(issue_num, model_key)
              progress(1, desc="Patch result received.")
 
@@ -1852,7 +1852,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
 
                  if patch_content:
                      patch_content_sanitized = patch_content.replace('`', '\\`')
-                     logger.info(f"Successfully generated patch for issue {{issue_num}} using {{model_used}}.")
+                     logger.info(f"Successfully generated patch for issue {{issue_num}}  using {{model_used}}.")
                      return f"""**🩹 Patch Suggestion from {{model_used}:**
 **Explanation:**
 {{explanation}
@@ -1899,10 +1899,10 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
             logger.info(f"Issue selected via Dataframe: ID {{selected_id}}")
 
             if selected_id not in manager.issues:
-                logger.error(f"Selected issue ID {{selected_id} not found in manager's issue list.")
+                logger.error(f"Selected issue ID {{selected_id}} not found in manager's issue list.")
                 return {{
                     **default_response,
-                    "issue_preview_html": gr.update(value=f"<p style='color: red; font-weight: bold;'>Error: Issue {{selected_id} not found in the current list. Try re-scanning.</p>"),
+                    "issue_preview_html": gr.update(value=f"<p style='color: red; font-weight: bold;'>Error: Issue {{selected_id}} not found in the current list. Try re-scanning.</p>"),
                 }
 
             issue_data = manager.issues[selected_id]
@@ -1917,8 +1917,8 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                      context_source_msg = f"Pre-computed (Failed @ {{timestamp_str}})"
                      files_content["error_context.txt"] = f"# Error loading pre-computed context:\n# {{context_data['error']}"
                  elif context_data.get("files"):
-                     context_source_msg = f"Pre-computed ({{len(context_data['files'])} files @ {{timestamp_str})"
-                     logger.info(f"Loading {{len(context_data['files'])} files from pre-computed context for issue {{selected_id}: {{context_data['files']}")
+                     context_source_msg = f"Pre-computed ({{len(context_data['files'])}} files @ {{timestamp_str})"
+                     logger.info(f"Loading {{len(context_data['files'])}} files from pre-computed context for issue {{selected_id}: {{context_data['files']}")
                      loaded_count = 0
                      for file_path_str in context_data["files"]:
                          full_path = manager.repo_local_path / file_path_str
@@ -1926,7 +1926,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                              files_content[file_path_str] = full_path.read_text(encoding='utf-8', errors='ignore')
                              loaded_count += 1
                          except Exception as e:
-                             logger.warning(f"Error reading pre-computed file {{full_path}} for issue {{selected_id}}: {{e}}")
+                             logger.warning(f"Error reading pre-computed file {{full_path}}  for issue {{selected_id}}: {{e}}")
                              files_content[file_path_str] = f"# Error reading file: {{e}}"
                      if loaded_count == 0 and context_data["files"]:
                           files_content["error_reading_files.txt"] = "# Precomputed context found file references, but failed to read any file content."
@@ -1949,8 +1949,8 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                      context_source_msg += f" (Error: {{context_result['error']})"
                      files_content["error_context.txt"] = f"# Error loading context on demand:\n# {{context_result['error']}"
                  elif context_result.get("files"):
-                     context_source_msg += f" ({{len(context_result['files'])} files)"
-                     logger.info(f"Loading {{len(context_result['files'])} files computed on-demand for issue {{selected_id}: {{context_result['files']}")
+                     context_source_msg += f" ({{len(context_result['files'])}} files)"
+                     logger.info(f"Loading {{len(context_result['files'])}} files computed on-demand for issue {{selected_id}: {{context_result['files']}")
                      loaded_count = 0
                      for file_path_str in context_result["files"]:
                          full_path = manager.repo_local_path / file_path_str
@@ -1958,7 +1958,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                              files_content[file_path_str] = full_path.read_text(encoding='utf-8', errors='ignore')
                              loaded_count +=1
                          except Exception as e:
-                             logger.warning(f"Error reading on-demand file {{full_path}} for issue {{selected_id}}: {{e}}")
+                             logger.warning(f"Error reading on-demand file {{full_path}}  for issue {{selected_id}}: {{e}}")
                              files_content[file_path_str] = f"# Error reading file: {{e}}"
                      if loaded_count == 0 and context_result["files"]:
                           files_content["error_reading_files.txt"] = "# Context computation found file references, but failed to read any file content."
@@ -1972,7 +1972,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
             if not files_content:
                  files_content["placeholder.txt"] = f"# No relevant files found or context failed to load for issue {{selected_id}}."
             manager.code_editors[selected_id] = OTCodeEditor(initial_value=files_content)
-            logger.info(f"Initialized/Updated OT editor state for issue {{selected_id}} with files: {{list(files_content.keys())}}")
+            logger.info(f"Initialized/Updated OT editor state for issue {{selected_id}}  with files: {{list(files_content.keys())}}")
 
             updates = {{
                 "selected_issue_id_state": gr.update(value=selected_id),
@@ -1992,7 +1992,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
             }
 
     # --- Gradio Blocks ---
-    with gr.Blocks(theme=theme, title="AI Issue Resolver Pro", css="#collab-list .collab-item {{ margin-bottom: 4px; font-size: 0.9em; } .gradio-container {{ max-width: 1600px !important; }") as demo_app:
+    with gr.Blocks(theme=theme, title="AI Issue Resolver Pro", css="#collab-list .collab-item {{ margin-bottom: 4px; font-size: 0.9em; }} .gradio-container {{ max-width: 1600px !important; }") as demo_app:
         gr.Markdown("""
         <div style="text-align: center; margin-bottom: 20px;">
             <h1 style="color: #6d28d9; font-weight: 800;">🚀 AI Issue Resolver Pro</h1>
@@ -2179,7 +2179,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                     if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname.endsWith('.gradio.live')) {{
                         wsUrl = `${{protocol}}//${{hostname}}:${{wsPort}}`;
                          console.log('Detected local/gradio.live environment, using direct WebSocket URL:', wsUrl);
-                    }} else {{
+                    }}  else {{
                         const wsPath = '/ws';
                         wsUrl = `${{protocol}}//${{window.location.host}}${{wsPath}}`;
                         console.log('Detected non-local environment, assuming proxied WebSocket URL:', wsUrl);
@@ -2209,7 +2209,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                         <span style="color: #555;">${{info.status || 'Idle'}}</span>
                                     </div>`)
                                 .join('');
-                        }} else {{
+                        }}  else {{
                             collabListDiv.innerHTML = '<span style="color: #6b7280;">You are the only active user.</span>';
                         }}
                     }}
@@ -2227,11 +2227,11 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                             console.log(`WebSocket already ${{(collabWs.readyState === WebSocket.OPEN) ? 'open' : 'connecting'}}. State: ${{collabWs.readyState}}`);
                             return;
                         }}
-                        console.log(`Attempting WebSocket connection to ${{wsUrl}} (Attempt ${{reconnectAttempts + 1}}/${{maxReconnectAttempts}})...`);
+                        console.log(`Attempting WebSocket connection to ${{wsUrl}}  (Attempt ${{reconnectAttempts + 1}}/${{maxReconnectAttempts}})...`);
                         updateStatusBar(`Connecting collaboration service (Attempt ${{reconnectAttempts + 1}})...`);
                         try {{
                              collabWs = new WebSocket(wsUrl);
-                        }} catch (e) {{
+                        }}  catch (e) {{
                              console.error("WebSocket constructor failed:", e);
                              updateStatusBar("Collaboration connection failed (init error).", true);
                              // Handle reconnection attempt here as well
@@ -2252,17 +2252,17 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                 const data = JSON.parse(event.data);
                                 if (data.type === 'collaboration_status') {{
                                     updateCollabList(data.collaborators);
-                                }} else if (data.type === 'code_update') {{
+                                }}  else if (data.type === 'code_update') {{
                                     const receivedIssueNum = parseInt(data.issue_num, 10);
                                     if (aceEditorInstance && receivedIssueNum === currentIssueId && data.senderId !== clientId) {{
-                                        console.warn(`Applying remote delta for issue ${{receivedIssueNum}} from ${{data.senderId}}. WARNING: NO OT!`);
+                                        console.warn(`Applying remote delta for issue ${{receivedIssueNum}}  from ${{data.senderId}}. WARNING: NO OT!`);
                                         try {{
                                             const delta = JSON.parse(data.delta);
                                             // Add ignore flag for local change listener
                                             aceEditorInstance.getSession().getDocument().applyDeltas([{{...delta, ignore: true}}]);
-                                        }} catch (e) {{ console.error('Failed to parse or apply remote delta:', e, data.delta); }}
+                                        }}  catch (e) {{ console.error('Failed to parse or apply remote delta:', e, data.delta); }}
                                     }}
-                                }} else if (data.type === 'issues_updated') {{
+                                }}  else if (data.type === 'issues_updated') {{
                                     console.log('Received notification: Issue list updated on server.');
                                     updateStatusBar('Issue list updated on server. Refreshing the page or re-scanning is recommended.');
                                     const crawlButton = document.getElementById('crawl_btn');
@@ -2270,10 +2270,10 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                         crawlButton.style.backgroundColor = '#fef08a';
                                         setTimeout(() => {{ crawlButton.style.backgroundColor = '' }}, 2000);
                                     }}
-                                }} else {{
+                                }}  else {{
                                     console.warn("Received unknown WebSocket message type:", data.type, data);
                                 }}
-                            }} catch (e) {{
+                            }}  catch (e) {{
                                 console.error('Failed to parse WebSocket message or update UI:', e, event.data);
                             }}
                         }};
@@ -2296,10 +2296,10 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                          editorChangeListenerAttached = false; // Allow re-attaching on reconnect
                          if (reconnectAttempts < maxReconnectAttempts) {{
                              const delay = Math.pow(2, reconnectAttempts) * 1500 + Math.random() * 1000;
-                             console.log(`Attempting to reconnect WebSocket in approx. ${{Math.round(delay / 1000)}} seconds...`);
+                             console.log(`Attempting to reconnect WebSocket in approx. ${{Math.round(delay / 1000)}}  seconds...`);
                              setTimeout(connectWebSocket, delay);
                              reconnectAttempts++;
-                         }} else {{
+                         }}  else {{
                              console.error('Max WebSocket reconnection attempts reached.');
                              updateStatusBar('Collaboration failed - Max reconnect attempts reached.', true);
                          }}
@@ -2308,10 +2308,10 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                         if (collabWs && collabWs.readyState === WebSocket.OPEN) {{
                             try {{
                                 collabWs.send(JSON.stringify(message));
-                            }} catch (e) {{
+                            }}  catch (e) {{
                                 console.error("Failed to stringify or send WebSocket message:", e, message);
                             }}
-                        }} else {{
+                        }}  else {{
                             console.warn('WebSocket not connected. Cannot send message:', message);
                         }}
                     }}
@@ -2325,7 +2325,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                 console.warn(`Ace library or editor element not found yet. Retrying editor setup (${{editorSetupAttempts + 1}}/${{maxEditorSetupAttempts}})...`);
                                 editorSetupAttempts++;
                                 setTimeout(setupCodeEditorListener, 1500 + Math.random() * 500);
-                            }} else {{
+                            }}  else {{
                                 console.error("Ace library or editor element not found after multiple attempts. Code editor collaboration disabled.");
                                 updateStatusBar("Code editor library or UI element failed to load.", true);
                             }}
@@ -2347,7 +2347,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                 console.log("Attaching Ace editor 'change' listener...");
                                 aceEditorInstance.getSession().on('change', function(delta) {{
                                     // Check for the custom 'ignore' flag added when applying remote deltas
-                                    if (delta.ignore) {{ return; }} // Ignore remote changes
+                                    if (delta.ignore) {{ return; }}  // Ignore remote changes
                                     if (currentIssueId !== null) {{
                                         const now = Date.now();
                                         // Simple debounce to avoid flooding server
@@ -2378,7 +2378,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                             }}
                             editorSetupAttempts = 0; // Reset attempts on success
                             updateTrackedIssueId(); // Ensure correct issue ID is tracked after setup
-                        }} catch (e) {{
+                        }}  catch (e) {{
                              console.error('Failed to initialize Ace editor instance or attach listeners:', e);
                              if (editorElement) delete editorElement.dataset.collabInitialized; // Allow retry
                              aceEditorInstance = null;
@@ -2387,7 +2387,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                  console.warn(`Retrying editor setup after error (${{editorSetupAttempts + 1}}/${{maxEditorSetupAttempts}})...`);
                                  editorSetupAttempts++;
                                  setTimeout(setupCodeEditorListener, 2000 + Math.random() * 500);
-                             }} else {{
+                             }}  else {{
                                  console.error("Max editor setup attempts failed after error. Collaboration disabled.");
                                  updateStatusBar("Code editor setup failed repeatedly.", true);
                              }}
@@ -2418,13 +2418,13 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                                      newIssueId = parseInt(value, 10);
                                      // Found a potential ID, stop searching
                                      break;
-                                }} catch (e) {{
+                                }}  catch (e) {{
                                      console.debug("Could not parse hidden input value as int:", value, e);
                                 }}
                             }}
                         }}
                         if (newIssueId !== currentIssueId) {{
-                            console.log(`Updating tracked issue ID: from ${{currentIssueId}} to ${{newIssueId}}`);
+                            console.log(`Updating tracked issue ID: from ${{currentIssueId}}  to ${{newIssueId}}`);
                             currentIssueId = newIssueId;
                             const status = currentIssueId !== null ? `Viewing Issue #${{currentIssueId}}` : 'Idle';
                             sendWsMessage({{ type: 'status_update', clientId: clientId, status: status}});
@@ -2480,7 +2480,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                     if (observerTargetNode) {{
                         console.log("Starting MutationObserver to detect Gradio UI changes (incl. hidden state).");
                         observer.observe(observerTargetNode, observerConfig);
-                    }} else {{
+                    }}  else {{
                         console.error("Could not find observer target node (document.body).");
                     }}
                     // Initial setup attempts
@@ -2500,7 +2500,7 @@ async def handle_ws_connection(websocket: WebSocketServerProtocol, path: str, ma
     client_id = f"client_{{hashlib.sha1(os.urandom(16)).hexdigest()[:8]}}"
     setattr(websocket, 'client_id', client_id)
     remote_addr = websocket.remote_address
-    logger.info(f"WebSocket client connected: {{remote_addr}} assigned ID {{client_id}}")
+    logger.info(f"WebSocket client connected: {{remote_addr}}  assigned ID {{client_id}}")
 
     manager.ws_clients.append(websocket)
     logger.info(f"Client list size: {{len(manager.ws_clients)}}")
@@ -2512,12 +2512,12 @@ async def handle_ws_connection(websocket: WebSocketServerProtocol, path: str, ma
                 msg_type = data.get("type")
                 sender_id = client_id
 
-                logger.debug(f"Received WS message type '{{msg_type}' from {{sender_id} ({{remote_addr})")
+                logger.debug(f"Received WS message type '{{msg_type}' from {{sender_id}} ({{remote_addr})")
 
                 if msg_type == "join":
                      client_name = data.get("name", f"User_{{sender_id[:4]}}")
                      manager.collaborators[sender_id] = {{"name": client_name, "status": "Connected"}
-                     logger.info(f"Client {{sender_id}} ({{client_name}}) joined collaboration. Current collaborators: {{list(manager.collaborators.keys())}}")
+                     logger.info(f"Client {{sender_id}}  ({{client_name}}) joined collaboration. Current collaborators: {{list(manager.collaborators.keys())}}")
                      await manager.broadcast_collaboration_status_once()
 
                 elif msg_type == "code_update":
@@ -2534,25 +2534,25 @@ async def handle_ws_connection(websocket: WebSocketServerProtocol, path: str, ma
                          manager.collaborators[sender_id]["status"] = status
                          await manager.broadcast_collaboration_status_once()
                      else:
-                         logger.warning(f"Received status update from client {{sender_id}} not in collaborator list. Adding/Updating.")
-                         manager.collaborators[sender_id] = {{"name": f"User_{{sender_id[:4]}} (Re-added)", "status": status}
+                         logger.warning(f"Received status update from client {{sender_id}}  not in collaborator list. Adding/Updating.")
+                         manager.collaborators[sender_id] = {{"name": f"User_{{sender_id[:4]}}  (Re-added)", "status": status}
                          await manager.broadcast_collaboration_status_once()
 
                 else:
-                    logger.warning(f"Unknown WebSocket message type '{{msg_type}' received from {{sender_id} ({{remote_addr}). Message: {{str(message)[:200]}")
+                    logger.warning(f"Unknown WebSocket message type '{{msg_type}' received from {{sender_id}} ({{remote_addr}). Message: {{str(message)[:200]}")
 
             except json.JSONDecodeError:
-                logger.error(f"Received invalid JSON over WebSocket from {{sender_id}} ({{remote_addr}}): {{str(message)[:200]}}...")
+                logger.error(f"Received invalid JSON over WebSocket from {{sender_id}}  ({{remote_addr}}): {{str(message)[:200]}}...")
             except Exception as e:
-                logger.exception(f"Error processing WebSocket message from {{sender_id}} ({{remote_addr}}): {{e}}")
+                logger.exception(f"Error processing WebSocket message from {{sender_id}}  ({{remote_addr}}): {{e}}")
 
     # Catch standard socket exceptions for disconnects
     except (ConnectionClosed, ConnectionClosedOK, ConnectionAbortedError, ConnectionResetError) as e:
-        logger.info(f"WebSocket client {{client_id} ({{remote_addr}) disconnected: Code={{getattr(e, 'code', 'N/A')}, Reason='{{getattr(e, 'reason', 'N/A')}'")
+        logger.info(f"WebSocket client {{client_id}} ({{remote_addr}) disconnected: Code={{getattr(e, 'code', 'N/A')}, Reason='{{getattr(e, 'reason', 'N/A')}'")
     except Exception as e:
-        logger.exception(f"Unexpected error in WebSocket handler for {{client_id}} ({{remote_addr}}): {{e}}")
+        logger.exception(f"Unexpected error in WebSocket handler for {{client_id}}  ({{remote_addr}}): {{e}}")
     finally:
-        logger.info(f"Cleaning up connection for client {{client_id}} ({{remote_addr}})")
+        logger.info(f"Cleaning up connection for client {{client_id}}  ({{remote_addr}})")
         manager.remove_ws_client(websocket)
 
 
@@ -2583,7 +2583,7 @@ async def start_websocket_server(manager: IssueManager, port: int):
 
     except OSError as e:
          logger.error(f"Failed to start WebSocket server on port {{port}}: {{e}}. Is the port already in use?")
-         raise SystemExit(f"WebSocket Port {{port}} unavailable. Application cannot start.")
+         raise SystemExit(f"WebSocket Port {{port}}  unavailable. Application cannot start.")
     except asyncio.CancelledError:
          logger.info("WebSocket server task cancelled.")
     except Exception as e: