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

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

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

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

@@ -1,13 +1,13 @@
-aline_ai-0.7.0.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=jmqpELzn0PmqMNOgBDumsQui50MdbRXM3-CbTnSxMAg,1623
+aline_ai-0.7.2.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=T1uqzYkOUbzoMzR_BVD5kRPO727lyC6k7hF_RudJoi8,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=mPRzNdPeKeZRLJvHUi8mHsl-fq99ZApkEaB-yjU6Gw0,37567
+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
-realign/config.py,sha256=Znfs43AjiK90LGWnArDPWyrE859sdZQAPIb0KAcU3Ig,9252
+realign/config.py,sha256=_loJkoTKszMONgo6Qq3N8VRm_iqvD-7WvXeCsKUgGUE,9478
 realign/context.py,sha256=8hzgNOg-7_eMW22wt7OM5H9IsmMveKXCv0epG7E0G7w,13917
 realign/file_lock.py,sha256=kLNm1Rra4TCrTMyPM5fwjVascq-CUz2Bzh9HHKtCKOE,3444
 realign/hooks.py,sha256=wSSIjS5x9w7fm9LUcL63Lf7bglEfb75dHFja_znKDDQ,65134
@@ -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
@@ -41,19 +41,21 @@ 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=b8dpVBx2HkbHVk9pSFXnErlAr0umciAOPpuxvTJyOBI,148467
-realign/commands/import_shares.py,sha256=qAH007WCQ6bwWP09MEJVmgJlRC8c-QicB2HYvMBqyRM,32966
+realign/commands/export_shares.py,sha256=76VYTB9r6JVx9rLcimwJ1xwpTNeeQU5TFL4SmTbRY54,148590
+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=gzvbqdujBbFdUY0SNyb66OPjp3e-qnqazinH5ZiPFok,14876
 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=IXF9CDbui4zXufRgc6Gagje7Duw5VlewUru4njbA6lQ,8243
+realign/dashboard/app.py,sha256=gp44tyR3dEJdxx36D-HODpbNh56cw4117zY1ina1chw,8182
 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/backends/__init__.py,sha256=POROX7YKtukYZcLB1pi_kO0sSEpuO3y-hwmF3WIN1Kk,163
@@ -61,7 +63,7 @@ realign/dashboard/backends/iterm2.py,sha256=XYYJT5lrrp4pW_MyEqPZYkRI0qyKUwJlezwM
 realign/dashboard/backends/kitty.py,sha256=5jdkR1f2PwB8a4SnS3EG6uOQ2XU-PB7-cpKBfIJq3hU,12066
 realign/dashboard/screens/__init__.py,sha256=MiefFamCYRrzTwQXiCUdybaJaFxlK5XKtLHaSQmqDv0,597
 realign/dashboard/screens/agent_detail.py,sha256=N-iUC4434C91OcDu4dkQaxS_NXQ5Yl5sqNBb2mTmoBw,10490
-realign/dashboard/screens/create_agent.py,sha256=06uiQYvz-Xvn4Xm689o3tdhzb2HQ0gdzAA1WHVEwziM,11706
+realign/dashboard/screens/create_agent.py,sha256=Dy9liP_4fj_zgNafRRJGX2iQJiarHvtVLdghrqMGiLQ,11323
 realign/dashboard/screens/create_agent_info.py,sha256=K2Rbp4zHVdanPT3Fp82We4qlSAM-0IBZXPLuQuevuME,7838
 realign/dashboard/screens/create_event.py,sha256=oiQY1zKpUYnQU-5fQLeuZH9BV5NClE5B5XZIVBYG5A8,5506
 realign/dashboard/screens/event_detail.py,sha256=-pqt3NBoeTXGJKtbndZy-msklwXTeNWMS4H12oMG5ks,20175
@@ -70,8 +72,8 @@ 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=CGs3qcHGcDDVIpDw1ERb8Jf2t-l--hSY_ufw9SZzM8E,43846
-realign/dashboard/widgets/config_panel.py,sha256=eRJRuqImQ8eJIKCEj4O8EvYxI-ht_anrcYbT5JskWyU,15972
+realign/dashboard/widgets/agents_panel.py,sha256=SEzjDFaMdl9bVhKr0XlhMww68pp9pmIu9HqyFfp5Iaw,45209
+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
 realign/dashboard/widgets/openable_table.py,sha256=GeJPDEYp0kRHShqvmPMzAePpYXRZHUNqcWNnxqsqxjA,1963
