aline-ai 0.6.7__py3-none-any.whl → 0.7.1__py3-none-any.whl

{aline_ai-0.6.7.dist-info → aline_ai-0.7.1.dist-info}/METADATA

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

{aline_ai-0.6.7.dist-info → aline_ai-0.7.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
-aline_ai-0.6.7.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=_XHUZdw-wtPtpgm845liUkFT-VXg86ZiqDK3pdnnh9Q,1623
+aline_ai-0.7.1.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=_ikWZs8Kc7Dp8xrIk27RttwL5TafxGktkWaWc0WLK68,1623
 realign/agent_names.py,sha256=H4oVJMkqg1ZYCk58vD_Jh9apaAHSFJRswa-C9SPdJxc,1171
 realign/auth.py,sha256=d_1yvCwluN5iIrdgjtuSKpOYAksDzrzNgntKacLVJrw,16583
 realign/claude_detector.py,sha256=ZLSJacMo6zzQclXByABKA70UNpstxqIv3fPGqdpA934,2792
-realign/cli.py,sha256=IctmQ0OTb6kLlWRFRQumdhY6-CpcpFtocdc68KiwxvM,37748
+realign/cli.py,sha256=PiMUA_sFQ-K7zlIr1Ahs7St8NwcXDG3JKT_8yIqLwZI,40569
 realign/codex_detector.py,sha256=WGIClvlrFVCqJ5vR9DrKVsp1eJhOShvcaXibTHb0Nfc,6304
 realign/codex_home.py,sha256=ljkW8uCfQD4cisEJtPNQmIgaR0yEfWSyHwoVQFY-6p4,4374
 realign/codex_terminal_linker.py,sha256=L2Ha4drlZ7Sbq2jzXyxczOdUY3S5fu1gJqoI5WN9CKk,6211
@@ -16,9 +16,9 @@ realign/logging_config.py,sha256=LCAigKFhTj86PSJm4-kUl3Ag9h_GENh3x2iPnMv7qUI,487
 realign/mcp_server.py,sha256=LWiQ2qukYoNLsoV2ID2f0vF9jkJlBvB587HpM5jymgE,10193
 realign/mcp_watcher.py,sha256=aK4jWStv7CoCroS4tXFHgZ_y_-q4QDjrpWgm4DxcEj4,1260
 realign/redactor.py,sha256=Zsoi5HfYak2yPmck20JArhm-1cPSB78IdkBJiNVXfrc,17096
-realign/watcher_core.py,sha256=XOJarc_jjlf51Gj8ytcdEeaDUkVIq3Ow0bMbFHbKfAM,116690
+realign/watcher_core.py,sha256=iXVXlDhYsoxk_BZ1rOVIfTDu6ABXZO18UeNQKVPsvzc,120374
 realign/watcher_daemon.py,sha256=OHUQ9P1LlagKJHfrf6uRnzO-zDtBRXIxt8ydMFHf5S8,3475
-realign/worker_core.py,sha256=IXDFvkmeboOUvWyNJ3iZ7xlfxAulPnmFlAtuuJSdgRo,12362
+realign/worker_core.py,sha256=tJGETH_FIBpb899D8-JP_cOyDE63BYc8kxxmrhb83i4,13013
 realign/worker_daemon.py,sha256=X7Xyjw_u6m6KG4E84nx0HpDFw4cWMv8ja1G8btc9PiM,3957
 realign/adapters/__init__.py,sha256=alkJr7DRn_CrJecSJRjRJOHHnkz9EnZ5TnsU8n1Bb0k,719
 realign/adapters/base.py,sha256=2IdAZKGjg5gPB3YLf_8r3V4XAdbK7fHpj06GjjsYEFY,7409
@@ -37,21 +37,21 @@ realign/claude_hooks/user_prompt_submit_hook_installer.py,sha256=2xLF8yZcE7Iwib9
 realign/commands/__init__.py,sha256=WVaVT1orM2Z0PYaG3X6tkKb_t2v3n_3siCadh1qd_QA,107
 realign/commands/add.py,sha256=_Xzt9P15mwndA3JvBBVrki8tn9Cc0UP6SiLwM4RS8Nc,27232
 realign/commands/agent.py,sha256=3CS48bMn7tkdDWKRrfg7CYbhcJK4Pz40YjYMvwD7c2w,3173
-realign/commands/auth.py,sha256=QrPukpP-ogYEDSwztV0NOYI-HDgn5fPxlCQ1-e2n7gU,11082
+realign/commands/auth.py,sha256=wcs1lUcSXxv75WcGruzyZ3kgi0xXA8W4lNnUwM4a3CI,11731
 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=b8dpVBx2HkbHVk9pSFXnErlAr0umciAOPpuxvTJyOBI,148467
-realign/commands/import_shares.py,sha256=qAH007WCQ6bwWP09MEJVmgJlRC8c-QicB2HYvMBqyRM,32966
+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=XRcHN00TjfzGwTw3O_OXqb9Yj0lMFfDX0S7oizVpS6E,12454
+realign/commands/sync_agent.py,sha256=VS_VU-4LdZpUbRKx51Gg0BFXPWZlnyROZAsahWsexIQ,14824
 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=e257euP0gR9nA0w1susuLkG9tnYQk1IJJdgAICnIYxs,10398
+realign/dashboard/app.py,sha256=IXF9CDbui4zXufRgc6Gagje7Duw5VlewUru4njbA6lQ,8243
 realign/dashboard/clipboard.py,sha256=81frq83E_urqLkwuCvtl0hiTEjavtdQn8kCi72jJWcs,1207
 realign/dashboard/layout.py,sha256=sZxmFj6QTbkois9MHTvBEMMcnaRVehCDqugdbiFx10k,9072
 realign/dashboard/terminal_backend.py,sha256=MlDfwtqhftyQK6jDNizQGFjAWIo5Bx2TDpSnP3MCZVM,3375
@@ -69,8 +69,8 @@ realign/dashboard/screens/help_screen.py,sha256=Icrcvbgyz49R2tBiu8vBZ4CLm6iYclv_
 realign/dashboard/screens/session_detail.py,sha256=TBkHqSHyMxsLB2QdZq9m1EoiH8oRVDbPrjt-a8I9sHs,9561
 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=33qjCa6WCQ7XojRiStdR73jX2xpKV_RlBqodVDQWkxs,577
-realign/dashboard/widgets/agents_panel.py,sha256=TtOX9RlF0CuwRTe1sXoo1xaf7ZykJA-YFmMu0-SKe2g,43299
+realign/dashboard/widgets/__init__.py,sha256=dXsOnbeu_8XhP-6Bu6-R_0LNGqsSM6x7dG7FCDumpa8,460
+realign/dashboard/widgets/agents_panel.py,sha256=CGs3qcHGcDDVIpDw1ERb8Jf2t-l--hSY_ufw9SZzM8E,43846
 realign/dashboard/widgets/config_panel.py,sha256=eRJRuqImQ8eJIKCEj4O8EvYxI-ht_anrcYbT5JskWyU,15972
 realign/dashboard/widgets/events_table.py,sha256=0cMvE0KdZFBZyvywv7vlt005qsR0aLQnQiMf3ZzK7RY,30218
 realign/dashboard/widgets/header.py,sha256=0HHCFXX7F3C6HII-WDwOJwWkJrajmKPWmdoMWyOkn9E,1587
@@ -104,8 +104,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.6.7.dist-info/METADATA,sha256=GyI08kzWpN5QDEsgynocnlk8Cp5zSTiKXRltp86xrsM,1597
-aline_ai-0.6.7.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aline_ai-0.6.7.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
-aline_ai-0.6.7.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.6.7.dist-info/RECORD,,
+aline_ai-0.7.1.dist-info/METADATA,sha256=Kj-SGQc0F5dLAvywJrieZbtE93ZkjCqPnozlsSgt_Ds,1597
+aline_ai-0.7.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aline_ai-0.7.1.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
+aline_ai-0.7.1.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.7.1.dist-info/RECORD,,

realign/__init__.py

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

realign/cli.py

@@ -127,7 +127,7 @@ def main(
 
         from .dashboard.app import AlineDashboard
 
-        dashboard = AlineDashboard(dev_mode=dev, use_native_terminal=use_native_terminal)
+        dashboard = AlineDashboard(use_native_terminal=use_native_terminal)
         dashboard.run()
 
 
@@ -311,6 +311,76 @@ def agent_share_cli(
     raise typer.Exit(code=exit_code)
 
 
+@agent_app.command(name="import")
+def agent_import_cli(
+    share_url: str = typer.Argument(..., help="Share URL to import agent from"),
+    password: Optional[str] = typer.Option(
+        None, "--password", "-p", help="Password for encrypted share"
+    ),
+):
+    """Import an agent from a share link.
+
+    Downloads the shared agent data and creates a local agent with all its sessions.
+    For unencrypted shares, sync is automatically enabled so you can push/pull updates.
+
+    Examples:
+        aline agent import https://realign-server.vercel.app/share/abc123
+        aline agent import https://realign-server.vercel.app/share/xyz789 --password mypass
+    """
+    from .commands.import_shares import import_agent_from_share
+
+    result = import_agent_from_share(share_url=share_url, password=password)
+
+    if result["success"]:
+        console.print(f"\n[green]✅ Agent imported successfully![/green]")
+        console.print(f"[cyan]Agent ID:[/cyan] {result['agent_id']}")
+        console.print(f"[cyan]Agent Name:[/cyan] {result['agent_name']}")
+        if result.get('agent_description'):
+            console.print(f"[cyan]Description:[/cyan] {result['agent_description'][:100]}...")
+        console.print(f"[cyan]Sessions imported:[/cyan] {result['sessions_imported']}")
+        console.print(f"[cyan]Turns imported:[/cyan] {result['turns_imported']}")
+        if result.get('sync_enabled'):
+            console.print(f"\n[green]✓ Sync enabled![/green] Use 'aline agent sync {result['agent_id'][:8]}' to sync updates.")
+        raise typer.Exit(code=0)
+    else:
+        console.print(f"\n[red]❌ Import failed:[/red] {result['error']}")
+        raise typer.Exit(code=1)
+
+
+@agent_app.command(name="sync")
+def agent_sync_cli(
+    agent_id: str = typer.Argument(..., help="Agent ID to sync"),
+):
+    """Sync an agent's sessions with the remote share.
+
+    Performs bidirectional sync: pulls new sessions from remote, merges locally,
+    then pushes merged state back. Uses optimistic locking to handle conflicts.
+
+    Only works with agents that were shared or imported with sync enabled.
+
+    Examples:
+        aline agent sync abc123de
+    """
+    from .commands.sync_agent import sync_agent_command
+
+    def progress_callback(msg: str) -> None:
+        console.print(f"[dim]{msg}[/dim]")
+
+    result = sync_agent_command(agent_id=agent_id, progress_callback=progress_callback)
+
+    if result["success"]:
+        console.print(f"\n[green]✅ Sync completed![/green]")
+        console.print(f"[cyan]Sessions pulled:[/cyan] {result['sessions_pulled']}")
+        console.print(f"[cyan]Sessions pushed:[/cyan] {result['sessions_pushed']}")
+        if result.get('description_updated'):
+            console.print(f"[cyan]Description updated:[/cyan] Yes")
+        console.print(f"[cyan]New sync version:[/cyan] {result['new_sync_version']}")
+        raise typer.Exit(code=0)
+    else:
+        console.print(f"\n[red]❌ Sync failed:[/red] {result['error']}")
+        raise typer.Exit(code=1)
+
+
 @add_app.command(name="tmux")
 def add_tmux_cli():
     """Install tmux via Homebrew and set up Aline tmux clipboard bindings."""
@@ -1022,9 +1092,7 @@ def dashboard(
 
         from .dashboard.app import AlineDashboard
 
-        # Use dev flag from this command or inherit from parent context
-        dev_mode = dev or (ctx.obj.get("dev", False) if ctx.obj else False)
-        dash = AlineDashboard(dev_mode=dev_mode, use_native_terminal=use_native_terminal)
+        dash = AlineDashboard(use_native_terminal=use_native_terminal)
         dash.run()
     except Exception as e:
         logger.error(f"Dashboard crashed: {e}\n{traceback.format_exc()}")

realign/commands/auth.py

@@ -170,6 +170,10 @@ def login_command() -> int:
         print("User ID synced to local config")
 
     logger.info(f"Login successful for {credentials.email}")
+
+    # Start watcher and worker daemons after login
+    _start_daemons()
+
     return 0
 
 
@@ -227,6 +231,22 @@ def logout_command() -> int:
     return 0
 
 
+def _start_daemons() -> None:
+    """Start watcher and worker daemons if not already running."""
+    try:
+        from . import watcher as watcher_cmd
+
+        exit_code = watcher_cmd.watcher_start_command()
+        if exit_code == 0:
+            if console:
+                console.print("[dim]Watcher and worker daemons started.[/dim]")
+            logger.info("Daemons started after login")
+        else:
+            logger.debug(f"watcher_start_command returned {exit_code}")
+    except Exception as e:
+        logger.debug(f"Failed to start daemons after login: {e}")
+
+
 def _stop_daemons() -> None:
     """Stop watcher and worker daemons."""
     import os

realign/commands/import_shares.py

@@ -202,9 +202,9 @@ def import_agent_from_share(
             total_turns += import_result["turns"]
         except Exception as e:
             logger.error(f"Failed to import session {session_id}: {e}")
-            continue
+            # Don't continue - still try to link the session if it exists
 
-        # Link session to agent
+        # Link session to agent (always attempt, even if import was skipped/failed)
         try:
             db.update_session_agent_id(session_id, agent_id)
         except Exception as e:

realign/commands/sync_agent.py

@@ -74,9 +74,19 @@ def sync_agent_command(
     # 1. Load local state
     _progress("Loading local agent data...")
 
+    # Support prefix matching for agent_id
     agent_info = db.get_agent_info(agent_id)
     if not agent_info:
-        return {"success": False, "error": f"Agent not found: {agent_id}"}
+        # Try prefix match
+        all_agents = db.list_agent_info()
+        matches = [a for a in all_agents if a.id.startswith(agent_id)]
+        if len(matches) == 1:
+            agent_info = matches[0]
+            agent_id = agent_info.id
+        elif len(matches) > 1:
+            return {"success": False, "error": f"Ambiguous agent_id prefix '{agent_id}' matches {len(matches)} agents"}
+        else:
+            return {"success": False, "error": f"Agent not found: {agent_id}"}
 
     if not agent_info.share_id or not agent_info.share_url:
         return {"success": False, "error": "Agent has no share metadata (not shared yet)"}
@@ -88,6 +98,29 @@ def sync_agent_command(
     share_id = agent_info.share_id
     local_sync_version = agent_info.sync_version or 0
 
+    # Repair: backfill agent_id on sessions linked via windowlink but missing agent_id.
+    # This handles Claude sessions where the watcher created the session before the
+    # agent_id was known (race between polling and stop-hook signals).
+    try:
+        conn = db._get_connection()
+        unlinked = conn.execute(
+            """SELECT DISTINCT w.session_id
+               FROM windowlink w
+               JOIN sessions s ON s.id = w.session_id
+               WHERE w.agent_id = ?
+                 AND (s.agent_id IS NULL OR s.agent_id = '')""",
+            (agent_id,),
+        ).fetchall()
+        for row in unlinked:
+            sid = row[0]
+            if sid:
+                db.update_session_agent_id(sid, agent_id)
+                logger.info(f"Sync repair: linked session {sid} to agent {agent_id}")
+        if unlinked:
+            _progress(f"Repaired {len(unlinked)} unlinked session(s)")
+    except Exception as e:
+        logger.warning(f"Session repair step failed (non-fatal): {e}")
+
     local_sessions = db.get_sessions_by_agent_id(agent_id)
     local_content_hashes = db.get_agent_content_hashes(agent_id)
 
@@ -129,29 +162,44 @@ def sync_agent_command(
         session_id = session_data.get("session_id", "")
         session_turns = session_data.get("turns", [])
 
-        # Check if any turns in this session are new to us
+        # Check if any turns in this session are new to THIS AGENT (not globally)
         new_turns = [
             t for t in session_turns
             if t.get("content_hash") and t["content_hash"] not in local_content_hashes
         ]
 
-        if not new_turns:
+        # Check if session exists and whether it's linked to this agent
+        existing_session = db.get_session_by_id(session_id)
+        session_is_new = existing_session is None
+        session_needs_linking = existing_session and existing_session.agent_id != agent_id
+
+        # Import if: new turns, or session is new, or session needs linking
+        if not new_turns and not session_is_new and not session_needs_linking:
             continue
 
         # Import the session (import_session_with_turns handles dedup by content_hash)
+        should_count = session_is_new or session_needs_linking
         try:
             # Suppress auto-summaries during sync
             os.environ["REALIGN_DISABLE_AUTO_SUMMARIES"] = "1"
             import_result = import_session_with_turns(
                 session_data, f"agent-{agent_id}", agent_info.share_url, db, force=False
             )
-            if import_result.get("sessions", 0) > 0 or import_result.get("turns", 0) > 0:
+            # Count as pulled if: created new session/turns, or session was new/needed linking
+            if (import_result.get("sessions", 0) > 0 or import_result.get("turns", 0) > 0
+                    or should_count):
+                sessions_pulled += 1
+        except Exception as e:
+            logger.error(f"Failed to import remote session {session_id}: {e}")
+            # Still count if we intended to import this session
+            if should_count:
                 sessions_pulled += 1
 
-            # Link session to agent
+        # Always link session to agent (even if import was skipped)
+        try:
             db.update_session_agent_id(session_id, agent_id)
         except Exception as e:
-            logger.error(f"Failed to import remote session {session_id}: {e}")
+            logger.error(f"Failed to link session {session_id} to agent: {e}")
 
     # Merge name/description: last-write-wins by updated_at
     description_updated = False

realign/dashboard/app.py

@@ -13,8 +13,6 @@ from textual.widgets import Footer, TabbedContent, TabPane
 from ..logging_config import setup_logger
 from .widgets import (
     AlineHeader,
-    WatcherPanel,
-    WorkerPanel,
     ConfigPanel,
     AgentsPanel,
 )
@@ -64,30 +62,24 @@ class AlineDashboard(App):
         Binding("?", "help", "Help"),
         Binding("tab", "next_tab", "Next Tab", priority=True, show=False),
         Binding("shift+tab", "prev_tab", "Prev Tab", priority=True, show=False),
-        Binding("n", "page_next", "Next Page", show=False),
-        Binding("p", "page_prev", "Prev Page", show=False),
-        Binding("s", "switch_view", "Switch View", show=False),
         Binding("ctrl+c", "quit_confirm", "Quit", priority=True),
     ]
 
     _quit_confirm_window_s: float = 1.2
 
-    def __init__(self, dev_mode: bool = False, use_native_terminal: bool | None = None):
+    def __init__(self, use_native_terminal: bool | None = None):
         """Initialize the dashboard.
 
         Args:
-            dev_mode: If True, shows developer tabs (Watcher, Worker).
             use_native_terminal: If True, use native terminal backend (iTerm2/Kitty).
                                  If False, use tmux.
                                  If None (default), auto-detect from ALINE_TERMINAL_MODE env var.
         """
         super().__init__()
-        self.dev_mode = dev_mode
         self.use_native_terminal = use_native_terminal
         self._native_terminal_mode = self._detect_native_mode()
         logger.info(
-            f"AlineDashboard initialized (dev_mode={dev_mode}, "
-            f"native_terminal={self._native_terminal_mode})"
+            f"AlineDashboard initialized (native_terminal={self._native_terminal_mode})"
         )
 
     def _detect_native_mode(self) -> bool:
@@ -103,15 +95,9 @@ class AlineDashboard(App):
         logger.debug("compose() started")
         try:
             yield AlineHeader()
-            tab_ids = self._tab_ids()
-            with TabbedContent(initial=tab_ids[0] if tab_ids else "agents"):
+            with TabbedContent(initial="agents"):
                 with TabPane("Agents", id="agents"):
                     yield AgentsPanel()
-                if self.dev_mode:
-                    with TabPane("Watcher", id="watcher"):
-                        yield WatcherPanel()
-                    with TabPane("Worker", id="worker"):
-                        yield WorkerPanel()
                 with TabPane("Config", id="config"):
                     yield ConfigPanel()
             yield Footer()
@@ -121,8 +107,6 @@ class AlineDashboard(App):
             raise
 
     def _tab_ids(self) -> list[str]:
-        if self.dev_mode:
-            return ["agents", "watcher", "worker", "config"]
         return ["agents", "config"]
 
     def on_mount(self) -> None:
@@ -207,43 +191,9 @@ class AlineDashboard(App):
 
         if active_tab_id == "agents":
             self.query_one(AgentsPanel).refresh_data()
-        elif active_tab_id == "watcher":
-            self.query_one(WatcherPanel).refresh_data()
-        elif active_tab_id == "worker":
-            self.query_one(WorkerPanel).refresh_data()
         elif active_tab_id == "config":
             self.query_one(ConfigPanel).refresh_data()
 
-    def action_page_next(self) -> None:
-        """Go to next page in current panel."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        if active_tab_id == "watcher":
-            self.query_one(WatcherPanel).action_next_page()
-        elif active_tab_id == "worker":
-            self.query_one(WorkerPanel).action_next_page()
-
-    def action_page_prev(self) -> None:
-        """Go to previous page in current panel."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        if active_tab_id == "watcher":
-            self.query_one(WatcherPanel).action_prev_page()
-        elif active_tab_id == "worker":
-            self.query_one(WorkerPanel).action_prev_page()
-
-    def action_switch_view(self) -> None:
-        """Switch view in current panel (if supported)."""
-        tabbed_content = self.query_one(TabbedContent)
-        active_tab_id = tabbed_content.active
-
-        if active_tab_id == "watcher":
-            self.query_one(WatcherPanel).action_switch_view()
-        elif active_tab_id == "worker":
-            self.query_one(WorkerPanel).action_switch_view()
-
     def action_help(self) -> None:
         """Show help information."""
         from .screens import HelpScreen

realign/dashboard/widgets/__init__.py

@@ -1,8 +1,6 @@
 """Aline Dashboard Widgets."""
 
 from .header import AlineHeader
-from .watcher_panel import WatcherPanel
-from .worker_panel import WorkerPanel
 from .sessions_table import SessionsTable
 from .events_table import EventsTable
 from .config_panel import ConfigPanel
@@ -12,8 +10,6 @@ from .agents_panel import AgentsPanel
 
 __all__ = [
     "AlineHeader",
-    "WatcherPanel",
-    "WorkerPanel",
     "SessionsTable",
     "EventsTable",
     "ConfigPanel",

realign/dashboard/widgets/agents_panel.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+import json as _json
 import re
 import shlex
 from pathlib import Path
@@ -163,6 +164,7 @@ class AgentsPanel(Container, can_focus=True):
         super().__init__()
         self._refresh_lock = asyncio.Lock()
         self._agents: list[dict] = []
+        self._rendered_fingerprint: str = ""
         self._refresh_worker: Optional[Worker] = None
         self._share_worker: Optional[Worker] = None
         self._sync_worker: Optional[Worker] = None
@@ -178,7 +180,7 @@ class AgentsPanel(Container, can_focus=True):
 
     def on_show(self) -> None:
         if self._refresh_timer is None:
-            self._refresh_timer = self.set_interval(30.0, self._on_refresh_timer)
+            self._refresh_timer = self.set_interval(1.0, self._on_refresh_timer)
         else:
             try:
                 self._refresh_timer.resume()
@@ -305,6 +307,14 @@ class AgentsPanel(Container, can_focus=True):
         return agents
 
 
+    @staticmethod
+    def _fingerprint(agents: list[dict]) -> str:
+        """Fast serialisation used only for change detection."""
+        try:
+            return _json.dumps(agents, sort_keys=True, default=str)
+        except Exception:
+            return ""
+
     def on_worker_state_changed(self, event: Worker.StateChanged) -> None:
         # Handle refresh worker
         if self._refresh_worker is not None and event.worker is self._refresh_worker:
@@ -314,6 +324,10 @@ class AgentsPanel(Container, can_focus=True):
                 self._agents = self._refresh_worker.result or []
             else:
                 return
+            fp = self._fingerprint(self._agents)
+            if fp == self._rendered_fingerprint:
+                return  # nothing changed – skip re-render to avoid flicker
+            self._rendered_fingerprint = fp
             self.run_worker(
                 self._render_agents(), group="agents-render", exclusive=True
             )

realign/watcher_core.py

@@ -245,12 +245,129 @@ class DialogueWatcher:
         # a new run may take over and re-process it to avoid permanent stuck states.
         self.processing_turn_ttl_seconds = 20 * 60  # 20 minutes
 
+        # Layer 1: Session list cache (avoid re-scanning directories every 0.5s)
+        self._cached_session_list: list[Path] = []
+        self._session_list_last_scan: float = 0.0
+        self._session_list_scan_interval: float = 30.0
+
+        # Layer 2: Per-cycle sizes stash (shared between check_for_changes and idle check)
+        self._last_cycle_sizes: Dict[str, int] = {}
+
+        # Layer 3: Turn count cache (avoid re-parsing JSONL for unchanged files)
+        self._cached_turn_counts: dict[str, int] = {}
+        self._cached_total_turn_counts: dict[str, int] = {}
+        self._turn_count_file_stats: dict[str, tuple[float, int]] = {}
+
         # Signal directory for Stop hook integration
         self.signal_dir = Path.home() / ".aline" / ".signals"
         self.signal_dir.mkdir(parents=True, exist_ok=True)
         self.user_prompt_signal_dir = self.signal_dir / "user_prompt_submit"
         self.user_prompt_signal_dir.mkdir(parents=True, exist_ok=True)
 
+    def _get_cached_session_list(self, force_rescan: bool = False) -> list[Path]:
+        """Return cached list of active session files, re-scanning only every 30s.
+
+        Args:
+            force_rescan: If True, bypass the time gate and re-scan immediately.
+        """
+        now = time.time()
+        if (
+            not force_rescan
+            and self._cached_session_list
+            and (now - self._session_list_last_scan) < self._session_list_scan_interval
+        ):
+            return self._cached_session_list
+
+        try:
+            self._cached_session_list = find_all_active_sessions(self.config, project_path=None)
+            self._session_list_last_scan = now
+        except PermissionError:
+            if not hasattr(self, "_permission_error_logged"):
+                self._permission_error_logged = True
+                logger.error("PERMISSION DENIED: Cannot access Claude Code sessions directory")
+        except Exception as e:
+            logger.error(f"Error scanning session list: {e}", exc_info=True)
+
+        return self._cached_session_list
+
+    def _get_cycle_session_stats(self) -> tuple[list[Path], Dict[str, int], Dict[str, float]]:
+        """Single stat() pass per cycle over the cached session list.
+
+        Returns:
+            (session_files, sizes_dict, mtimes_dict)
+        """
+        session_files = self._get_cached_session_list()
+        sizes: Dict[str, int] = {}
+        mtimes: Dict[str, float] = {}
+        force_rescan = False
+
+        for session_file in list(session_files):  # copy so we can mutate
+            path_key = str(session_file)
+            try:
+                if session_file.is_dir():
+                    # Handle directory-based sessions (e.g., Antigravity brain directories)
+                    artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
+                    total_size = 0
+                    max_mtime = 0.0
+                    for artifact_name in artifacts:
+                        artifact_path = session_file / artifact_name
+                        if artifact_path.exists():
+                            artifact_stat = artifact_path.stat()
+                            total_size += artifact_stat.st_size
+                            max_mtime = max(max_mtime, artifact_stat.st_mtime)
+                    if max_mtime > 0:
+                        sizes[path_key] = total_size
+                        mtimes[path_key] = max_mtime
+                else:
+                    stat = session_file.stat()
+                    sizes[path_key] = stat.st_size
+                    mtimes[path_key] = stat.st_mtime
+            except FileNotFoundError:
+                # File disappeared — prune from cache, force re-scan next cycle
+                if session_file in self._cached_session_list:
+                    self._cached_session_list.remove(session_file)
+                force_rescan = True
+            except Exception as e:
+                logger.debug(f"Error stat-ing {path_key}: {e}")
+
+        if force_rescan:
+            self._session_list_last_scan = 0.0  # Force re-scan next cycle
+
+        live_files = [f for f in session_files if str(f) in sizes]
+        return live_files, sizes, mtimes
+
+    def _get_cached_turn_counts(
+        self, session_file: Path, current_mtime: float, current_size: int
+    ) -> tuple[int, int]:
+        """Return (completed_turns, total_turns) for a session, using cache when file unchanged.
+
+        Args:
+            session_file: Path to the session file.
+            current_mtime: The mtime from the current cycle's stat pass.
+            current_size: The size from the current cycle's stat pass.
+
+        Returns:
+            (completed_turn_count, total_turn_count)
+        """
+        path_key = str(session_file)
+        cached_stats = self._turn_count_file_stats.get(path_key)
+
+        if cached_stats and cached_stats == (current_mtime, current_size):
+            return (
+                self._cached_turn_counts.get(path_key, 0),
+                self._cached_total_turn_counts.get(path_key, 0),
+            )
+
+        # File changed — re-parse
+        completed = self._count_complete_turns(session_file)
+        total = self._get_total_turn_count(session_file)
+
+        self._cached_turn_counts[path_key] = completed
+        self._cached_total_turn_counts[path_key] = total
+        self._turn_count_file_stats[path_key] = (current_mtime, current_size)
+
+        return completed, total
+
     def _maybe_link_codex_terminal(self, session_file: Path) -> None:
         """Best-effort: bind a Codex session file to the most likely active Codex terminal."""
         try:
@@ -468,11 +585,15 @@ class DialogueWatcher:
                 if self.config.enable_temp_turn_titles:
                     await self._check_user_prompt_submit_signals()
 
+                # Single stat pass per cycle (Layer 2)
+                cycle_sessions, cycle_sizes, cycle_mtimes = self._get_cycle_session_stats()
+                self._last_cycle_sizes = cycle_sizes
+
                 # Priority 2: Fallback polling mechanism (with debounce)
-                await self.check_for_changes()
+                await self.check_for_changes(cycle_sizes, cycle_mtimes)
 
                 # Check for idle sessions that need final commit
-                await self._check_idle_sessions_for_final_commit()
+                await self._check_idle_sessions_for_final_commit(cycle_sessions, cycle_mtimes)
 
                 await asyncio.sleep(0.5)  # Check every 0.5 seconds for responsiveness
             except Exception as e:
@@ -555,7 +676,15 @@ class DialogueWatcher:
                                 logger.warning(
                                     f"Failed to enqueue stop-hook job for {session_id}: {e}"
                                 )
-                                continue
+
+                            # Directly link session to agent (in case the turn job
+                            # was already processed by polling without agent_id
+                            # and the new enqueue was deduped).
+                            if agent_id and session_id:
+                                try:
+                                    db.update_session_agent_id(session_id, agent_id)
+                                except Exception:
+                                    pass
 
                             logger.info(
                                 f"Enqueued turn_summary via Stop hook: {session_id} turn {target_turn} ({project_path.name})"
@@ -737,66 +866,11 @@ class DialogueWatcher:
     def _get_session_stats(self) -> tuple[Dict[str, int], Dict[str, float]]:
         """Get (sizes, mtimes) for all active session files.
 
-        For directory-based sessions (e.g., Antigravity), computes:
-        - size: sum of all artifact file sizes
-        - mtime: max mtime of all artifact files
-
-        This ensures changes to individual artifacts are detected.
+        Delegates to _get_cycle_session_stats() which uses the cached session list
+        and performs a single stat() pass.
         """
-        sizes: Dict[str, int] = {}
-        mtimes: Dict[str, float] = {}
-        try:
-            session_files = find_all_active_sessions(self.config, project_path=None)
-            for session_file in session_files:
-                if not session_file.exists():
-                    continue
-                path_key = str(session_file)
-
-                # Handle directory-based sessions (e.g., Antigravity brain directories)
-                if session_file.is_dir():
-                    # Check for Antigravity-style artifacts
-                    artifacts = ["task.md", "walkthrough.md", "implementation_plan.md"]
-                    total_size = 0
-                    max_mtime = 0.0
-
-                    for artifact_name in artifacts:
-                        artifact_path = session_file / artifact_name
-                        if artifact_path.exists():
-                            artifact_stat = artifact_path.stat()
-                            total_size += artifact_stat.st_size
-                            max_mtime = max(max_mtime, artifact_stat.st_mtime)
-
-                    # Only track if at least one artifact exists
-                    if max_mtime > 0:
-                        sizes[path_key] = total_size
-                        mtimes[path_key] = max_mtime
-                else:
-                    # Regular file-based session
-                    stat = session_file.stat()
-                    sizes[path_key] = stat.st_size
-                    mtimes[path_key] = stat.st_mtime
-
-            logger.debug(f"Tracked {len(sizes)} session file(s) across all projects")
-        except PermissionError as e:
-            # macOS permission issue - only log once
-            if not hasattr(self, "_permission_error_logged"):
-                self._permission_error_logged = True
-                logger.error("PERMISSION DENIED: Cannot access Claude Code sessions directory")
-                print(
-                    "[Watcher] ✗ PERMISSION DENIED: Cannot access ~/.claude/projects/",
-                    file=sys.stderr,
-                )
-                print(
-                    "[Watcher] ⓘ Grant Full Disk Access to Acme in System Preferences",
-                    file=sys.stderr,
-                )
-                print(
-                    "[Watcher] ⓘ System Preferences → Privacy & Security → Full Disk Access → Add Acme",
-                    file=sys.stderr,
-                )
-        except Exception as e:
-            logger.error(f"Error getting session stats: {e}", exc_info=True)
-            print(f"[Watcher] Error getting session stats: {e}", file=sys.stderr)
+        _, sizes, mtimes = self._get_cycle_session_stats()
+        logger.debug(f"Tracked {len(sizes)} session file(s) across all projects")
         return sizes, mtimes
 
     def _get_session_sizes(self) -> Dict[str, int]:
@@ -965,23 +1039,22 @@ class DialogueWatcher:
             logger.warning(f"Failed to compute hash for {session_file.name}: {e}")
             return None
 
-    async def _check_idle_sessions_for_final_commit(self):
+    async def _check_idle_sessions_for_final_commit(self, session_files: Optional[list[Path]] = None, current_mtimes: Optional[Dict[str, float]] = None):
         """Check for idle sessions and trigger final commits if needed."""
         try:
             current_time = time.time()
-            # Always use multi-project mode (project_path=None)
-            session_files = find_all_active_sessions(self.config, project_path=None)
+            if session_files is None:
+                session_files = self._get_cached_session_list()
+            if current_mtimes is None:
+                _, _, current_mtimes = self._get_cycle_session_stats()
 
             for session_file in session_files:
-                if not session_file.exists():
-                    continue
-
                 session_path = str(session_file)
+                mtime = current_mtimes.get(session_path)
+                if mtime is None:
+                    continue
 
                 try:
-                    # Get current mtime
-                    mtime = session_file.stat().st_mtime
-
                     # Initialize tracking if first time seeing this session
                     if session_path not in self.last_session_mtimes:
                         self.last_session_mtimes[session_path] = mtime
@@ -1010,13 +1083,16 @@ class DialogueWatcher:
 
                         session_id = session_file.stem
                         session_type = self._detect_session_type(session_file)
-                        completed_count = self._count_complete_turns(session_file)
+                        # Use cached turn counts (Layer 3) — avoids re-parsing unchanged files
+                        file_size = self._last_cycle_sizes.get(session_path, 0)
+                        completed_count, total_turns = self._get_cached_turn_counts(
+                            session_file, mtime, file_size
+                        )
                         last_count = self.last_stop_reason_counts.get(session_path, 0)
 
                         # For Claude, also consider the last turn (not counted in completed_count).
                         last_turn_to_enqueue: Optional[int] = None
                         if session_type == "claude":
-                            total_turns = self._get_total_turn_count(session_file)
                             if total_turns > completed_count:
                                 existing = db.get_turn_by_number(session_id, int(total_turns))
                                 if existing is None:
@@ -1221,10 +1297,11 @@ class DialogueWatcher:
             logger.error(f"Trigger error for {session_file.name}: {e}")
             return 0
 
-    async def check_for_changes(self):
+    async def check_for_changes(self, current_sizes: Optional[Dict[str, int]] = None, current_mtimes: Optional[Dict[str, float]] = None):
         """Check if any session file has been modified."""
         try:
-            current_sizes, current_mtimes = self._get_session_stats()
+            if current_sizes is None or current_mtimes is None:
+                current_sizes, current_mtimes = self._get_session_stats()
 
             # Detect changed files
             changed_files = []

realign/worker_core.py

@@ -279,6 +279,8 @@ class AlineWorker:
             return
 
         agent_info_id = None
+
+        # Method 1: Match via agents table session_id (works for Codex)
         for agent in agents:
             try:
                 if (agent.session_id or "").strip() != session_id:
@@ -290,6 +292,21 @@ class AlineWorker:
             except Exception:
                 continue
 
+        # Method 2: Match via windowlink table (works for Claude)
+        if not agent_info_id:
+            try:
+                conn = self.db._get_connection()
+                row = conn.execute(
+                    """SELECT w.agent_id FROM windowlink w
+                       WHERE w.session_id = ? AND w.agent_id IS NOT NULL
+                       ORDER BY w.ts DESC LIMIT 1""",
+                    (session_id,),
+                ).fetchone()
+                if row and row[0]:
+                    agent_info_id = row[0]
+            except Exception:
+                pass
+
         if agent_info_id:
             try:
                 self.db.update_session_agent_id(session_id, agent_info_id)