aline-ai 0.5.13__py3-none-any.whl → 0.6.0__py3-none-any.whl

{aline_ai-0.5.13.dist-info → aline_ai-0.6.0.dist-info}/METADATA

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

{aline_ai-0.5.13.dist-info → aline_ai-0.6.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-aline_ai-0.5.13.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=7hBPixwKhL2BzvTWOw-rerx1yBjnC8f5kVd0IDyl-Bo,1624
+aline_ai-0.6.0.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=a8wH_-YI_n2n6He2CL8jdy4zSUj9pxtT6cz9iNZgp24,1623
 realign/auth.py,sha256=63fdy-KsNoLZ9A6X0Mz_v-0tQOXN_1XncXBGBlEoXqE,16030
 realign/claude_detector.py,sha256=ZLSJacMo6zzQclXByABKA70UNpstxqIv3fPGqdpA934,2792
-realign/cli.py,sha256=RuFw_FWnKcRm0-3J-pGNR-S9e0D1rZ-ptAPlO2FFOlM,31807
+realign/cli.py,sha256=2BhDitD5IYUPJRGtfOXv_m0r7ZsiPU9iGtkp2pfA59M,41637
 realign/codex_detector.py,sha256=N9ulgMgvTzDfXE4s4vLd6OoS0hT7R6h2bDFFXWa-2hE,4183
 realign/config.py,sha256=d8HQ6v1xju6cjNGbR7LlfHaMyvFPcMDofhGbepxpQq8,11634
 realign/context.py,sha256=8hzgNOg-7_eMW22wt7OM5H9IsmMveKXCv0epG7E0G7w,13917
@@ -14,9 +14,9 @@ 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=NNn_xlm50Ybb60--DrF9dyvzGgJ4ENQeAUbZsH7w4to,106555
-realign/watcher_daemon.py,sha256=AVOMXrlVVy7Rlx3Yfib4e-KLszIR7CLdSHpdoxDRp8c,3090
+realign/watcher_daemon.py,sha256=OHUQ9P1LlagKJHfrf6uRnzO-zDtBRXIxt8ydMFHf5S8,3475
 realign/worker_core.py,sha256=-GOItHE0vzExB8LZK6KeHx4tt_mIqtCoUljOtEg2x8A,10105
-realign/worker_daemon.py,sha256=LpJbQDY0Z4AMtq0LmpxvFeQM4puuoGDRBayKRafvKhc,3574
+realign/worker_daemon.py,sha256=X7Xyjw_u6m6KG4E84nx0HpDFw4cWMv8ja1G8btc9PiM,3957
 realign/adapters/__init__.py,sha256=bpDm5aBxMdq4OA_beYahoUb4zfNaq3KOG6KghQJruRc,827
 realign/adapters/antigravity.py,sha256=geaYxAEswpgsVtERqsQ1OwvPFsy5tRkyjx2yQ-Uq9nM,5461
 realign/adapters/base.py,sha256=2IdAZKGjg5gPB3YLf_8r3V4XAdbK7fHpj06GjjsYEFY,7409
@@ -34,17 +34,17 @@ realign/claude_hooks/user_prompt_submit_hook.py,sha256=WD-UavhBTueN2TPfnZrnPC7DF
 realign/claude_hooks/user_prompt_submit_hook_installer.py,sha256=2xLF8yZcE7Iwib9gU-xCkA1NWxNH9Nc5CFKPYK7rtXw,5371
 realign/commands/__init__.py,sha256=sx_ck55oxaoiF4N3LugG0ZXwonUDxeEZ5uHbBKCC7K8,89
 realign/commands/add.py,sha256=njZgg3paUmOw-sb-sWkXr_eUaf5bD-hBEiRectaphPs,24332
-realign/commands/auth.py,sha256=AnUXpnRBkdBflFIweUz5WQKFVmtyxWRjwvw-96w0rRw,7625
+realign/commands/auth.py,sha256=B1FQjaLUKYc4DsGqrpXZ3JPmsttUXhrtxxrKuOUmP4Q,10844
 realign/commands/config.py,sha256=nYnu_h2pk7GODcrzrV04K51D-s7v06FlRXHJ0HJ-gvU,6732
 realign/commands/context.py,sha256=pM2KfZHVkB-ou4nBhFvKSwnYliLBzwN3zerLyBAbhfE,7095
 realign/commands/export_shares.py,sha256=g2SxlPEb7FPMarjTZcoZntviZo5JdqEe-M28vggc2-s,136601
-realign/commands/import_shares.py,sha256=4_Bzf9IgSpK2oOLoYWEnF1BmpXZaB5ijvpUQPeCtIfg,25386
+realign/commands/import_shares.py,sha256=HiswLlYHqR0dR3wgB7Rs54_WownqahIs5IdyJOHuot8,25572
 realign/commands/init.py,sha256=nhP1Qjl6Xo5R1ry_iTGVu3RwMxP-pYT5Z50NdzEMKrY,32756
 realign/commands/restore.py,sha256=s2BxQZHxQw9r12NzRVsK20KlGafy5AIoSjWMo5PcnHY,11173
 realign/commands/search.py,sha256=QJrC0hln9sCDFxXbpo0nPGMHXrud18qA5QfRyD0z6fQ,25926
 realign/commands/upgrade.py,sha256=L3PLOUIN5qAQTbkfoVtSsIbbzEezA_xjjk9F1GMVfjw,12781
-realign/commands/watcher.py,sha256=VunN3deqE1_DLW9UcFgLj_MFX8jNkVr2Ra7aNmWG9xA,136006
-realign/commands/worker.py,sha256=K1DG1uZ--ebKwklHCyIFdN_axoLjL9Onx8Naq-DOZBs,23078
+realign/commands/watcher.py,sha256=rB3x2diC7scqghl7wLAeBNgMj4NLXUKbr0ou1_VVUIU,136292
+realign/commands/worker.py,sha256=jTu7Pj60nTnn7SsH3oNCNnO6zl4TIFCJVNSC1OoQ_0o,23363
 realign/dashboard/__init__.py,sha256=QZkHTsGityH8UkF8rmvA3xW7dMXNe0swEWr443qfgCM,128
 realign/dashboard/app.py,sha256=jyW6mqmItTy253CPSqInxctkWzkrGEikdy-ikuShQ14,13299
 realign/dashboard/tmux_manager.py,sha256=Vt_30WNtDg7c_9SEh8xdDtBLJ8kNq6bGSPh5r3VXpg0,26276
@@ -58,11 +58,11 @@ realign/dashboard/screens/share_import.py,sha256=hl2x0yGVycsoUI76AmdZTAV-br3Q619
 realign/dashboard/styles/dashboard.tcss,sha256=ewonevBGLN-dfSsgxUk4VBCPchtxY4rx_vj1u6Ox2Fw,3454
 realign/dashboard/widgets/__init__.py,sha256=3Pf2_K9obrertgv_psfxradgkI9RXlmjoXYQH7oBKm0,583
 realign/dashboard/widgets/config_panel.py,sha256=JRv9Hgm5V-vqVptS7gQqnjg5MbKpt_FmdZV13D4E9A4,17894
-realign/dashboard/widgets/events_table.py,sha256=dXN_aD94YJ1fDSV2B_5m7YMvMU3bNUhGFCMIRWvvLMg,31141
+realign/dashboard/widgets/events_table.py,sha256=Ru4y5Xq04Y-3CN9Dwm-fHrHR37Aup9NFW_Yh-J1x-Jo,33247
 realign/dashboard/widgets/header.py,sha256=0HHCFXX7F3C6HII-WDwOJwWkJrajmKPWmdoMWyOkn9E,1587
 realign/dashboard/widgets/openable_table.py,sha256=GeJPDEYp0kRHShqvmPMzAePpYXRZHUNqcWNnxqsqxjA,1963
 realign/dashboard/widgets/search_panel.py,sha256=ZNJDfwDSxUFnCeltYQYsQsPJ6t4HDeNWpENoTOoBdVM,8951
-realign/dashboard/widgets/sessions_table.py,sha256=PohOkg-ESLBa-Sq0PdLPhV-YzVXOGpUo5ETs0MYO4u8,33415
+realign/dashboard/widgets/sessions_table.py,sha256=GyaWzvt-elKx1iE2YR94CBNPyjqM8B7g0j7zsukiXi0,36517
 realign/dashboard/widgets/terminal_panel.py,sha256=uoi3LjgYWyFE6Yr208KC5iKg0QxLcXpN6hCERlI6pBg,29069
 realign/dashboard/widgets/watcher_panel.py,sha256=O_mdDacgc87xA-5KEfta53Ik_Xsk_B2OfwenMOTtGw8,19722
 realign/dashboard/widgets/worker_panel.py,sha256=F_jKWABuCNmjQgeeuCr4KnFRKdY4CLTNcEXMYwsNaSk,18691
@@ -91,8 +91,8 @@ realign/triggers/next_turn_trigger.py,sha256=BpP0PWn4mU1MZd6mv89jWcjs8Jtv0zEWapW
 realign/triggers/registry.py,sha256=cb-AVLbYB2pqwfWL3q1DQxLv4kOw7g7m-GshTdfFESc,3827
 realign/triggers/turn_status.py,sha256=wAZEhXDAmDoX5F-ohWfSnZZ0eA6DAJ9svSPiSv_f6sg,6041
 realign/triggers/turn_summary.py,sha256=f3hEUshgv9skJ9AbfWpoYs417lsv_HK2A_vpPjgryO4,4467
-aline_ai-0.5.13.dist-info/METADATA,sha256=yh0oIdfIbiWQHUhP8UPOdsLFxqCjsdvF3xYfAWquT9c,1598
-aline_ai-0.5.13.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aline_ai-0.5.13.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
-aline_ai-0.5.13.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.5.13.dist-info/RECORD,,
+aline_ai-0.6.0.dist-info/METADATA,sha256=oukhmryjZ2KFfmgLAIPBjpr8S4_8pxboUCOAgIWLx4Y,1597
+aline_ai-0.6.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aline_ai-0.6.0.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
+aline_ai-0.6.0.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.6.0.dist-info/RECORD,,

realign/__init__.py

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

realign/cli.py

@@ -33,6 +33,26 @@ def main(
     ctx.obj["dev"] = dev
 
     if ctx.invoked_subcommand is None:
+        # Check login status before launching dashboard
+        from .auth import is_logged_in, get_current_user
+
+        if not is_logged_in():
+            console.print("[yellow]You need to login before using Aline.[/yellow]")
+            console.print("Starting login flow...\n")
+
+            # Run login command
+            exit_code = auth.login_command()
+            if exit_code != 0:
+                console.print("\n[red]Login failed. Please try again with 'aline login'.[/red]")
+                raise typer.Exit(code=1)
+
+            # Verify login succeeded
+            if not is_logged_in():
+                console.print("\n[red]Login verification failed. Please try again.[/red]")
+                raise typer.Exit(code=1)
+
+            console.print()  # Add spacing before dashboard launch
+
         # Check for updates before launching dashboard
         from .commands.upgrade import check_and_prompt_update
 
@@ -79,6 +99,235 @@ def whoami_cli():
     raise typer.Exit(code=exit_code)
 
 
+@app.command(name="doctor")
+def doctor_cli(
+    no_restart: bool = typer.Option(False, "--no-restart", help="Only clear cache, don't restart daemons"),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed output"),
+):
+    """
+    Fix common issues after code updates.
+
+    This command:
+    - Clears Python bytecode cache (.pyc files)
+    - Updates Claude Code hooks (Stop, UserPromptSubmit, PermissionRequest)
+    - Updates skills to latest version
+    - Restarts the watcher daemon (if running)
+    - Restarts the worker daemon (if running)
+
+    Run this after pulling new code to ensure everything uses the latest version.
+    """
+    import shutil
+    import subprocess
+    import signal
+    import time
+
+    # Find the project root (where src/realign is)
+    project_root = Path(__file__).parent.parent.parent
+
+    # 1. Clear Python cache
+    console.print("[bold]1. Clearing Python cache...[/bold]")
+    pyc_count = 0
+    pycache_count = 0
+
+    for pyc_file in project_root.rglob("*.pyc"):
+        try:
+            pyc_file.unlink()
+            pyc_count += 1
+            if verbose:
+                console.print(f"  [dim]Removed: {pyc_file}[/dim]")
+        except Exception as e:
+            if verbose:
+                console.print(f"  [yellow]Failed to remove {pyc_file}: {e}[/yellow]")
+
+    for pycache_dir in project_root.rglob("__pycache__"):
+        if pycache_dir.is_dir():
+            try:
+                shutil.rmtree(pycache_dir)
+                pycache_count += 1
+                if verbose:
+                    console.print(f"  [dim]Removed: {pycache_dir}[/dim]")
+            except Exception as e:
+                if verbose:
+                    console.print(f"  [yellow]Failed to remove {pycache_dir}: {e}[/yellow]")
+
+    console.print(f"  [green]✓[/green] Cleared {pyc_count} .pyc files, {pycache_count} __pycache__ directories")
+
+    # 2. Update Claude Code hooks
+    console.print("\n[bold]2. Updating Claude Code hooks...[/bold]")
+    hooks_updated = []
+    hooks_failed = []
+
+    # Stop hook
+    try:
+        from .claude_hooks.stop_hook_installer import install_stop_hook, get_settings_path
+        if install_stop_hook(get_settings_path(), quiet=True, force=True):
+            hooks_updated.append("Stop")
+            if verbose:
+                console.print("  [dim]Stop hook updated[/dim]")
+        else:
+            hooks_failed.append("Stop")
+    except Exception as e:
+        hooks_failed.append("Stop")
+        if verbose:
+            console.print(f"  [yellow]Stop hook failed: {e}[/yellow]")
+
+    # UserPromptSubmit hook
+    try:
+        from .claude_hooks.user_prompt_submit_hook_installer import install_user_prompt_submit_hook, get_settings_path as get_submit_settings_path
+        if install_user_prompt_submit_hook(get_submit_settings_path(), quiet=True, force=True):
+            hooks_updated.append("UserPromptSubmit")
+            if verbose:
+                console.print("  [dim]UserPromptSubmit hook updated[/dim]")
+        else:
+            hooks_failed.append("UserPromptSubmit")
+    except Exception as e:
+        hooks_failed.append("UserPromptSubmit")
+        if verbose:
+            console.print(f"  [yellow]UserPromptSubmit hook failed: {e}[/yellow]")
+
+    # PermissionRequest hook
+    try:
+        from .claude_hooks.permission_request_hook_installer import install_permission_request_hook, get_settings_path as get_permission_settings_path
+        if install_permission_request_hook(get_permission_settings_path(), quiet=True, force=True):
+            hooks_updated.append("PermissionRequest")
+            if verbose:
+                console.print("  [dim]PermissionRequest hook updated[/dim]")
+        else:
+            hooks_failed.append("PermissionRequest")
+    except Exception as e:
+        hooks_failed.append("PermissionRequest")
+        if verbose:
+            console.print(f"  [yellow]PermissionRequest hook failed: {e}[/yellow]")
+
+    if hooks_updated:
+        console.print(f"  [green]✓[/green] Updated hooks: {', '.join(hooks_updated)}")
+    if hooks_failed:
+        console.print(f"  [yellow]![/yellow] Failed hooks: {', '.join(hooks_failed)}")
+
+    # 3. Update skills
+    console.print("\n[bold]3. Updating skills...[/bold]")
+    try:
+        from .commands.add import add_skills_command
+        # Capture output by redirecting - use force=True to update
+        import io
+        import contextlib
+
+        stdout_capture = io.StringIO()
+        with contextlib.redirect_stdout(stdout_capture):
+            add_skills_command(force=True)
+
+        output = stdout_capture.getvalue()
+        # Count updated skills from output
+        updated_count = output.count("✓")
+        if updated_count > 0:
+            console.print(f"  [green]✓[/green] Updated {updated_count} skill(s)")
+        else:
+            console.print("  [green]✓[/green] Skills are up to date")
+        if verbose and output.strip():
+            for line in output.strip().split("\n"):
+                console.print(f"  [dim]{line}[/dim]")
+    except Exception as e:
+        console.print(f"  [yellow]![/yellow] Failed to update skills: {e}")
+
+    if no_restart:
+        console.print("\n[dim]Skipping daemon restart (--no-restart)[/dim]")
+        console.print("\n[green]Done![/green] Aline is ready with the latest code.")
+        raise typer.Exit(code=0)
+
+    # 4. Restart watcher daemon
+    console.print("\n[bold]4. Checking watcher daemon...[/bold]")
+    pid_file = Path.home() / ".aline" / ".logs" / "watcher.pid"
+    watcher_was_running = False
+
+    if pid_file.exists():
+        try:
+            pid = int(pid_file.read_text().strip())
+            # Check if process is running
+            try:
+                import os
+                os.kill(pid, 0)  # Signal 0 just checks if process exists
+                watcher_was_running = True
+                console.print(f"  [dim]Found watcher daemon (PID {pid}), stopping...[/dim]")
+                os.kill(pid, signal.SIGTERM)
+                time.sleep(1)
+                # Force kill if still running
+                try:
+                    os.kill(pid, 0)
+                    os.kill(pid, signal.SIGKILL)
+                    time.sleep(0.5)
+                except ProcessLookupError:
+                    pass
+            except ProcessLookupError:
+                console.print("  [dim]Watcher daemon not running (stale PID file)[/dim]")
+        except Exception as e:
+            if verbose:
+                console.print(f"  [yellow]Error checking watcher: {e}[/yellow]")
+
+    if watcher_was_running:
+        console.print("  [dim]Starting watcher daemon...[/dim]")
+        try:
+            subprocess.Popen(
+                ["python", "-m", "src.realign.watcher_daemon"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+                cwd=str(project_root),
+            )
+            time.sleep(2)
+            console.print("  [green]✓[/green] Watcher daemon restarted")
+        except Exception as e:
+            console.print(f"  [red]✗[/red] Failed to restart watcher: {e}")
+    else:
+        console.print("  [dim]Watcher daemon was not running[/dim]")
+
+    # 5. Restart worker daemon
+    console.print("\n[bold]5. Checking worker daemon...[/bold]")
+    worker_pid_file = Path.home() / ".aline" / ".logs" / "worker.pid"
+    worker_was_running = False
+
+    if worker_pid_file.exists():
+        try:
+            pid = int(worker_pid_file.read_text().strip())
+            try:
+                import os
+                os.kill(pid, 0)
+                worker_was_running = True
+                console.print(f"  [dim]Found worker daemon (PID {pid}), stopping...[/dim]")
+                os.kill(pid, signal.SIGTERM)
+                time.sleep(1)
+                try:
+                    os.kill(pid, 0)
+                    os.kill(pid, signal.SIGKILL)
+                    time.sleep(0.5)
+                except ProcessLookupError:
+                    pass
+            except ProcessLookupError:
+                console.print("  [dim]Worker daemon not running (stale PID file)[/dim]")
+        except Exception as e:
+            if verbose:
+                console.print(f"  [yellow]Error checking worker: {e}[/yellow]")
+
+    if worker_was_running:
+        console.print("  [dim]Starting worker daemon...[/dim]")
+        try:
+            subprocess.Popen(
+                ["python", "-m", "src.realign.worker_daemon"],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                start_new_session=True,
+                cwd=str(project_root),
+            )
+            time.sleep(2)
+            console.print("  [green]✓[/green] Worker daemon restarted")
+        except Exception as e:
+            console.print(f"  [red]✗[/red] Failed to restart worker: {e}")
+    else:
+        console.print("  [dim]Worker daemon was not running[/dim]")
+
+    console.print("\n[green]Done![/green] Aline is ready with the latest code.")
+    raise typer.Exit(code=0)
+
+
 @app.command(name="search")
 def search_cli(
     query: str = typer.Argument(..., help="Search query (keywords or regex pattern)"),

realign/commands/auth.py

@@ -176,6 +176,8 @@ def logout_command() -> int:
     """
     Logout from Aline and clear local credentials.
 
+    Also stops watcher and worker daemons since they require authentication.
+
     Returns:
         0 on success, 1 on error
     """
@@ -190,6 +192,14 @@ def logout_command() -> int:
 
     email = credentials.email
 
+    # Stop watcher and worker daemons before logout
+    if console:
+        console.print("[dim]Stopping daemons...[/dim]")
+    else:
+        print("Stopping daemons...")
+
+    _stop_daemons()
+
     if not clear_credentials():
         if console:
             console.print("[red]Error: Failed to clear credentials[/red]")
@@ -208,6 +218,97 @@ def logout_command() -> int:
     return 0
 
 
+def _stop_daemons() -> None:
+    """Stop watcher and worker daemons."""
+    import os
+    import signal
+    import time
+    from pathlib import Path
+
+    def stop_daemon(name: str, pid_file: Path) -> None:
+        """Stop a daemon by PID file, wait for it to terminate."""
+        if not pid_file.exists():
+            return
+
+        try:
+            pid = int(pid_file.read_text().strip())
+        except Exception:
+            return
+
+        # Check if process is running
+        try:
+            os.kill(pid, 0)
+        except ProcessLookupError:
+            # Process already gone, clean up PID file
+            try:
+                pid_file.unlink(missing_ok=True)
+            except Exception:
+                pass
+            return
+        except PermissionError:
+            pass  # Can't check, try to stop anyway
+
+        # Send SIGTERM
+        try:
+            os.kill(pid, signal.SIGTERM)
+            if console:
+                console.print(f"  [dim]Stopping {name} daemon (PID {pid})...[/dim]")
+            logger.info(f"Sent SIGTERM to {name} daemon (PID {pid})")
+        except ProcessLookupError:
+            try:
+                pid_file.unlink(missing_ok=True)
+            except Exception:
+                pass
+            return
+        except Exception as e:
+            logger.debug(f"Error sending SIGTERM to {name}: {e}")
+            return
+
+        # Wait for process to terminate (up to 5 seconds)
+        for _ in range(50):  # 50 * 0.1s = 5 seconds
+            time.sleep(0.1)
+            try:
+                os.kill(pid, 0)
+            except ProcessLookupError:
+                # Process terminated
+                if console:
+                    console.print(f"  [dim]{name.capitalize()} daemon stopped[/dim]")
+                logger.info(f"{name.capitalize()} daemon (PID {pid}) stopped")
+                try:
+                    pid_file.unlink(missing_ok=True)
+                except Exception:
+                    pass
+                return
+            except PermissionError:
+                break  # Can't check anymore
+
+        # Process still running, try SIGKILL
+        try:
+            os.kill(pid, signal.SIGKILL)
+            time.sleep(0.5)
+            if console:
+                console.print(f"  [dim]{name.capitalize()} daemon force killed[/dim]")
+            logger.info(f"{name.capitalize()} daemon (PID {pid}) force killed")
+        except ProcessLookupError:
+            pass
+        except Exception as e:
+            logger.debug(f"Error sending SIGKILL to {name}: {e}")
+
+        # Clean up PID file
+        try:
+            pid_file.unlink(missing_ok=True)
+        except Exception:
+            pass
+
+    # Stop watcher daemon
+    watcher_pid_file = Path.home() / ".aline" / ".logs" / "watcher.pid"
+    stop_daemon("watcher", watcher_pid_file)
+
+    # Stop worker daemon
+    worker_pid_file = Path.home() / ".aline" / ".logs" / "worker.pid"
+    stop_daemon("worker", worker_pid_file)
+
+
 def whoami_command() -> int:
     """
     Display current login status.

realign/commands/import_shares.py

@@ -239,6 +239,9 @@ def import_v2_data(
 
     logger.info("Starting v2.0 data import")
 
+    # Load config to get current user's UID for shared_by
+    config = ReAlignConfig.load()
+
     # 1. Create Event
     event_data = data.get("event", {})
     event_id = event_data.get("event_id")
@@ -366,6 +369,9 @@ def import_session_with_turns(
     Returns:
         Dict with counts: {'sessions': int, 'turns': int, 'skipped': int}
     """
+    # Load config to get current user's UID for shared_by
+    config = ReAlignConfig.load()
+
     session_id = session_data.get("session_id")
     imported_sessions = 0
     imported_turns = 0

realign/commands/watcher.py

@@ -658,6 +658,14 @@ def watcher_start_command() -> int:
         int: Exit code (0 = success, 1 = error)
     """
     try:
+        # Check login status first
+        from ..auth import is_logged_in
+
+        if not is_logged_in():
+            console.print("[red]✗ Not logged in. Watcher requires authentication.[/red]")
+            console.print("[dim]Run 'aline login' first.[/dim]")
+            return 1
+
         # Check if already running
         is_running, pid, mode = detect_watcher_process()
 

realign/commands/worker.py

@@ -461,6 +461,14 @@ def worker_repair_command(*, force: bool = False) -> int:
 
 def worker_start_command() -> int:
     try:
+        # Check login status first
+        from ..auth import is_logged_in
+
+        if not is_logged_in():
+            console.print("[red]✗ Not logged in. Worker requires authentication.[/red]")
+            console.print("[dim]Run 'aline login' first.[/dim]")
+            return 1
+
         is_running, pid, mode = detect_worker_process()
         if is_running:
             console.print(f"[yellow]Worker is already running (PID: {pid}, mode: {mode})[/yellow]")

realign/dashboard/widgets/events_table.py

@@ -232,6 +232,8 @@ class EventsTable(Container):
         table.add_column("Share", key="share", width=12)
         table.add_column("Type", key="type", width=8)
         table.add_column("Sessions", key="sessions", width=8)
+        table.add_column("Created By", key="created_by", width=10)
+        table.add_column("Shared By", key="shared_by", width=10)
         table.add_column("Event ID", key="event_id", width=12)
         table.add_column("Created", key="created", width=10)
         table.cursor_type = "row"
@@ -352,6 +354,12 @@ class EventsTable(Container):
                 table.update_cell(
                     eid, "sessions", self._format_cell(str(event["sessions"]), eid)
                 )
+                table.update_cell(
+                    eid, "created_by", self._format_cell(event.get("created_by", "-"), eid)
+                )
+                table.update_cell(
+                    eid, "shared_by", self._format_cell(event.get("shared_by", "-"), eid)
+                )
                 table.update_cell(
                     eid, "event_id", self._format_cell(event["short_id"], eid)
                 )
@@ -736,6 +744,8 @@ class EventsTable(Container):
                         e.event_type,
                         e.created_at,
                         e.share_url,
+                        e.created_by,
+                        e.shared_by,
                         (SELECT COUNT(*) FROM event_sessions WHERE event_id = e.id) AS session_count
                     FROM events e
                     ORDER BY e.created_at DESC
@@ -743,8 +753,9 @@ class EventsTable(Container):
                     """,
                     (int(rows_per_page), int(offset)),
                 ).fetchall()
-                has_share_url = True
+                has_new_columns = True
             except Exception:
+                # Fallback for older schema without created_by/shared_by
                 rows = conn.execute(
                     """
                     SELECT
@@ -759,18 +770,22 @@ class EventsTable(Container):
                     """,
                     (int(rows_per_page), int(offset)),
                 ).fetchall()
-                has_share_url = False
+                has_new_columns = False
 
             for i, row in enumerate(rows):
                 event_id = row[0]
                 title = row[1] or "(no title)"
                 event_type = row[2] or "unknown"
                 created_at = row[3]
-                if has_share_url:
+                if has_new_columns:
                     share_url = row[4]
-                    session_count = row[5]
+                    created_by = row[5]
+                    shared_by = row[6]
+                    session_count = row[7]
                 else:
                     share_url = None
+                    created_by = None
+                    shared_by = None
                     session_count = row[4]
 
                 # Format event type
@@ -789,6 +804,26 @@ class EventsTable(Container):
                     except Exception:
                         created_str = created_at
 
+                # Look up user names from users table
+                created_by_display = "-"
+                shared_by_display = "-"
+                if created_by:
+                    try:
+                        user_row = conn.execute(
+                            "SELECT user_name FROM users WHERE uid = ?", (created_by,)
+                        ).fetchone()
+                        created_by_display = user_row[0] if user_row and user_row[0] else created_by[:8] + "..."
+                    except Exception:
+                        created_by_display = created_by[:8] + "..." if len(created_by) > 8 else created_by
+                if shared_by:
+                    try:
+                        user_row = conn.execute(
+                            "SELECT user_name FROM users WHERE uid = ?", (shared_by,)
+                        ).fetchone()
+                        shared_by_display = user_row[0] if user_row and user_row[0] else shared_by[:8] + "..."
+                    except Exception:
+                        shared_by_display = shared_by[:8] + "..." if len(shared_by) > 8 else shared_by
+
                 events.append(
                     {
                         "index": offset + i + 1,
@@ -799,6 +834,8 @@ class EventsTable(Container):
                         "sessions": session_count,
                         "share_url": share_url,
                         "share_id": self._extract_share_id(share_url),
+                        "created_by": created_by_display,
+                        "shared_by": shared_by_display,
                         "created": created_str,
                     }
                 )
@@ -849,7 +886,7 @@ class EventsTable(Container):
             if self.wrap_mode and event.get("share_url"):
                 share_val = event.get("share_url")
 
-            # Column order: ✓, #, Title, Share, Type, Sessions, Event ID, Created
+            # Column order: ✓, #, Title, Share, Type, Sessions, Created By, Shared By, Event ID, Created
             table.add_row(
                 self._checkbox_cell(eid),
                 self._format_cell(str(event["index"]), eid),
@@ -857,6 +894,8 @@ class EventsTable(Container):
                 self._format_cell(share_val, eid),
                 self._format_cell(event["type"], eid),
                 self._format_cell(str(event["sessions"]), eid),
+                self._format_cell(event.get("created_by", "-"), eid),
+                self._format_cell(event.get("shared_by", "-"), eid),
                 self._format_cell(event["short_id"], eid),
                 self._format_cell(event["created"], eid),
                 key=eid,

realign/dashboard/widgets/sessions_table.py

@@ -223,6 +223,8 @@ class SessionsTable(Container):
         table.add_column("Project", key="project", width=15)
         table.add_column("Source", key="source", width=10)
         table.add_column("Turns", key="turns", width=6)
+        table.add_column("Created By", key="created_by", width=10)
+        table.add_column("Shared By", key="shared_by", width=10)
         table.add_column("Session ID", key="session_id", width=20)
         table.add_column("Last Activity", key="last_activity", width=12)
         table.cursor_type = "row"
@@ -361,6 +363,12 @@ class SessionsTable(Container):
                 table.update_cell(
                     sid, "turns", self._format_cell(str(session["turns"]), sid)
                 )
+                table.update_cell(
+                    sid, "created_by", self._format_cell(session.get("created_by", "-"), sid)
+                )
+                table.update_cell(
+                    sid, "shared_by", self._format_cell(session.get("shared_by", "-"), sid)
+                )
                 table.update_cell(
                     sid, "session_id", self._format_cell(session["short_id"], sid)
                 )
@@ -805,21 +813,43 @@ class SessionsTable(Container):
                 # Get paginated sessions
                 # Use cached total_turns instead of subquery for performance
                 offset = (int(page) - 1) * int(rows_per_page)
-                rows = conn.execute(
-                    """
-                    SELECT
-                        s.id,
-                        s.session_type,
-                        s.workspace_path,
-                        s.session_title,
-                        s.last_activity_at,
-                        s.total_turns
-                    FROM sessions s
-                    ORDER BY s.last_activity_at DESC
-                    LIMIT ? OFFSET ?
-                """,
-                    (int(rows_per_page), int(offset)),
-                ).fetchall()
+                try:
+                    rows = conn.execute(
+                        """
+                        SELECT
+                            s.id,
+                            s.session_type,
+                            s.workspace_path,
+                            s.session_title,
+                            s.last_activity_at,
+                            s.total_turns,
+                            s.created_by,
+                            s.shared_by
+                        FROM sessions s
+                        ORDER BY s.last_activity_at DESC
+                        LIMIT ? OFFSET ?
+                    """,
+                        (int(rows_per_page), int(offset)),
+                    ).fetchall()
+                    has_new_columns = True
+                except Exception:
+                    # Fallback for older schema without created_by/shared_by
+                    rows = conn.execute(
+                        """
+                        SELECT
+                            s.id,
+                            s.session_type,
+                            s.workspace_path,
+                            s.session_title,
+                            s.last_activity_at,
+                            s.total_turns
+                        FROM sessions s
+                        ORDER BY s.last_activity_at DESC
+                        LIMIT ? OFFSET ?
+                    """,
+                        (int(rows_per_page), int(offset)),
+                    ).fetchall()
+                    has_new_columns = False
 
                 for i, row in enumerate(rows):
                     session_id = row[0]
@@ -828,6 +858,12 @@ class SessionsTable(Container):
                     title = row[3] or "(no title)"
                     last_activity = row[4]
                     turn_count = row[5]
+                    if has_new_columns:
+                        created_by = row[6]
+                        shared_by = row[7]
+                    else:
+                        created_by = None
+                        shared_by = None
 
                     source_map = {
                         "claude": "Claude",
@@ -846,6 +882,26 @@ class SessionsTable(Container):
                         except Exception:
                             activity_str = last_activity
 
+                    # Look up user names from users table
+                    created_by_display = "-"
+                    shared_by_display = "-"
+                    if created_by:
+                        try:
+                            user_row = conn.execute(
+                                "SELECT user_name FROM users WHERE uid = ?", (created_by,)
+                            ).fetchone()
+                            created_by_display = user_row[0] if user_row and user_row[0] else created_by[:8] + "..."
+                        except Exception:
+                            created_by_display = created_by[:8] + "..." if len(created_by) > 8 else created_by
+                    if shared_by:
+                        try:
+                            user_row = conn.execute(
+                                "SELECT user_name FROM users WHERE uid = ?", (shared_by,)
+                            ).fetchone()
+                            shared_by_display = user_row[0] if user_row and user_row[0] else shared_by[:8] + "..."
+                        except Exception:
+                            shared_by_display = shared_by[:8] + "..." if len(shared_by) > 8 else shared_by
+
                     sessions.append(
                         {
                             "index": offset + i + 1,
@@ -855,6 +911,8 @@ class SessionsTable(Container):
                             "project": project,
                             "turns": turn_count,
                             "title": title,
+                            "created_by": created_by_display,
+                            "shared_by": shared_by_display,
                             "last_activity": activity_str,
                         }
                     )
@@ -905,7 +963,7 @@ class SessionsTable(Container):
             if self.wrap_mode:
                 display_id = sid
 
-            # Column order: ✓, #, Title, Project, Source, Turns, Session ID, Last Activity
+            # Column order: ✓, #, Title, Project, Source, Turns, Created By, Shared By, Session ID, Last Activity
             table.add_row(
                 self._checkbox_cell(sid),
                 self._format_cell(str(session["index"]), sid),
@@ -913,6 +971,8 @@ class SessionsTable(Container):
                 self._format_cell(session["project"], sid),
                 self._format_cell(session["source"], sid),
                 self._format_cell(str(session["turns"]), sid),
+                self._format_cell(session.get("created_by", "-"), sid),
+                self._format_cell(session.get("shared_by", "-"), sid),
                 self._format_cell(display_id, sid),
                 self._format_cell(session["last_activity"], sid),
                 key=sid,

realign/watcher_daemon.py

@@ -48,6 +48,17 @@ async def run_daemon():
     """Run the watcher daemon."""
     watcher = None
 
+    # Check login status before starting
+    try:
+        from .auth import is_logged_in
+    except ImportError:
+        from realign.auth import is_logged_in
+
+    if not is_logged_in():
+        logger.error("Not logged in. Watcher daemon requires authentication.")
+        print("[Watcher Daemon] Error: Not logged in. Run 'aline login' first.", file=sys.stderr)
+        sys.exit(1)
+
     # Shutdown handler
     def handle_shutdown(signum, frame):
         """Handle shutdown signals gracefully."""

realign/worker_daemon.py

@@ -49,6 +49,17 @@ async def run_daemon() -> None:
     worker = None
     db = None
 
+    # Check login status before starting
+    try:
+        from .auth import is_logged_in
+    except ImportError:
+        from realign.auth import is_logged_in
+
+    if not is_logged_in():
+        logger.error("Not logged in. Worker daemon requires authentication.")
+        print("[Worker Daemon] Error: Not logged in. Run 'aline login' first.", file=sys.stderr)
+        sys.exit(1)
+
     def handle_shutdown(signum, frame):
         logger.info(f"Received signal {signum}, shutting down...")
         try: