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

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

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

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

@@ -1,9 +1,9 @@
-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.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=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
@@ -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
@@ -42,11 +42,11 @@ realign/commands/config.py,sha256=nYnu_h2pk7GODcrzrV04K51D-s7v06FlRXHJ0HJ-gvU,67
 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
@@ -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.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.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.7.0"
+__version__ = "0.7.1"
 
 
 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/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/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)