aline-ai 0.7.2__py3-none-any.whl → 0.7.3__py3-none-any.whl

{aline_ai-0.7.2.dist-info → aline_ai-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aline-ai
-Version: 0.7.2
+Version: 0.7.3
 Summary: Shared AI memory; everyone knows everything in teams
 Author: Sharemind
 License: MIT

{aline_ai-0.7.2.dist-info → aline_ai-0.7.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
-aline_ai-0.7.2.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=T1uqzYkOUbzoMzR_BVD5kRPO727lyC6k7hF_RudJoi8,1623
+aline_ai-0.7.3.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=ReJTANkYJVgZYwHExBSBOBiJZxdi2HY4VluOTHSxRns,1623
 realign/agent_names.py,sha256=H4oVJMkqg1ZYCk58vD_Jh9apaAHSFJRswa-C9SPdJxc,1171
 realign/auth.py,sha256=d_1yvCwluN5iIrdgjtuSKpOYAksDzrzNgntKacLVJrw,16583
 realign/claude_detector.py,sha256=ZLSJacMo6zzQclXByABKA70UNpstxqIv3fPGqdpA934,2792
@@ -41,23 +41,23 @@ realign/commands/auth.py,sha256=wcs1lUcSXxv75WcGruzyZ3kgi0xXA8W4lNnUwM4a3CI,1173
 realign/commands/config.py,sha256=nYnu_h2pk7GODcrzrV04K51D-s7v06FlRXHJ0HJ-gvU,6732
 realign/commands/context.py,sha256=pM2KfZHVkB-ou4nBhFvKSwnYliLBzwN3zerLyBAbhfE,7095
 realign/commands/doctor.py,sha256=0c1TZuA_cw1CSU0yKMVRU-18uTxdqjXKJ8lP2CTTNSQ,20656
-realign/commands/export_shares.py,sha256=76VYTB9r6JVx9rLcimwJ1xwpTNeeQU5TFL4SmTbRY54,148590
+realign/commands/export_shares.py,sha256=O2yRZT4S2ANoswLwDDmA1mau1nEvBVbmSXD4ST6Id_o,153150
 realign/commands/import_shares.py,sha256=Jx_7HVSg7SrGGKLDxsf_UqoStDimw8B26uKkqNFF6t8,33071
 realign/commands/init.py,sha256=6rBr1LVIrQLbUH_UvoDhkF1qXmMh2xkjNWCYAUz5Tho,35274
 realign/commands/restore.py,sha256=s2BxQZHxQw9r12NzRVsK20KlGafy5AIoSjWMo5PcnHY,11173
 realign/commands/search.py,sha256=QlUDzRDD6ebq21LTtLe5-OZM62iwDrDqfbnXbuxfklU,27516
-realign/commands/sync_agent.py,sha256=gzvbqdujBbFdUY0SNyb66OPjp3e-qnqazinH5ZiPFok,14876
+realign/commands/sync_agent.py,sha256=sopzUQ6kiRgiBlcEReGAWCRoqrHpk3nAx75qXSgnNi4,17082
 realign/commands/upgrade.py,sha256=L3PLOUIN5qAQTbkfoVtSsIbbzEezA_xjjk9F1GMVfjw,12781
 realign/commands/watcher.py,sha256=4WTThIgr-Z5guKh_JqGDcPmerr97XiHrVaaijmckHsA,134350
 realign/commands/worker.py,sha256=jTu7Pj60nTnn7SsH3oNCNnO6zl4TIFCJVNSC1OoQ_0o,23363
 realign/dashboard/__init__.py,sha256=QZkHTsGityH8UkF8rmvA3xW7dMXNe0swEWr443qfgCM,128
-realign/dashboard/app.py,sha256=gp44tyR3dEJdxx36D-HODpbNh56cw4117zY1ina1chw,8182
+realign/dashboard/app.py,sha256=XLPqvPwGuR5Tyu6uz9T88yQSc4wq8Afu0h7pWH5A8_k,8161
 realign/dashboard/clipboard.py,sha256=81frq83E_urqLkwuCvtl0hiTEjavtdQn8kCi72jJWcs,1207
 realign/dashboard/layout.py,sha256=sZxmFj6QTbkois9MHTvBEMMcnaRVehCDqugdbiFx10k,9072
 realign/dashboard/local_api.py,sha256=Roq74etTJR0uOiHE3uIe7sqVITjS5JGQEF4g0nmUm5Q,4332
 realign/dashboard/state.py,sha256=V7zBKvyDgqdXv68XHxV4T8xf3IhYbI5W33UmYW3_hyM,1139
 realign/dashboard/terminal_backend.py,sha256=MlDfwtqhftyQK6jDNizQGFjAWIo5Bx2TDpSnP3MCZVM,3375
-realign/dashboard/tmux_manager.py,sha256=sS6fo7UVPHWxYm1RYtLDPmwsagFh5RO6TRwYd1CuHaI,34581
+realign/dashboard/tmux_manager.py,sha256=HJwB2Wpz-I4OrNT3Db8gKCLifmHdMCalA-UONBaLMG8,34564
 realign/dashboard/backends/__init__.py,sha256=POROX7YKtukYZcLB1pi_kO0sSEpuO3y-hwmF3WIN1Kk,163
 realign/dashboard/backends/iterm2.py,sha256=XYYJT5lrrp4pW_MyEqPZYkRI0qyKUwJlezwMidgnsHc,21390
 realign/dashboard/backends/kitty.py,sha256=5jdkR1f2PwB8a4SnS3EG6uOQ2XU-PB7-cpKBfIJq3hU,12066
@@ -72,7 +72,7 @@ realign/dashboard/screens/session_detail.py,sha256=TBkHqSHyMxsLB2QdZq9m1EoiH8oRV
 realign/dashboard/screens/share_import.py,sha256=hl2x0yGVycsoUI76AmdZTAV-br3Q6191g5xHHrZ8hOA,6318
 realign/dashboard/styles/dashboard.tcss,sha256=9W5Tx0lgyGb4HU-z-Kn7gBdexIK0aPe0bkVn2k_AseM,3288
 realign/dashboard/widgets/__init__.py,sha256=dXsOnbeu_8XhP-6Bu6-R_0LNGqsSM6x7dG7FCDumpa8,460
-realign/dashboard/widgets/agents_panel.py,sha256=SEzjDFaMdl9bVhKr0XlhMww68pp9pmIu9HqyFfp5Iaw,45209
+realign/dashboard/widgets/agents_panel.py,sha256=pqXZhzSL84lzJPqGGGsfsGJGVlVo2iCyHByXM4_ITCM,47083
 realign/dashboard/widgets/config_panel.py,sha256=J6A_rxGVqNu5TMFcWELWgdX1nFCHAjKprFMMp7mBDKo,18203
 realign/dashboard/widgets/events_table.py,sha256=0cMvE0KdZFBZyvywv7vlt005qsR0aLQnQiMf3ZzK7RY,30218
 realign/dashboard/widgets/header.py,sha256=0HHCFXX7F3C6HII-WDwOJwWkJrajmKPWmdoMWyOkn9E,1587
@@ -106,8 +106,8 @@ realign/triggers/next_turn_trigger.py,sha256=-x80_I-WmIjXXzQHEPBykgx_GQW6oKaLDQx
 realign/triggers/registry.py,sha256=dkIjSd8Bg-hF0nxaO2Fi2K-0Zipqv6vVjc-HYSrA_fY,3656
 realign/triggers/turn_status.py,sha256=wAZEhXDAmDoX5F-ohWfSnZZ0eA6DAJ9svSPiSv_f6sg,6041
 realign/triggers/turn_summary.py,sha256=f3hEUshgv9skJ9AbfWpoYs417lsv_HK2A_vpPjgryO4,4467
-aline_ai-0.7.2.dist-info/METADATA,sha256=8dK5fqTKyPuVF0b8Y5I0DMLyaRKF7AlzfQ92oSsWBFM,1597
-aline_ai-0.7.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aline_ai-0.7.2.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
-aline_ai-0.7.2.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.7.2.dist-info/RECORD,,
+aline_ai-0.7.3.dist-info/METADATA,sha256=qbtgEyiKE5FSJk_zjGsOTKm8s89Ckqpnw8wGM8RFezA,1597
+aline_ai-0.7.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aline_ai-0.7.3.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
+aline_ai-0.7.3.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.7.3.dist-info/RECORD,,

realign/__init__.py

@@ -3,7 +3,7 @@
 import hashlib
 from pathlib import Path
 
-__version__ = "0.7.2"
+__version__ = "0.7.3"
 
 
 def get_realign_dir(project_root: Path) -> Path:

realign/commands/export_shares.py

@@ -1703,6 +1703,21 @@ def _update_share_content(
     if not HTTPX_AVAILABLE:
         raise RuntimeError("httpx package not installed. Run: pip install httpx")
 
+    # Large payloads can exceed serverless request limits; fall back to chunked update.
+    update_payload = {"conversation_data": conversation_data}
+    payload_size = len(json.dumps(update_payload).encode("utf-8"))
+    if payload_size > CHUNKED_UPLOAD_THRESHOLD:
+        logger.info(
+            f"Update payload size ({payload_size / 1024 / 1024:.2f}MB) exceeds threshold, using chunked update"
+        )
+        return _chunked_update_share_content(
+            backend_url=backend_url,
+            share_id=share_id,
+            token=token,
+            conversation_data=conversation_data,
+            expected_version=expected_version,
+        )
+
     headers = {
         "X-Token": token,
         "X-Expected-Version": str(expected_version),
@@ -1712,7 +1727,7 @@ def _update_share_content(
     response = httpx.put(
         f"{backend_url}/api/share/{share_id}",
         headers=headers,
-        json={"conversation_data": conversation_data},
+        json=update_payload,
         timeout=60.0,
     )
     response.raise_for_status()
@@ -1752,64 +1767,148 @@ def _upload_chunks_and_complete(
     upload_id: str,
     backend_url: str,
     progress_callback: Optional[Callable] = None,
-    auth_headers: Optional[Dict[str, str]] = None,
-) -> None:
+    headers_provider: Optional[Callable[[], Dict[str, str]]] = None,
+) -> Optional[dict]:
     """
     Helper function to upload chunks and complete the upload.
     Can be run in background thread.
     """
+    import time
+
     total_chunks = len(chunks)
-    headers = auth_headers or {}
+
+    def _headers() -> Dict[str, str]:
+        try:
+            return dict(headers_provider()) if headers_provider else {}
+        except Exception:
+            return {}
+
+    def _post_with_retries(url: str, payload: dict, timeout: float) -> Optional[dict]:
+        max_attempts = 3
+        for attempt in range(max_attempts):
+            try:
+                response = httpx.post(url, json=payload, headers=_headers(), timeout=timeout)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                status = getattr(e.response, "status_code", None)
+                retriable = status in (401, 403, 409, 429, 500, 502, 503, 504)
+                if retriable and attempt < max_attempts - 1:
+                    time.sleep(0.5 * (2**attempt))
+                    continue
+                logger.error(f"POST failed: {e}")
+                return None
+            except httpx.HTTPError as e:
+                if attempt < max_attempts - 1:
+                    time.sleep(0.5 * (2**attempt))
+                    continue
+                logger.error(f"POST failed: {e}")
+                return None
 
     # Upload each chunk
     for i, chunk in enumerate(chunks):
         if progress_callback:
             progress_callback(i + 1, total_chunks + 2, f"Uploading chunk {i + 1}/{total_chunks}...")
 
-        try:
-            chunk_payload = {
-                "upload_id": upload_id,
-                "chunk_index": i,
-                "data": chunk,
-            }
+        chunk_payload = {
+            "upload_id": upload_id,
+            "chunk_index": i,
+            "data": chunk,
+        }
 
-            response = httpx.post(
-                f"{backend_url}/api/share/chunk/upload",
-                json=chunk_payload,
-                headers=headers,
-                timeout=60.0,  # Longer timeout for chunk uploads
-            )
-            response.raise_for_status()
-            result = response.json()
-            logger.debug(
-                f"Chunk {i + 1}/{total_chunks} uploaded, received: {result.get('received_chunks')}"
-            )
+        result = _post_with_retries(
+            f"{backend_url}/api/share/chunk/upload",
+            chunk_payload,
+            timeout=60.0,  # Longer timeout for chunk uploads
+        )
+        if not result:
+            logger.error(f"Failed to upload chunk {i}")
+            return None
 
-        except httpx.HTTPError as e:
-            logger.error(f"Failed to upload chunk {i}: {e}")
-            # In background mode, we just log the error
-            return
+        logger.debug(
+            f"Chunk {i + 1}/{total_chunks} uploaded, received: {result.get('received_chunks')}"
+        )
 
     # Complete upload
     if progress_callback:
         progress_callback(total_chunks + 1, total_chunks + 2, "Finalizing upload...")
 
-    try:
-        response = httpx.post(
-            f"{backend_url}/api/share/chunk/complete",
-            json={"upload_id": upload_id},
-            headers=headers,
-            timeout=60.0,
-        )
-        response.raise_for_status()
-        result = response.json()
-        logger.info(f"Chunked upload completed: {result.get('share_url')}")
+    result = _post_with_retries(
+        f"{backend_url}/api/share/chunk/complete",
+        {"upload_id": upload_id},
+        timeout=60.0,
+    )
+    if not result:
+        logger.error("Failed to complete chunked upload")
+        return None
 
-        if progress_callback:
-            progress_callback(total_chunks + 2, total_chunks + 2, "Upload complete!")
+    logger.info(f"Chunked upload completed: {result.get('share_url')}")
 
-    except httpx.HTTPError as e:
-        logger.error(f"Failed to complete chunked upload: {e}")
+    if progress_callback:
+        progress_callback(total_chunks + 2, total_chunks + 2, "Upload complete!")
+
+    return result
+
+
+def _chunked_update_share_content(
+    backend_url: str,
+    share_id: str,
+    token: str,
+    conversation_data: dict,
+    expected_version: int,
+) -> dict:
+    data_str = json.dumps(conversation_data)
+    data_bytes = data_str.encode("utf-8")
+    total_size = len(data_bytes)
+
+    chunks: List[str] = []
+    for i in range(0, total_size, CHUNK_SIZE):
+        chunk_data = data_bytes[i : i + CHUNK_SIZE]
+        chunks.append(base64.b64encode(chunk_data).decode("ascii"))
+
+    total_chunks = len(chunks)
+    logger.info(f"Splitting update into {total_chunks} chunks")
+
+    init_payload = {
+        "total_chunks": total_chunks,
+        "total_size": total_size,
+        "metadata": {},
+        "encrypted_info": None,
+        "ui_metadata": conversation_data.get("ui_metadata"),
+        "share_id": share_id,
+        "operation": "update",
+    }
+
+    def headers_provider() -> Dict[str, str]:
+        # Keep bearer auth when available; required for create, optional for update.
+        headers = get_auth_headers()
+        headers["X-Token"] = token
+        headers["X-Expected-Version"] = str(expected_version)
+        return headers
+
+    init_headers = headers_provider()
+    init_headers["Content-Type"] = "application/json"
+
+    response = httpx.post(
+        f"{backend_url}/api/share/chunk/init",
+        json=init_payload,
+        headers=init_headers,
+        timeout=30.0,
+    )
+    response.raise_for_status()
+    init_result = response.json()
+    upload_id = init_result["upload_id"]
+
+    result = _upload_chunks_and_complete(
+        chunks,
+        upload_id,
+        backend_url,
+        progress_callback=None,
+        headers_provider=headers_provider,
+    )
+    if not result:
+        raise RuntimeError("Failed to complete chunked update")
+    return result
 
 
 def _chunked_upload(
@@ -1857,8 +1956,11 @@ def _chunked_upload(
     if progress_callback:
         progress_callback(0, total_chunks + 2, "Initializing chunked upload...")
 
-    # Get auth headers for Bearer token authentication
-    auth_headers = get_auth_headers()
+    def headers_provider() -> Dict[str, str]:
+        # Refresh token if needed between chunks.
+        headers = get_auth_headers()
+        headers["Content-Type"] = "application/json"
+        return headers
 
     # Step 1: Initialize upload session (now returns share_url immediately)
     try:
@@ -1877,7 +1979,7 @@ def _chunked_upload(
         response = httpx.post(
             f"{backend_url}/api/share/chunk/init",
             json=init_payload,
-            headers=auth_headers,
+            headers=headers_provider(),
             timeout=30.0,
         )
         response.raise_for_status()
@@ -1902,7 +2004,7 @@ def _chunked_upload(
         # but user already has the share URL displayed
         thread = threading.Thread(
             target=_upload_chunks_and_complete,
-            args=(chunks, upload_id, backend_url, None, auth_headers),  # No callback in background
+            args=(chunks, upload_id, backend_url, None, headers_provider),  # No callback in background
             daemon=False,  # Important: let thread complete before process exits
         )
         thread.start()
@@ -1917,14 +2019,17 @@ def _chunked_upload(
         }
 
     # Foreground mode: upload chunks synchronously
-    _upload_chunks_and_complete(chunks, upload_id, backend_url, progress_callback, auth_headers)
-
-    return {
-        "share_id": share_id,
-        "share_url": share_url,
-        "admin_token": admin_token,
-        "expiry_at": expiry_at,
-    }
+    result = _upload_chunks_and_complete(
+        chunks, upload_id, backend_url, progress_callback, headers_provider
+    )
+    if not result:
+        raise RuntimeError("Failed to complete chunked upload")
+    # Preserve init fields if server didn't echo them
+    result.setdefault("share_id", share_id)
+    result.setdefault("share_url", share_url)
+    result.setdefault("admin_token", admin_token)
+    result.setdefault("expiry_at", expiry_at)
+    return result
 
 
 def upload_to_backend_unencrypted(
@@ -2032,8 +2137,10 @@ def _chunked_upload_unencrypted(
     if progress_callback:
         progress_callback(0, total_chunks + 2, "Initializing chunked upload...")
 
-    # Get auth headers for Bearer token authentication
-    auth_headers = get_auth_headers()
+    def headers_provider() -> Dict[str, str]:
+        headers = get_auth_headers()
+        headers["Content-Type"] = "application/json"
+        return headers
 
     # Step 1: Initialize upload session (now returns share_url immediately)
     try:
@@ -2048,7 +2155,7 @@ def _chunked_upload_unencrypted(
         response = httpx.post(
             f"{backend_url}/api/share/chunk/init",
             json=init_payload,
-            headers=auth_headers,
+            headers=headers_provider(),
             timeout=30.0,
         )
         response.raise_for_status()
@@ -2073,7 +2180,7 @@ def _chunked_upload_unencrypted(
         # but user already has the share URL displayed
         thread = threading.Thread(
             target=_upload_chunks_and_complete,
-            args=(chunks, upload_id, backend_url, None, auth_headers),  # No callback in background
+            args=(chunks, upload_id, backend_url, None, headers_provider),  # No callback in background
             daemon=False,  # Important: let thread complete before process exits
         )
         thread.start()
@@ -2088,14 +2195,16 @@ def _chunked_upload_unencrypted(
         }
 
     # Foreground mode: upload chunks synchronously
-    _upload_chunks_and_complete(chunks, upload_id, backend_url, progress_callback, auth_headers)
-
-    return {
-        "share_id": share_id,
-        "share_url": share_url,
-        "admin_token": admin_token,
-        "expiry_at": expiry_at,
-    }
+    result = _upload_chunks_and_complete(
+        chunks, upload_id, backend_url, progress_callback, headers_provider
+    )
+    if not result:
+        raise RuntimeError("Failed to complete chunked upload")
+    result.setdefault("share_id", share_id)
+    result.setdefault("share_url", share_url)
+    result.setdefault("admin_token", admin_token)
+    result.setdefault("expiry_at", expiry_at)
+    return result
 
 
 def clean_text_for_prompt(text: str) -> str:
@@ -3093,6 +3202,10 @@ def export_shares_interactive_command(
         if not json_output:
             print("Error: Not logged in. Please run 'aline login' first.", file=sys.stderr)
         return 1
+    if not get_auth_headers():
+        if not json_output:
+            print("Error: Login expired. Please run 'aline login' again.", file=sys.stderr)
+        return 1
 
     # Get backend URL
     if backend_url is None:
@@ -3784,6 +3897,12 @@ def export_agent_shares_command(
         if not json_output:
             print("Error: Not logged in. Please run 'aline login' first.", file=sys.stderr)
         return 1
+    # is_logged_in() can be true with an expired token + refresh_token; ensure we actually have an access token
+    # before attempting uploads (otherwise the server returns 401/403 and the UX is confusing).
+    if not get_auth_headers():
+        if not json_output:
+            print("Error: Login expired. Please run 'aline login' again.", file=sys.stderr)
+        return 1
 
     _progress("Fetching agent info...")
 
@@ -3990,14 +4109,18 @@ def export_agent_shares_command(
                 metadata=metadata,
                 backend_url=backend_url,
                 ui_metadata=conversation_data.get("ui_metadata"),
-                background=True,
+                background=False,
             )
         else:
+            def upload_progress(current: int, total: int, message: str) -> None:
+                _progress(f"{message} ({current}/{total})")
+
             result = upload_to_backend_unencrypted(
                 conversation_data=conversation_data,
                 metadata=metadata,
                 backend_url=backend_url,
-                background=True,
+                progress_callback=upload_progress,
+                background=False,
             )
     except Exception as e:
         if not json_output:

realign/commands/sync_agent.py

@@ -240,6 +240,58 @@ def sync_agent_command(
         if new_local_turns:
             sessions_pushed += 1
 
+    # Skip push if there's nothing new to send.
+    # This avoids re-uploading large, unchanged payloads (which can hit serverless limits and show up as 403/413).
+    needs_push_metadata = False
+    try:
+        remote_title = remote_event.get("title")
+        remote_desc = remote_event.get("description")
+
+        local_title = agent_info.name
+        local_desc = agent_info.description
+
+        has_metadata_diff = (remote_title != local_title) or (remote_desc != local_desc)
+        if has_metadata_diff and not description_updated:
+            remote_updated_at = remote_event.get("updated_at")
+            remote_dt = None
+            if isinstance(remote_updated_at, str) and remote_updated_at:
+                try:
+                    remote_dt = datetime.fromisoformat(remote_updated_at.replace("Z", "+00:00"))
+                except Exception:
+                    remote_dt = None
+
+            local_dt = getattr(agent_info, "updated_at", None)
+            if hasattr(local_dt, "tzinfo") and local_dt and local_dt.tzinfo is None:
+                local_dt = local_dt.replace(tzinfo=timezone.utc)
+
+            # If remote has no timestamp, assume local should win. Otherwise, push only if local is newer.
+            if remote_dt is None or (local_dt and remote_dt and local_dt > remote_dt):
+                needs_push_metadata = True
+    except Exception as e:
+        logger.warning(f"Failed to compute metadata push necessity (non-fatal): {e}")
+
+    if sessions_pushed == 0 and not needs_push_metadata:
+        now_iso = datetime.now(timezone.utc).isoformat()
+        try:
+            db.update_agent_sync_metadata(
+                agent_id,
+                last_synced_at=now_iso,
+                sync_version=remote_sync_version,
+            )
+        except Exception as e:
+            logger.warning(f"Failed to update local sync metadata after no-op sync: {e}")
+
+        _progress("No changes to push.")
+        _progress("Sync complete!")
+
+        return {
+            "success": True,
+            "sessions_pulled": sessions_pulled,
+            "sessions_pushed": 0,
+            "description_updated": description_updated,
+            "new_sync_version": remote_sync_version,
+        }
+
     # Build full conversation data for push
     merged_conversation = _build_merged_conversation_data(
         agent_info=agent_info,

realign/dashboard/app.py

@@ -58,9 +58,7 @@ class AlineDashboard(App):
         self._native_terminal_mode = self._detect_native_mode()
         self._local_api_server = None
         self._apply_saved_theme()
-        logger.info(
-            f"AlineDashboard initialized (native_terminal={self._native_terminal_mode})"
-        )
+        logger.info(f"AlineDashboard initialized (native_terminal={self._native_terminal_mode})")
 
     def _detect_native_mode(self) -> bool:
         """Detect if native terminal mode should be used."""
@@ -204,6 +202,7 @@ class AlineDashboard(App):
         self._quit_confirm_deadline = now + self._quit_confirm_window_s
         self.notify("Press Ctrl+C again to quit", title="Quit", timeout=2)
 
+
 def run_dashboard(use_native_terminal: bool | None = None) -> None:
     """Run the Aline Dashboard.
 

realign/dashboard/tmux_manager.py

@@ -196,16 +196,17 @@ def _session_id_from_transcript_path(transcript_path: str | None) -> str | None:
 def _load_terminal_state_from_db() -> dict[str, dict[str, str]]:
     """Load terminal state from database (best-effort)."""
     import time as _time
+
     t0 = _time.time()
     try:
         from ..db import get_database
 
         t1 = _time.time()
         db = get_database(read_only=True)
-        logger.info(f"[PERF] _load_terminal_state_from_db get_database: {_time.time() - t1:.3f}s")
+        logger.debug(f"[PERF] _load_terminal_state_from_db get_database: {_time.time() - t1:.3f}s")
         t2 = _time.time()
         agents = db.list_agents(status="active", limit=100)
-        logger.info(f"[PERF] _load_terminal_state_from_db list_agents: {_time.time() - t2:.3f}s")
+        logger.debug(f"[PERF] _load_terminal_state_from_db list_agents: {_time.time() - t2:.3f}s")
 
         out: dict[str, dict[str, str]] = {}
         for agent in agents:
@@ -711,13 +712,14 @@ def ensure_right_pane(width_percent: int = 50) -> bool:
 
 def list_inner_windows() -> list[InnerWindow]:
     import time as _time
+
     t0 = _time.time()
     if not ensure_inner_session():
         return []
-    logger.info(f"[PERF] list_inner_windows ensure_inner_session: {_time.time() - t0:.3f}s")
+    logger.debug(f"[PERF] list_inner_windows ensure_inner_session: {_time.time() - t0:.3f}s")
     t1 = _time.time()
     state = _load_terminal_state()
-    logger.info(f"[PERF] list_inner_windows _load_terminal_state: {_time.time() - t1:.3f}s")
+    logger.debug(f"[PERF] list_inner_windows _load_terminal_state: {_time.time() - t1:.3f}s")
     out = (
         _run_inner_tmux(
             [
@@ -840,6 +842,7 @@ def list_inner_windows() -> list[InnerWindow]:
 
 def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
     import time as _time
+
     if not ensure_inner_session():
         return False
     ok = True
@@ -848,7 +851,7 @@ def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
         # Important: these are per-window (not session-wide) to avoid cross-tab clobbering.
         if _run_inner_tmux(["set-option", "-w", "-t", window_id, key, value]).returncode != 0:
             ok = False
-        logger.info(f"[PERF] set_inner_window_options {key}: {_time.time() - t0:.3f}s")
+        logger.debug(f"[PERF] set_inner_window_options {key}: {_time.time() - t0:.3f}s")
     return ok
 
 
@@ -868,15 +871,16 @@ def create_inner_window(
     no_track: bool = False,
 ) -> InnerWindow | None:
     import time as _time
+
     t0 = _time.time()
-    logger.info(f"[PERF] create_inner_window START")
+    logger.debug("[PERF] create_inner_window START")
     if not ensure_right_pane():
         return None
-    logger.info(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
+    logger.debug(f"[PERF] create_inner_window ensure_right_pane: {_time.time() - t0:.3f}s")
 
     t1 = _time.time()
     existing = list_inner_windows()
-    logger.info(f"[PERF] create_inner_window list_inner_windows: {_time.time() - t1:.3f}s")
+    logger.debug(f"[PERF] create_inner_window list_inner_windows: {_time.time() - t1:.3f}s")
     name = _unique_name((w.window_name for w in existing), base_name)
 
     # Record creation time before creating the window
@@ -897,7 +901,7 @@ def create_inner_window(
         ],
         capture=True,
     )
-    logger.info(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
+    logger.debug(f"[PERF] create_inner_window new-window: {_time.time() - t2:.3f}s")
     if proc.returncode != 0:
         return None
 
@@ -923,7 +927,7 @@ def create_inner_window(
         opts.setdefault(OPT_NO_TRACK, "")
     t3 = _time.time()
     set_inner_window_options(window_id, opts)
-    logger.info(f"[PERF] create_inner_window set_options: {_time.time() - t3:.3f}s")
+    logger.debug(f"[PERF] create_inner_window set_options: {_time.time() - t3:.3f}s")
 
     _run_inner_tmux(["select-window", "-t", window_id])
 
@@ -947,10 +951,7 @@ def select_inner_window(window_id: str) -> bool:
 def focus_right_pane() -> bool:
     """Focus the right pane (terminal area) in the outer tmux layout."""
     return (
-        _run_outer_tmux(
-            ["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"]
-        ).returncode
-        == 0
+        _run_outer_tmux(["select-pane", "-t", f"{OUTER_SESSION}:{OUTER_WINDOW}.1"]).returncode == 0
     )
 
 

realign/dashboard/widgets/agents_panel.py

@@ -6,6 +6,7 @@ import asyncio
 import json as _json
 import re
 import shlex
+import time
 from pathlib import Path
 from typing import Optional
 
@@ -171,6 +172,7 @@ class AgentsPanel(Container, can_focus=True):
         self._share_agent_id: Optional[str] = None
         self._sync_agent_id: Optional[str] = None
         self._refresh_timer = None
+        self._last_refresh_error_at: float | None = None
 
     def compose(self) -> ComposeResult:
         with Horizontal(classes="summary"):
@@ -180,7 +182,8 @@ class AgentsPanel(Container, can_focus=True):
 
     def on_show(self) -> None:
         if self._refresh_timer is None:
-            self._refresh_timer = self.set_interval(1.0, self._on_refresh_timer)
+            # Refresh frequently, but avoid hammering SQLite/tmux (can cause transient empty UI).
+            self._refresh_timer = self.set_interval(2.0, self._on_refresh_timer)
         else:
             try:
                 self._refresh_timer.resume()
@@ -212,100 +215,127 @@ class AgentsPanel(Container, can_focus=True):
 
     def _collect_agents(self) -> list[dict]:
         """Collect agent info with their terminals."""
-        agents = []
-        try:
-            from ...db import get_database
+        agents: list[dict] = []
 
-            db = get_database(read_only=True)
-            agent_infos = db.list_agent_info()
+        from ...db import get_database
+
+        # Dashboard should prefer correctness/stability over ultra-low lock timeouts.
+        db = get_database(read_only=True, connect_timeout_seconds=2.0)
+
+        # Critical: if this fails, let it surface as a worker ERROR so we can keep
+        # the last rendered UI instead of flashing an empty agent list.
+        agent_infos = db.list_agent_info()
+
+        # Best-effort: missing pieces should degrade gracefully (names still render).
+        try:
             active_terminals = db.list_agents(status="active", limit=1000)
+        except Exception as e:
+            logger.debug(f"Failed to list active terminals: {e}")
+            active_terminals = []
 
-            # Latest window links per terminal (V23)
+        try:
             latest_links = db.list_latest_window_links(limit=2000)
-            link_by_terminal = {l.terminal_id: l for l in latest_links if l.terminal_id}
+        except Exception:
+            latest_links = []
+        link_by_terminal = {
+            l.terminal_id: l for l in latest_links if getattr(l, "terminal_id", None)
+        }
 
-            # Get tmux windows to retrieve window id and fallback session_id
+        try:
             tmux_windows = tmux_manager.list_inner_windows()
-            terminal_to_window = {
-                w.terminal_id: w for w in tmux_windows if w.terminal_id
-            }
+        except Exception as e:
+            logger.debug(f"Failed to list tmux windows: {e}")
+            tmux_windows = []
+        terminal_to_window = {
+            w.terminal_id: w for w in tmux_windows if getattr(w, "terminal_id", None)
+        }
 
-            # Collect all session_ids for title lookup
-            session_ids: list[str] = []
-            for t in active_terminals:
-                link = link_by_terminal.get(t.id)
-                if link and link.session_id:
-                    session_ids.append(link.session_id)
-                    continue
+        # Collect all session_ids for title lookup
+        session_ids: list[str] = []
+        for t in active_terminals:
+            link = link_by_terminal.get(t.id)
+            if link and getattr(link, "session_id", None):
+                session_ids.append(link.session_id)
+                continue
+            window = terminal_to_window.get(t.id)
+            if window and getattr(window, "session_id", None):
+                session_ids.append(window.session_id)
+
+        titles = self._fetch_session_titles(session_ids)
+
+        # Map agent_info.id -> list of terminals
+        agent_to_terminals: dict[str, list[dict]] = {}
+        for t in active_terminals:
+            # Find which agent_info this terminal belongs to
+            agent_info_id = None
+
+            link = link_by_terminal.get(t.id)
+
+            # Method 1: Check source field for "agent:{agent_info_id}" format
+            source = t.source or ""
+            if source.startswith("agent:"):
+                agent_info_id = source[6:]
+
+            # Method 2: WindowLink agent_id
+            if not agent_info_id and link and getattr(link, "agent_id", None):
+                agent_info_id = link.agent_id
+
+            # Method 3: Fallback - check tmux window's session.agent_id
+            if not agent_info_id:
                 window = terminal_to_window.get(t.id)
-                if window and window.session_id:
-                    session_ids.append(window.session_id)
-
-            titles = self._fetch_session_titles(session_ids)
-
-            # Map agent_info.id -> list of terminals
-            agent_to_terminals: dict[str, list[dict]] = {}
-            for t in active_terminals:
-                # Find which agent_info this terminal belongs to
-                agent_info_id = None
-
-                link = link_by_terminal.get(t.id)
-
-                # Method 1: Check source field for "agent:{agent_info_id}" format
-                source = t.source or ""
-                if source.startswith("agent:"):
-                    agent_info_id = source[6:]
-
-                # Method 2: WindowLink agent_id
-                if not agent_info_id and link and link.agent_id:
-                    agent_info_id = link.agent_id
-
-                # Method 3: Fallback - check tmux window's session.agent_id
-                if not agent_info_id:
-                    window = terminal_to_window.get(t.id)
-                    if window and window.session_id:
+                if window and getattr(window, "session_id", None):
+                    try:
                         session = db.get_session_by_id(window.session_id)
-                        if session:
-                            agent_info_id = session.agent_id
+                    except Exception:
+                        session = None
+                    if session:
+                        agent_info_id = session.agent_id
 
-                if agent_info_id:
-                    if agent_info_id not in agent_to_terminals:
-                        agent_to_terminals[agent_info_id] = []
+            if agent_info_id:
+                agent_to_terminals.setdefault(agent_info_id, [])
 
-                    # Get session_id from windowlink (preferred) or tmux window
-                    window = terminal_to_window.get(t.id)
-                    session_id = (
-                        link.session_id if link and link.session_id else (window.session_id if window else None)
-                    )
-                    title = titles.get(session_id, "") if session_id else ""
-
-                    agent_to_terminals[agent_info_id].append(
-                        {
-                            "terminal_id": t.id,
-                            "session_id": session_id,
-                            "provider": link.provider if link and link.provider else (t.provider or ""),
-                            "session_type": t.session_type or "",
-                            "title": title,
-                            "cwd": t.cwd or "",
-                        }
+                # Get session_id from windowlink (preferred) or tmux window
+                window = terminal_to_window.get(t.id)
+                session_id = (
+                    link.session_id
+                    if link and getattr(link, "session_id", None)
+                    else (
+                        window.session_id
+                        if window and getattr(window, "session_id", None)
+                        else None
                     )
+                )
+                title = titles.get(session_id, "") if session_id else ""
 
-            for info in agent_infos:
-                terminals = agent_to_terminals.get(info.id, [])
-                agents.append(
+                agent_to_terminals[agent_info_id].append(
                     {
-                        "id": info.id,
-                        "name": info.name,
-                        "description": info.description or "",
-                        "terminals": terminals,
-                        "share_url": getattr(info, "share_url", None),
-                        "last_synced_at": getattr(info, "last_synced_at", None),
+                        "terminal_id": t.id,
+                        "session_id": session_id,
+                        "provider": (
+                            link.provider
+                            if link and getattr(link, "provider", None)
+                            else (t.provider or "")
+                        ),
+                        "session_type": t.session_type or "",
+                        "title": title,
+                        "cwd": t.cwd or "",
                     }
                 )
-        except Exception as e:
-            logger.debug(f"Failed to collect agents: {e}")
-        return agents
 
+        for info in agent_infos:
+            terminals = agent_to_terminals.get(info.id, [])
+            agents.append(
+                {
+                    "id": info.id,
+                    "name": info.name,
+                    "description": info.description or "",
+                    "terminals": terminals,
+                    "share_url": getattr(info, "share_url", None),
+                    "last_synced_at": getattr(info, "last_synced_at", None),
+                }
+            )
+
+        return agents
 
     @staticmethod
     def _fingerprint(agents: list[dict]) -> str:
@@ -319,9 +349,21 @@ class AgentsPanel(Container, can_focus=True):
         # Handle refresh worker
         if self._refresh_worker is not None and event.worker is self._refresh_worker:
             if event.state == WorkerState.ERROR:
-                self._agents = []
+                # Keep the last successfully-rendered list on refresh errors to avoid
+                # flashing an empty Agents tab during transient tmux/SQLite hiccups.
+                self._last_refresh_error_at = time.monotonic()
+                err = self._refresh_worker.error
+                if isinstance(err, BaseException):
+                    logger.warning(
+                        "Agents refresh failed",
+                        exc_info=(type(err), err, err.__traceback__),
+                    )
+                else:
+                    logger.warning(f"Agents refresh failed: {err}")
+                return
             elif event.state == WorkerState.SUCCESS:
                 self._agents = self._refresh_worker.result or []
+                self._last_refresh_error_at = None
             else:
                 return
             fp = self._fingerprint(self._agents)
@@ -329,7 +371,10 @@ class AgentsPanel(Container, can_focus=True):
                 return  # nothing changed – skip re-render to avoid flicker
             self._rendered_fingerprint = fp
             self.run_worker(
-                self._render_agents(), group="agents-render", exclusive=True
+                self._render_agents(),
+                group="agents-render",
+                exclusive=True,
+                exit_on_error=False,
             )
             return
 
@@ -345,117 +390,123 @@ class AgentsPanel(Container, can_focus=True):
         async with self._refresh_lock:
             try:
                 container = self.query_one("#agents-list", Vertical)
-            except Exception:
-                return
-
-            await container.remove_children()
+                await container.remove_children()
 
-            if not self._agents:
-                await container.mount(
-                    Static("No agents yet. Click 'Create Agent' to add one.")
-                )
-                return
+                if not self._agents:
+                    await container.mount(Static("No agents yet. Click 'Create Agent' to add one."))
+                    return
 
-            for agent in self._agents:
-                safe_id = self._safe_id(agent["id"])
+                for agent in self._agents:
+                    safe_id = self._safe_id(agent["id"])
 
-                # Agent row with name, create button, and delete button
-                row = Horizontal(classes="agent-row")
-                await container.mount(row)
+                    # Agent row with name, create button, and delete button
+                    row = Horizontal(classes="agent-row")
+                    await container.mount(row)
 
-                # Agent name button
-                name_label = Text(agent["name"], style="bold")
-                terminal_count = len(agent["terminals"])
-                if terminal_count > 0:
-                    name_label.append(f" ({terminal_count})", style="dim")
+                    # Agent name button
+                    name_label = Text(agent["name"], style="bold")
+                    terminal_count = len(agent["terminals"])
+                    if terminal_count > 0:
+                        name_label.append(f" ({terminal_count})", style="dim")
 
-                await row.mount(
-                    AgentNameButton(
+                    agent_btn = AgentNameButton(
                         name_label,
                         id=f"agent-{safe_id}",
                         name=agent["id"],
                         classes="agent-name",
                     )
-                )
+                    if agent.get("description"):
+                        agent_btn.tooltip = agent["description"]
+                    await row.mount(agent_btn)
 
-                # Share or Sync button (Sync if agent already has a share_url)
-                if agent.get("share_url"):
-                    await row.mount(
-                        Button(
-                            "Sync",
-                            id=f"sync-{safe_id}",
-                            name=agent["id"],
-                            classes="agent-share",
+                    # Share or Sync button (Sync if agent already has a share_url)
+                    if agent.get("share_url"):
+                        await row.mount(
+                            Button(
+                                "Sync",
+                                id=f"sync-{safe_id}",
+                                name=agent["id"],
+                                classes="agent-share",
+                            )
                         )
-                    )
-                    # Link button to copy share URL to clipboard
+                        await row.mount(
+                            Button(
+                                "Link",
+                                id=f"link-{safe_id}",
+                                name=agent["id"],
+                                classes="agent-share",
+                            )
+                        )
+                    else:
+                        await row.mount(
+                            Button(
+                                "Share",
+                                id=f"share-{safe_id}",
+                                name=agent["id"],
+                                classes="agent-share",
+                            )
+                        )
+
+                    # Create terminal button
                     await row.mount(
                         Button(
-                            "Link",
-                            id=f"link-{safe_id}",
+                            "+ Term",
+                            id=f"create-term-{safe_id}",
                             name=agent["id"],
-                            classes="agent-share",
+                            classes="agent-create",
                         )
                     )
-                else:
+
+                    # Delete agent button
                     await row.mount(
                         Button(
-                            "Share",
-                            id=f"share-{safe_id}",
+                            "✕",
+                            id=f"delete-{safe_id}",
                             name=agent["id"],
-                            classes="agent-share",
+                            variant="error",
+                            classes="agent-delete",
                         )
                     )
 
-                # Create terminal button
-                await row.mount(
-                    Button(
-                        "+ Term",
-                        id=f"create-term-{safe_id}",
-                        name=agent["id"],
-                        classes="agent-create",
-                    )
-                )
-
-                # Delete agent button
-                await row.mount(
-                    Button(
-                        "✕",
-                        id=f"delete-{safe_id}",
-                        name=agent["id"],
-                        variant="error",
-                        classes="agent-delete",
-                    )
-                )
-
-                # Terminal list (indented under agent)
-                if agent["terminals"]:
-                    term_list = Vertical(classes="terminal-list")
-                    await container.mount(term_list)
-
-                    for term in agent["terminals"]:
-                        term_safe_id = self._safe_id(term["terminal_id"])
-                        term_row = Horizontal(classes="terminal-row")
-                        await term_list.mount(term_row)
-
-                        label = self._make_terminal_label(term)
-                        await term_row.mount(
-                            Button(
-                                label,
-                                id=f"switch-{term_safe_id}",
-                                name=term["terminal_id"],
-                                classes="terminal-switch",
+                    # Terminal list (indented under agent)
+                    if agent["terminals"]:
+                        term_list = Vertical(classes="terminal-list")
+                        await container.mount(term_list)
+
+                        for term in agent["terminals"]:
+                            term_safe_id = self._safe_id(term["terminal_id"])
+                            term_row = Horizontal(classes="terminal-row")
+                            await term_list.mount(term_row)
+
+                            label = self._make_terminal_label(term)
+                            await term_row.mount(
+                                Button(
+                                    label,
+                                    id=f"switch-{term_safe_id}",
+                                    name=term["terminal_id"],
+                                    classes="terminal-switch",
+                                )
                             )
-                        )
-                        await term_row.mount(
-                            Button(
-                                "✕",
-                                id=f"close-{term_safe_id}",
-                                name=term["terminal_id"],
-                                variant="error",
-                                classes="terminal-close",
+                            await term_row.mount(
+                                Button(
+                                    "✕",
+                                    id=f"close-{term_safe_id}",
+                                    name=term["terminal_id"],
+                                    variant="error",
+                                    classes="terminal-close",
+                                )
                             )
-                        )
+            except Exception:
+                logger.exception("Failed to render agents list")
+                try:
+                    container = self.query_one("#agents-list", Vertical)
+                    await container.remove_children()
+                    await container.mount(
+                        Static("Agents UI error (see ~/.aline/.logs/dashboard.log)")
+                    )
+                except Exception:
+                    pass
+                return
 
     def _make_terminal_label(self, term: dict) -> Text:
         """Generate label for a terminal."""
@@ -613,9 +664,7 @@ class AgentsPanel(Container, can_focus=True):
         if result:
             if result.get("imported"):
                 n = result.get("sessions_imported", 0)
-                self.app.notify(
-                    f"Imported: {result.get('name')} ({n} sessions)", title="Agent"
-                )
+                self.app.notify(f"Imported: {result.get('name')} ({n} sessions)", title="Agent")
             else:
                 self.app.notify(f"Created: {result.get('name')}", title="Agent")
         self.refresh_data()
@@ -653,11 +702,10 @@ class AgentsPanel(Container, can_focus=True):
 
         # Create the terminal with agent association
         self.run_worker(
-            self._do_create_terminal(
-                agent_type, workspace, skip_permissions, no_track, agent_id
-            ),
+            self._do_create_terminal(agent_type, workspace, skip_permissions, no_track, agent_id),
             group="terminal-create",
             exclusive=True,
+            exit_on_error=False,
         )
 
     async def _do_create_terminal(
@@ -670,9 +718,7 @@ class AgentsPanel(Container, can_focus=True):
     ) -> None:
         """Actually create the terminal with agent association."""
         if agent_type == "claude":
-            await self._create_claude_terminal(
-                workspace, skip_permissions, no_track, agent_id
-            )
+            await self._create_claude_terminal(workspace, skip_permissions, no_track, agent_id)
         elif agent_type == "codex":
             await self._create_codex_terminal(workspace, no_track, agent_id)
         elif agent_type == "opencode":
@@ -748,13 +794,9 @@ class AgentsPanel(Container, can_focus=True):
             except Exception:
                 pass
         else:
-            self.app.notify(
-                "Failed to create terminal", title="Agent", severity="error"
-            )
+            self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
-    async def _create_codex_terminal(
-        self, workspace: str, no_track: bool, agent_id: str
-    ) -> None:
+    async def _create_codex_terminal(self, workspace: str, no_track: bool, agent_id: str) -> None:
         """Create a Codex terminal associated with an agent."""
         try:
             from ...db import get_database
@@ -817,9 +859,7 @@ class AgentsPanel(Container, can_focus=True):
         except Exception:
             pass
 
-        command = self._command_in_directory(
-            tmux_manager.zsh_run_and_keep_open("codex"), workspace
-        )
+        command = self._command_in_directory(tmux_manager.zsh_run_and_keep_open("codex"), workspace)
 
         created = tmux_manager.create_inner_window(
             "codex",
@@ -831,9 +871,7 @@ class AgentsPanel(Container, can_focus=True):
         )
 
         if not created:
-            self.app.notify(
-                "Failed to create terminal", title="Agent", severity="error"
-            )
+            self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
     async def _create_opencode_terminal(self, workspace: str, agent_id: str) -> None:
         """Create an Opencode terminal associated with an agent."""
@@ -892,9 +930,7 @@ class AgentsPanel(Container, can_focus=True):
             except Exception:
                 pass
         else:
-            self.app.notify(
-                "Failed to create terminal", title="Agent", severity="error"
-            )
+            self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
     async def _create_zsh_terminal(self, workspace: str, agent_id: str) -> None:
         """Create a zsh terminal associated with an agent."""
@@ -951,9 +987,7 @@ class AgentsPanel(Container, can_focus=True):
             except Exception:
                 pass
         else:
-            self.app.notify(
-                "Failed to create terminal", title="Agent", severity="error"
-            )
+            self.app.notify("Failed to create terminal", title="Agent", severity="error")
 
     def _install_claude_hooks(self, workspace: str) -> None:
         """Install Claude hooks for a workspace."""
@@ -980,12 +1014,8 @@ class AgentsPanel(Container, can_focus=True):
 
             project_root = Path(workspace)
             install_stop_hook(get_stop_settings_path(project_root), quiet=True)
-            install_user_prompt_submit_hook(
-                get_submit_settings_path(project_root), quiet=True
-            )
-            install_permission_request_hook(
-                get_permission_settings_path(project_root), quiet=True
-            )
+            install_user_prompt_submit_hook(get_submit_settings_path(project_root), quiet=True)
+            install_permission_request_hook(get_permission_settings_path(project_root), quiet=True)
         except Exception:
             pass
 
@@ -1064,14 +1094,10 @@ class AgentsPanel(Container, can_focus=True):
             db = get_database(read_only=True)
             sessions = db.get_sessions_by_agent_id(agent_id)
             if not sessions:
-                self.app.notify(
-                    "Agent has no sessions to share", title="Share", severity="warning"
-                )
+                self.app.notify("Agent has no sessions to share", title="Share", severity="warning")
                 return
         except Exception as e:
-            self.app.notify(
-                f"Failed to check sessions: {e}", title="Share", severity="error"
-            )
+            self.app.notify(f"Failed to check sessions: {e}", title="Share", severity="error")
             return
 
         # Store agent_id for the worker callback
@@ -1128,9 +1154,7 @@ class AgentsPanel(Container, can_focus=True):
                         try:
                             match = re.search(r"\{.*\}", output, re.DOTALL)
                             if match:
-                                result["json"] = json_module.loads(
-                                    match.group(0), strict=False
-                                )
+                                result["json"] = json_module.loads(match.group(0), strict=False)
                         except Exception:
                             result["json"] = None
 
@@ -1165,9 +1189,7 @@ class AgentsPanel(Container, can_focus=True):
         share_link = payload.get("share_link") or payload.get("share_url")
         if not share_link:
             share_link = result.get("share_link_guess")
-        slack_message = (
-            payload.get("slack_message") if isinstance(payload, dict) else None
-        )
+        slack_message = payload.get("slack_message") if isinstance(payload, dict) else None
         if not slack_message:
             try:
                 from ...db import get_database
@@ -1190,17 +1212,13 @@ class AgentsPanel(Container, can_focus=True):
             copied = copy_text(self.app, text_to_copy)
 
             suffix = " (copied)" if copied else ""
-            self.app.notify(
-                f"Share link: {share_link}{suffix}", title="Share", timeout=6
-            )
+            self.app.notify(f"Share link: {share_link}{suffix}", title="Share", timeout=6)
         elif exit_code == 0:
             self.app.notify("Share completed", title="Share", timeout=3)
         else:
             extra = result.get("stderr") or ""
             suffix = f": {extra}" if extra else ""
-            self.app.notify(
-                f"Share failed (exit {exit_code}){suffix}", title="Share", timeout=6
-            )
+            self.app.notify(f"Share failed (exit {exit_code}){suffix}", title="Share", timeout=6)
 
     async def _sync_agent(self, agent_id: str) -> None:
         """Sync all sessions for an agent with remote share."""