@@ -104,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.0.dist-info/METADATA,sha256=nWZ9aGO494Ci9MG8EUIUQSc-uHxHV1MZkQ-4Z1E1x7M,1597
-aline_ai-0.7.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aline_ai-0.7.0.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
-aline_ai-0.7.0.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.7.0.dist-info/RECORD,,
+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,,

realign/__init__.py

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

realign/cli.py

@@ -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."""

realign/commands/export_shares.py

@@ -3956,6 +3956,9 @@ def export_agent_shares_command(
             "description": event_description,
         }
 
+    # Add agent name to ui_metadata for chat display
+    conversation_data["ui_metadata"]["agent_name"] = agent_info.name
+
     # Add MCP instructions if enabled
     if enable_mcp:
         conversation_data["ui_metadata"]["mcp_instructions"] = {

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
@@ -335,7 +383,9 @@ def _build_merged_conversation_data(
         "time": datetime.now(timezone.utc).isoformat(),
         "event": event_data,
         "sessions": sessions_data,
-        "ui_metadata": {},
+        "ui_metadata": {
+            "agent_name": agent_info.name,
+        },
     }
 
     if contributor_token:

realign/config.py

@@ -33,6 +33,9 @@ class ReAlignConfig:
     # Session catch-up settings
     max_catchup_sessions: int = 3  # Max sessions to auto-import on watcher startup
 
+    # Local API server port (for one-click browser import)
+    local_api_port: int = 17280
+
     # Terminal auto-close settings
     auto_close_stale_terminals: bool = False  # Auto-close terminals inactive for 24+ hours
     stale_terminal_hours: int = 24  # Hours of inactivity before auto-closing
@@ -85,13 +88,14 @@ class ReAlignConfig:
             "user_name": os.getenv("REALIGN_USER_NAME"),
             "uid": os.getenv("REALIGN_UID"),
             "max_catchup_sessions": os.getenv("REALIGN_MAX_CATCHUP_SESSIONS"),
+            "local_api_port": os.getenv("ALINE_LOCAL_API_PORT"),
             "auto_close_stale_terminals": os.getenv("REALIGN_AUTO_CLOSE_STALE_TERMINALS"),
             "stale_terminal_hours": os.getenv("REALIGN_STALE_TERMINAL_HOURS"),
         }
 
         for key, value in env_overrides.items():
             if value is not None:
-                if key in ["summary_max_chars", "max_catchup_sessions", "stale_terminal_hours"]:
+                if key in ["summary_max_chars", "max_catchup_sessions", "stale_terminal_hours", "local_api_port"]:
                     config_dict[key] = int(value)
                 elif key in [
                     "redact_on_match",
@@ -139,6 +143,7 @@ class ReAlignConfig:
             "user_name": self.user_name,
             "uid": self.uid,
             "max_catchup_sessions": self.max_catchup_sessions,
+            "local_api_port": self.local_api_port,
             "auto_close_stale_terminals": self.auto_close_stale_terminals,
             "stale_terminal_hours": self.stale_terminal_hours,
         }

realign/dashboard/app.py

@@ -1,8 +1,6 @@
 """Aline Dashboard - Main Application."""
 
 import os
-import subprocess
-import sys
 import time
 import traceback
 
@@ -16,6 +14,7 @@ from .widgets import (
     ConfigPanel,
     AgentsPanel,
 )
+from .state import get_dashboard_state_value
 
 # Environment variable to control terminal mode
 ENV_TERMINAL_MODE = "ALINE_TERMINAL_MODE"
@@ -24,27 +23,6 @@ ENV_TERMINAL_MODE = "ALINE_TERMINAL_MODE"
 logger = setup_logger("realign.dashboard", "dashboard.log")
 
 
-def _detect_system_dark_mode() -> bool:
-    """Detect if the system is in dark mode.
-
-    On macOS, checks AppleInterfaceStyle via defaults command.
-    Returns True for dark mode, False for light mode.
-    """
-    if sys.platform != "darwin":
-        return True  # Default to dark on non-macOS
-
-    try:
-        result = subprocess.run(
-            ["defaults", "read", "-g", "AppleInterfaceStyle"],
-            capture_output=True,
-            text=True,
-            timeout=1,
-        )
-        return result.stdout.strip().lower() == "dark"
-    except Exception:
-        return True  # Default to dark on error
-
-
 def _monotonic() -> float:
     """Small wrapper so tests can patch without affecting global time.monotonic()."""
     return time.monotonic()
@@ -78,6 +56,8 @@ class AlineDashboard(App):
         super().__init__()
         self.use_native_terminal = use_native_terminal
         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})"
         )
@@ -110,14 +90,14 @@ class AlineDashboard(App):
         return ["agents", "config"]
 
     def on_mount(self) -> None:
-        """Apply theme based on system settings and watch for changes."""
+        """Apply dashboard theme based on saved preference."""
         logger.info("on_mount() started")
         try:
-            self._sync_theme()
-            # Check for system theme changes every 2 seconds
-            self.set_interval(2, self._sync_theme)
             self._quit_confirm_deadline: float | None = None
 
+            # Start local API server for one-click browser import
+            self._start_local_api_server()
+
             # Set up side-by-side layout for native terminal mode
             if self._native_terminal_mode:
                 self._setup_native_terminal_layout()
@@ -127,6 +107,25 @@ class AlineDashboard(App):
             logger.error(f"on_mount() failed: {e}\n{traceback.format_exc()}")
             raise
 
+    def _start_local_api_server(self) -> None:
+        """Start the local HTTP API server for browser-based agent import."""
+        try:
+            from ..config import ReAlignConfig
+            from .local_api import LocalAPIServer
+
+            config = ReAlignConfig.load()
+            self._local_api_server = LocalAPIServer(port=config.local_api_port)
+            self._local_api_server.start()
+        except Exception as e:
+            logger.warning(f"Could not start local API server: {e}")
+
+    def _apply_saved_theme(self) -> None:
+        theme_choice = str(get_dashboard_state_value("theme", "dark")).strip().lower()
+        if theme_choice == "light":
+            self.theme = "textual-light"
+        else:
+            self.theme = "textual-dark"
+
     def _setup_native_terminal_layout(self) -> None:
         """Set up side-by-side layout for Dashboard and native terminal."""
         # Skip if using iTerm2 split pane mode (already set up by CLI)
@@ -158,12 +157,6 @@ class AlineDashboard(App):
         except Exception as e:
             logger.warning(f"Could not set up native terminal layout: {e}")
 
-    def _sync_theme(self) -> None:
-        """Sync app theme with system theme."""
-        target_theme = "textual-dark" if _detect_system_dark_mode() else "textual-light"
-        if self.theme != target_theme:
-            self.theme = target_theme
-
     def action_next_tab(self) -> None:
         """Switch to next tab."""
         tabbed_content = self.query_one(TabbedContent)

realign/dashboard/local_api.py

@@ -0,0 +1,122 @@
+"""Local HTTP API server for one-click agent import from browser."""
+
+import json
+import threading
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+from ..logging_config import setup_logger
+
+logger = setup_logger("realign.dashboard.local_api", "local_api.log")
+
+ALLOWED_ORIGINS = [
+    "https://realign-server.vercel.app",
+    "http://localhost:3000",
+]
+
+
+class LocalAPIHandler(BaseHTTPRequestHandler):
+    """Handle local API requests from the browser."""
+
+    def _set_cors_headers(self) -> bool:
+        """Set CORS headers. Returns True if origin is allowed."""
+        origin = self.headers.get("Origin", "")
+        if origin in ALLOWED_ORIGINS:
+            self.send_header("Access-Control-Allow-Origin", origin)
+            self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+            self.send_header("Access-Control-Allow-Headers", "Content-Type")
+            return True
+        return False
+
+    def _send_json(self, status: int, data: dict) -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self._set_cors_headers()
+        self.end_headers()
+        self.wfile.write(json.dumps(data).encode())
+
+    def do_OPTIONS(self) -> None:
+        """Handle CORS preflight."""
+        self.send_response(204)
+        self._set_cors_headers()
+        self.end_headers()
+
+    def do_GET(self) -> None:
+        if self.path == "/api/health":
+            self._send_json(200, {"status": "ok"})
+        else:
+            self._send_json(404, {"error": "not found"})
+
+    def do_POST(self) -> None:
+        if self.path == "/api/import-agent":
+            self._handle_import_agent()
+        else:
+            self._send_json(404, {"error": "not found"})
+
+    def _handle_import_agent(self) -> None:
+        try:
+            length = int(self.headers.get("Content-Length", 0))
+            body = json.loads(self.rfile.read(length)) if length else {}
+        except (json.JSONDecodeError, ValueError):
+            self._send_json(400, {"error": "invalid JSON body"})
+            return
+
+        share_url = body.get("share_url")
+        if not share_url:
+            self._send_json(400, {"error": "share_url is required"})
+            return
+
+        password = body.get("password")
+
+        logger.info(f"Import agent request: {share_url}")
+
+        try:
+            from ..commands.import_shares import import_agent_from_share
+
+            result = import_agent_from_share(share_url, password=password)
+            if result.get("success"):
+                logger.info(
+                    f"Agent imported: {result.get('agent_name')} "
+                    f"({result.get('sessions_imported')} sessions)"
+                )
+                self._send_json(200, result)
+            else:
+                logger.warning(f"Import failed: {result.get('error')}")
+                self._send_json(422, result)
+        except Exception as e:
+            logger.error(f"Import agent error: {e}", exc_info=True)
+            self._send_json(500, {"success": False, "error": str(e)})
+
+    def log_message(self, format: str, *args) -> None:
+        """Suppress default stderr logging; use our logger instead."""
+        logger.debug(f"HTTP {args[0] if args else ''}")
+
+
+class LocalAPIServer:
+    """Manages the local HTTP API server in a daemon thread."""
+
+    def __init__(self, port: int = 17280):
+        self.port = port
+        self._server: HTTPServer | None = None
+        self._thread: threading.Thread | None = None
+
+    def start(self) -> bool:
+        """Start the server. Returns True on success."""
+        try:
+            self._server = HTTPServer(("127.0.0.1", self.port), LocalAPIHandler)
+            self._thread = threading.Thread(
+                target=self._server.serve_forever, daemon=True
+            )
+            self._thread.start()
+            logger.info(f"Local API server started on http://127.0.0.1:{self.port}")
+            return True
+        except OSError as e:
+            logger.warning(f"Failed to start local API server on port {self.port}: {e}")
+            return False
+
+    def stop(self) -> None:
+        """Stop the server."""
+        if self._server:
+            self._server.shutdown()
+            self._server = None
+            self._thread = None
+            logger.info("Local API server stopped")

realign/dashboard/screens/create_agent.py

@@ -15,9 +15,7 @@ from textual.containers import Container, Horizontal, Vertical
 from textual.screen import ModalScreen
 from textual.widgets import Button, Label, RadioButton, RadioSet, Static
 
-
-# State file for storing last workspace path
-DASHBOARD_STATE_FILE = Path.home() / ".aline" / "dashboard_state.json"
+from ..state import DASHBOARD_STATE_FILE, set_dashboard_state_value
 
 
 def _load_last_workspace() -> str:
@@ -80,14 +78,7 @@ def _save_claude_tracking_mode(mode: str) -> None:
 def _save_state(key: str, value: str) -> None:
     """Save a key-value pair to the state file."""
     try:
-        DASHBOARD_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-        state = {}
-        if DASHBOARD_STATE_FILE.exists():
-            with open(DASHBOARD_STATE_FILE, "r", encoding="utf-8") as f:
-                state = json.load(f)
-        state[key] = value
-        with open(DASHBOARD_STATE_FILE, "w", encoding="utf-8") as f:
-            json.dump(state, f, indent=2)
+        set_dashboard_state_value(key, value)
     except Exception:
         pass
 

realign/dashboard/state.py

@@ -0,0 +1,41 @@
+"""Small persistence helpers for dashboard UI state."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+DASHBOARD_STATE_FILE = Path.home() / ".aline" / "dashboard_state.json"
+
+
+def load_dashboard_state() -> dict[str, Any]:
+    try:
+        if not DASHBOARD_STATE_FILE.exists():
+            return {}
+        with open(DASHBOARD_STATE_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def save_dashboard_state(state: dict[str, Any]) -> None:
+    try:
+        DASHBOARD_STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        with open(DASHBOARD_STATE_FILE, "w", encoding="utf-8") as f:
+            json.dump(state, f, indent=2)
+    except Exception:
+        return
+
+
+def get_dashboard_state_value(key: str, default: Any) -> Any:  # noqa: ANN401
+    return load_dashboard_state().get(key, default)
+
+
+def set_dashboard_state_value(key: str, value: Any) -> None:  # noqa: ANN401
+    state = load_dashboard_state()
+    state[key] = value
+    save_dashboard_state(state)
+

realign/dashboard/widgets/agents_panel.py

@@ -388,6 +388,15 @@ class AgentsPanel(Container, can_focus=True):
                             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(
@@ -554,6 +563,11 @@ class AgentsPanel(Container, can_focus=True):
             await self._sync_agent(agent_id)
             return
 
+        if btn_id.startswith("link-"):
+            agent_id = event.button.name or ""
+            await self._copy_share_link(agent_id)
+            return
+
         if btn_id.startswith("switch-"):
             terminal_id = event.button.name or ""
             await self._switch_to_terminal(terminal_id)
@@ -1260,3 +1274,26 @@ class AgentsPanel(Container, can_focus=True):
         else:
             error = result.get("error", "Unknown error")
             self.app.notify(f"Sync failed: {error}", title="Sync", severity="error")
+
+    async def _copy_share_link(self, agent_id: str) -> None:
+        """Copy the share link for an agent to clipboard."""
+        if not agent_id:
+            return
+
+        agent = next((a for a in self._agents if a["id"] == agent_id), None)
+        if not agent:
+            self.app.notify("Agent not found", title="Link", severity="error")
+            return
+
+        share_url = agent.get("share_url")
+        if not share_url:
+            self.app.notify("No share link available", title="Link", severity="warning")
+            return
+
+        copied = copy_text(self.app, share_url)
+        if copied:
+            self.app.notify("Share link copied to clipboard", title="Link", timeout=3)
+        else:
+            self.app.notify(
+                f"Failed to copy. Link: {share_url}", title="Link", severity="warning"
+            )

realign/dashboard/widgets/config_panel.py

@@ -7,6 +7,7 @@ from textual.containers import Horizontal
 from textual.widgets import Button, RadioButton, RadioSet, Static
 
 from ..tmux_manager import _run_outer_tmux
+from ..state import get_dashboard_state_value, set_dashboard_state_value
 from ...auth import (
     load_credentials,
     save_credentials,
@@ -113,6 +114,30 @@ class ConfigPanel(Static):
         width: auto;
         margin-right: 2;
     }
+
+    ConfigPanel .appearance-settings {
+        height: auto;
+        margin-top: 2;
+    }
+
+    ConfigPanel .appearance-settings .setting-row {
+        height: auto;
+    }
+
+    ConfigPanel .appearance-settings .setting-label {
+        width: auto;
+    }
+
+    ConfigPanel .appearance-settings RadioSet {
+        width: auto;
+        height: auto;
+        layout: horizontal;
+    }
+
+    ConfigPanel .appearance-settings RadioButton {
+        width: auto;
+        margin-right: 2;
+    }
     """
 
     def __init__(self) -> None:
@@ -131,6 +156,15 @@ class ConfigPanel(Static):
             yield Static(id="account-email", classes="account-email")
             yield Button("Login", id="auth-btn", variant="primary")
 
+        # Appearance settings section
+        with Static(classes="appearance-settings"):
+            yield Static("[bold]Appearance[/bold]", classes="section-title")
+            with Horizontal(classes="setting-row"):
+                yield Static("Theme:", classes="setting-label")
+                with RadioSet(id="theme-radio"):
+                    yield RadioButton("Dark", id="theme-dark", value=True)
+                    yield RadioButton("Light", id="theme-light")
+
         # Tmux settings section
         with Static(classes="tmux-settings"):
             yield Static("[bold]Tmux Settings[/bold]", classes="section-title")
@@ -160,6 +194,9 @@ class ConfigPanel(Static):
         # Update account status display
         self._update_account_status()
 
+        # Sync theme from persisted preference
+        self._sync_theme_radio()
+
         # Query and set the actual tmux border resize state
         self._sync_border_resize_radio()
 
@@ -184,7 +221,10 @@ class ConfigPanel(Static):
         """Handle radio set change events."""
         if self._syncing_radio:
             return  # Ignore events during sync
-        if event.radio_set.id == "border-resize-radio":
+        if event.radio_set.id == "theme-radio":
+            theme = "dark" if event.pressed.id == "theme-dark" else "light"
+            self._set_theme(theme)
+        elif event.radio_set.id == "border-resize-radio":
             # Check which radio button is selected
             enabled = event.pressed.id == "border-resize-enabled"
             self._toggle_border_resize(enabled)
@@ -313,6 +353,28 @@ class ConfigPanel(Static):
         else:
             self.app.notify("Failed to logout", title="Account", severity="error")
 
+    def _sync_theme_radio(self) -> None:
+        """Sync theme radio buttons with persisted dashboard preference."""
+        try:
+            theme = str(get_dashboard_state_value("theme", "dark")).strip().lower()
+            self._syncing_radio = True
+            try:
+                if theme == "light":
+                    radio = self.query_one("#theme-light", RadioButton)
+                else:
+                    radio = self.query_one("#theme-dark", RadioButton)
+                radio.value = True
+            finally:
+                self._syncing_radio = False
+        except Exception:
+            pass
+
+    def _set_theme(self, theme: str) -> None:
+        theme_value = "light" if theme.strip().lower() == "light" else "dark"
+        set_dashboard_state_value("theme", theme_value)
+        self.app.theme = "textual-light" if theme_value == "light" else "textual-dark"
+        self.app.notify(f"Theme set to {theme_value}", title="Appearance")
+
     def _sync_border_resize_radio(self) -> None:
         """Query tmux state and sync the radio buttons to match."""
         try:

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)