aline-ai 0.5.3__py3-none-any.whl → 0.5.4__py3-none-any.whl

{aline_ai-0.5.3.dist-info → aline_ai-0.5.4.dist-info}/METADATA

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

{aline_ai-0.5.3.dist-info → aline_ai-0.5.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
-aline_ai-0.5.3.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
-realign/__init__.py,sha256=ii28HcuehiV7QZMbEa-1t_hZkRPYlMzW801qcAZLYzo,1623
+aline_ai-0.5.4.dist-info/licenses/LICENSE,sha256=H8wTqV5IF1oHw_HbBtS1PSDU8G_q81yblEIL_JfV8Vo,1077
+realign/__init__.py,sha256=IahJlCDpOv2BJxOCpmx8UfhzQxweVN7I9N7YQyT7zMo,1623
 realign/claude_detector.py,sha256=hU5OcFO7JH9BCVbmajAmz4TIP-EQuvz9VlpsRYuSoVM,2792
-realign/cli.py,sha256=CGuAGp4s7LCV7DOuF54eF2s6xe30oie7zkCF8xttXaU,29207
+realign/cli.py,sha256=81zMPACOurb9YzDKdhHyNmnye5lHOv3dbNSuXmKqJ7Y,29783
 realign/codex_detector.py,sha256=vDjRWHycjzX9Pavv8IwrznMf5oyFKBn4FvqYYy3I0s4,4141
 realign/config.py,sha256=fDwXstNF80yNSUOtNJYAqkDEWZOQkzNC7cN0-_2W0KU,12223
 realign/context.py,sha256=ttQL4_Q9FNv6JA85aRslBuu97LeJPoKAgRbShaj_UiU,10006
@@ -24,7 +24,7 @@ realign/adapters/codex.py,sha256=o9XyZEPDVqskHgXSkCDovu3yJM8x6HTIIobU90MGE3s,207
 realign/adapters/gemini.py,sha256=Oaucgz6l_6Cb0GDdt0ant_Pun6B1CfrDMN9B4irIHXc,2636
 realign/adapters/registry.py,sha256=gJf9MSfd0clt653eBfcM17snrSDXeQDwVXal0N2NrHo,3303
 realign/claude_hooks/__init__.py,sha256=-2CiH5UIjPQzok2pBQ8yIVXB5oFxkzLhFXQ8NDDVy0c,594
-realign/claude_hooks/permission_request_hook.py,sha256=p3rTT5zyFPUzSeGW2_5uW5P7cwyK109UoFRwAd47X88,5220
+realign/claude_hooks/permission_request_hook.py,sha256=jMN7UtL6bMqHObUCP5A5ysvFrooDEcd9KxtmF2-3nCw,6448
 realign/claude_hooks/permission_request_hook_installer.py,sha256=B05ey_7OT3tlJBGzBlmy6DFJdW3OGMZCCrk1HSXl0Cs,7800
 realign/claude_hooks/stop_hook.py,sha256=bcWr9jCDZErijSzVSP-kdfmoZ6DHYc6hkRaJ_A2PmQ8,11989
 realign/claude_hooks/stop_hook_installer.py,sha256=BjzabUrAPLCA0m_8ZQWqDW4eCujdPTzlwUNdVGxtRk4,7238
@@ -32,7 +32,7 @@ realign/claude_hooks/terminal_state.py,sha256=ZvdQ-ZmqEltdMoNk3lXVsbpvbAQEmf2hxT
 realign/claude_hooks/user_prompt_submit_hook.py,sha256=WD-UavhBTueN2TPfnZrnPC7DFYGEeptjUEF21EJn7Qo,10312
 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=QWNx78ASIvcaVrj1bv4524P25PdcJ-N2NAX1Q4v5wJw,12535
+realign/commands/add.py,sha256=nkkHETnNprCMKoJuqirddVzJjAiLew7oatLSt3kJOV4,23620
 realign/commands/config.py,sha256=rVwWUgLQDoRh25bjNzsN2eC77aiaPB5D77UtxgS3RlY,6798
 realign/commands/context.py,sha256=tD5jQG4kXPfV57PrS1Du3JUzvY6RCbNbxsOQWdomrPg,7057
 realign/commands/export_shares.py,sha256=6omUtPK8OJsWfrzeQAx5LbM8-lOiONZtWa9btpVumVQ,136179
@@ -45,7 +45,7 @@ realign/commands/watcher.py,sha256=6EBzIc439ClqS4UG8iGd_tfb5MQMPeieAgjCc-M-NEI,1
 realign/commands/worker.py,sha256=LErEjB9T9_XatuLTS9Wn0BbSFc3ah0O9lFTzQOin4qU,22673
 realign/dashboard/__init__.py,sha256=QZkHTsGityH8UkF8rmvA3xW7dMXNe0swEWr443qfgCM,128
 realign/dashboard/app.py,sha256=SOlQ6QHt01-Jj5Daa5xyigrNhR-gXC3jupH24lcbeLY,11935
-realign/dashboard/tmux_manager.py,sha256=XDfznyF9-j5fKdxzSNtGWh8L0i7_AG3S_MZhgYLtsZ8,21066
+realign/dashboard/tmux_manager.py,sha256=zptH81f62tita2h0Yj3HUMcbBQoDNxHDlID4s6KQXAk,22022
 realign/dashboard/screens/__init__.py,sha256=x42K31sqL5KVMtufOnZjG8LnFN7hQyN5-z8CySqbwlM,304
 realign/dashboard/screens/create_event.py,sha256=nPMZMOekduxLXBTjMmLJEQMhb33RXWRIY0uHbD5fmmM,5484
 realign/dashboard/screens/event_detail.py,sha256=WJFO7pryO0DZIMtyA-IOriFYtSLZ5Ri5AVSzjYiW1BQ,20842
@@ -59,7 +59,7 @@ realign/dashboard/widgets/header.py,sha256=ESejMT53T3sbtRrlCGJk8smUv0ts8binkshzC
 realign/dashboard/widgets/openable_table.py,sha256=GeJPDEYp0kRHShqvmPMzAePpYXRZHUNqcWNnxqsqxjA,1963
 realign/dashboard/widgets/search_panel.py,sha256=D0NXVIdNXpcnnVETfA44Muue4CyZq5XkMj4vfpNb3LQ,8635
 realign/dashboard/widgets/sessions_table.py,sha256=CfSy93AbAqGGDFxEQW4u59twZDoVnHyuMmPcSOZTiW4,21852
-realign/dashboard/widgets/terminal_panel.py,sha256=85FTGJVd8sRW_AoWJXFUTaVWIaB_kqtREpwkv7_GcYc,24560
+realign/dashboard/widgets/terminal_panel.py,sha256=obVB9ONnR2Voun_druPiyVG-hd6gf4idXN9iOU84Jq4,29704
 realign/dashboard/widgets/watcher_panel.py,sha256=ThQfVi_GOP-KR1GDNh5WsSmPJ11TEiP_fuuyxd2sdEk,19662
 realign/dashboard/widgets/worker_panel.py,sha256=ufJYpW0nIPcek7GHa1nuMkrpNU9AY0WvtnWzhNZneW0,18547
 realign/db/__init__.py,sha256=dqFKTskcVA7qCn7JAXeUz_c5T0_g--e9BAVokmk2Ys0,1874
@@ -86,8 +86,8 @@ realign/triggers/next_turn_trigger.py,sha256=CU6jsIxA_uoV-ROIke0iwEh4-on8vuataLG
 realign/triggers/registry.py,sha256=AVlMm5xjzWLCnJMuzvfw4hMdNGlLqSTsgd3VCOZ-cHs,3799
 realign/triggers/turn_status.py,sha256=tPHUB3NnnBfMVCIYdrFt5W1840IUGEZ-3v2GEtC981g,5987
 realign/triggers/turn_summary.py,sha256=f3hEUshgv9skJ9AbfWpoYs417lsv_HK2A_vpPjgryO4,4467
-aline_ai-0.5.3.dist-info/METADATA,sha256=6R443dwfUWv_LioywElkXwak1fzgKbrJz_hcaeSLjo0,1597
-aline_ai-0.5.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-aline_ai-0.5.3.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
-aline_ai-0.5.3.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
-aline_ai-0.5.3.dist-info/RECORD,,
+aline_ai-0.5.4.dist-info/METADATA,sha256=hpo9KnzjijOm4LWcK9gS851AwfbHhETS3DFarY-FONk,1597
+aline_ai-0.5.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+aline_ai-0.5.4.dist-info/entry_points.txt,sha256=TvYELpMoWsUTcQdMV8tBHxCbEf_LbK4sESqK3r8PM6Y,78
+aline_ai-0.5.4.dist-info/top_level.txt,sha256=yIL3s2xv9nf1GwD5n71Aq_JEIV4AfzCIDNKBzewuRm4,8
+aline_ai-0.5.4.dist-info/RECORD,,

realign/__init__.py

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

realign/claude_hooks/permission_request_hook.py

@@ -25,7 +25,37 @@ stdin JSON format:
 import os
 import sys
 import json
+import time
 import subprocess
+from pathlib import Path
+
+
+def get_signal_dir() -> Path:
+    """Get the signal directory for permission requests."""
+    signal_dir = Path.home() / ".aline" / ".signals" / "permission_request"
+    signal_dir.mkdir(parents=True, exist_ok=True)
+    return signal_dir
+
+
+def write_signal_file(terminal_id: str, tool_name: str = "") -> None:
+    """Write a signal file to notify the dashboard of a permission request."""
+    try:
+        signal_dir = get_signal_dir()
+        timestamp_ms = int(time.time() * 1000)
+        signal_file = signal_dir / f"{terminal_id}_{timestamp_ms}.signal"
+        tmp_file = signal_dir / f"{terminal_id}_{timestamp_ms}.signal.tmp"
+
+        signal_data = {
+            "terminal_id": terminal_id,
+            "tool_name": tool_name,
+            "timestamp": time.time(),
+            "hook_event": "PermissionRequest",
+        }
+
+        tmp_file.write_text(json.dumps(signal_data, indent=2))
+        tmp_file.replace(signal_file)
+    except Exception:
+        pass  # Best effort
 
 
 def main():
@@ -142,6 +172,11 @@ def main():
         except Exception:
             pass
 
+        # Write signal file to notify dashboard (triggers file watcher refresh)
+        if terminal_id:
+            tool_name = data.get("tool_name", "")
+            write_signal_file(terminal_id, tool_name)
+
         # Exit 0 - don't block the permission request
         sys.exit(0)
 

realign/cli.py

@@ -157,6 +157,23 @@ def add_skills_cli(
     raise typer.Exit(code=exit_code)
 
 
+@add_app.command(name="skills-dev")
+def add_skills_dev_cli(
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing skills"),
+):
+    """Install developer skills from skill-dev/ directory.
+
+    Scans skill-dev/ for SKILL.md files and installs them to ~/.claude/skills/.
+    This is for developer use only.
+
+    Examples:
+        aline add skills-dev           # Install dev skills
+        aline add skills-dev --force   # Reinstall/update dev skills
+    """
+    exit_code = add.add_skills_dev_command(force=force)
+    raise typer.Exit(code=exit_code)
+
+
 @context_app.command(name="load")
 def context_load_cli(
     sessions: Optional[str] = typer.Option(

realign/commands/add.py

@@ -251,10 +251,233 @@ Use this skill when the user wants to:
 - Send Slack updates about completed work
 """
 
+# Aline Import History Sessions skill definition for Claude Code
+# Installed to ~/.claude/skills/aline-import-history-sessions/SKILL.md
+ALINE_IMPORT_HISTORY_SESSIONS_SKILL_MD = """---
+name: aline-import-history-sessions
+description: Guide users through importing Claude Code session history into Aline database. Use this for first-time setup, onboarding new users, or when users want to selectively import historical sessions. Provides interactive workflow with progress checking.
+---
+
+# Aline Import History Sessions Skill
+
+This skill guides users through the process of importing Claude Code session history into Aline's database. It provides an interactive, step-by-step workflow to help users discover, select, and import their historical sessions.
+
+## Workflow Overview
+
+```
+Analyze Unimported Sessions → Present Summary → User Selection → Import Sessions → Verify Success → Continue or Finish
+```
+
+## Step-by-Step Guide
+
+### Step 1: Analyze Current Status
+
+First, list all sessions to understand what hasn't been imported yet:
+
+```bash
+aline watcher session list --detect-turns
+```
+
+**Internal analysis (do NOT expose status terminology to user):**
+- Count sessions with status `new` → these are "unimported sessions"
+- Count sessions with status `partial` → these have "updates available"
+- Count sessions with status `tracked` → these are "already imported"
+
+Parse the output to extract:
+- Total number of unimported sessions
+- Their session IDs (use these for import, NOT index numbers)
+- Project paths they belong to
+
+### Step 2: Present Summary to User
+
+Present a user-friendly summary WITHOUT mentioning internal status labels:
+
+Example:
+> "I found **47 sessions** in your Claude Code history:
+> - **12 sessions** haven't been imported yet
+> - **3 sessions** have updates since last import
+> - **32 sessions** are already fully imported
+>
+> The unimported sessions span these projects:
+> - `/Users/you/Projects/ProjectA` (5 sessions)
+> - `/Users/you/Projects/ProjectB` (7 sessions)"
+
+### Step 3: Ask User Import Preferences
+
+Use `AskUserQuestion` to understand what the user wants to import:
+
+```json
+{
+  "questions": [{
+    "header": "Import scope",
+    "question": "Which sessions would you like to import?",
+    "options": [
+      {"label": "All unimported (Recommended)", "description": "Import all 12 sessions that haven't been imported yet"},
+      {"label": "Include updates", "description": "Import unimported sessions + update 3 sessions with new content"},
+      {"label": "Select by project", "description": "Choose which project's sessions to import"},
+      {"label": "Select specific", "description": "I'll review and pick individual sessions"}
+    ],
+    "multiSelect": false
+  }]
+}
+```
+
+### Step 4: Handle User Selection
+
+#### If "All unimported":
+Confirm the import with session count:
+```json
+{
+  "questions": [{
+    "header": "Confirm",
+    "question": "Ready to import 12 sessions. Proceed?",
+    "options": [
+      {"label": "Yes, import", "description": "Start importing all unimported sessions"},
+      {"label": "Let me review first", "description": "Show me the session list to review"}
+    ],
+    "multiSelect": false
+  }]
+}
+```
+
+#### If "Select by project":
+List the projects with unimported sessions and ask:
+```json
+{
+  "questions": [{
+    "header": "Project",
+    "question": "Which project's sessions should I import?",
+    "options": [
+      {"label": "ProjectA", "description": "5 unimported sessions"},
+      {"label": "ProjectB", "description": "7 unimported sessions"},
+      {"label": "Current directory", "description": "Import sessions from the current working directory"}
+    ],
+    "multiSelect": true
+  }]
+}
+```
+
+#### If "Select specific":
+Show the session list with details (project path, turn count, last modified) and let user specify which ones. When user provides selection, map their choice back to session IDs.
+
+### Step 5: Execute Import
+
+**IMPORTANT: Always use session_id for imports, NOT index numbers.** Index numbers can change between list operations and cause wrong sessions to be imported.
+
+```bash
+# Import by session ID (PREFERRED - always use this)
+aline watcher session import abc12345-6789-...
+
+# Import multiple by session ID
+aline watcher session import abc12345,def67890,ghi11111
+
+# With force flag (re-import already tracked)
+aline watcher session import abc12345 --force
+
+# With regenerate flag (update summaries)
+aline watcher session import abc12345 --regenerate
+
+# Synchronous import to wait for completion
+aline watcher session import abc12345 --sync
+```
+
+For importing multiple sessions, collect all the session IDs from your analysis and pass them comma-separated.
+
+### Step 6: Verify Import Success
+
+After import, check the status again:
+
+```bash
+aline watcher session list --detect-turns
+```
+
+Verify:
+- Previously unimported sessions should now show as imported
+- Check for any errors in the import output
+- Report success/failure count to user
+
+### Step 7: Ask If User Is Satisfied
+
+```json
+{
+  "questions": [{
+    "header": "Continue?",
+    "question": "Successfully imported X sessions. What would you like to do next?",
+    "options": [
+      {"label": "Import more", "description": "Select additional sessions to import"},
+      {"label": "View imported", "description": "Show details of imported sessions"},
+      {"label": "Done", "description": "Finish the import process"}
+    ],
+    "multiSelect": false
+  }]
+}
+```
+
+If user wants to import more, loop back to Step 1.
+
+### Step 8: Final Summary
+
+When the user is done, provide a summary:
+- Total sessions imported in this session
+- Sessions that were updated
+- Any errors encountered
+- Next steps: suggest `aline search` to explore their imported history
+
+## Command Reference
+
+| Command | Purpose |
+|---------|---------|
+| `aline watcher session list` | List all discovered sessions with status |
+| `aline watcher session list --detect-turns` | Include turn counts in listing |
+| `aline watcher session list -p N -n M` | Paginate: page N with M items per page |
+| `aline watcher session import <session_id>` | Import by session ID (recommended) |
+| `aline watcher session import <id1>,<id2>` | Import multiple sessions by ID |
+| `aline watcher session import <id> -f` | Force re-import |
+| `aline watcher session import <id> -r` | Regenerate LLM summaries |
+| `aline watcher session import <id> --sync` | Synchronous import (wait for completion) |
+| `aline watcher session show <session_id>` | View details of a specific session |
+
+## Important: Use Session IDs, Not Index Numbers
+
+**Always use session_id (UUID) for import operations.**
+
+Why:
+- Index numbers are assigned dynamically and can change between list commands
+- Using wrong index could import unintended sessions
+- Session IDs are stable and unique identifiers
+
+Example session ID format: `e58f67bf-ebba-47bd-9371-5ef9e06697d3`
+
+You can use UUID prefix for convenience: `e58f67bf` (first 8 characters)
+
+## Error Handling
+
+- **No sessions found**: Check if Claude Code history exists at `~/.claude/projects/`. Suggest running some Claude Code sessions first.
+- **Import fails**: Check disk space, database permissions at `~/.aline/db/aline.db`
+- **Partial import**: Some sessions may fail due to corrupted JSONL files. Report specific errors and suggest `--force` retry.
+- **Watcher not running**: If async import doesn't complete, suggest `aline watcher start` or use `--sync` flag.
+
+## Tips for Large Imports
+
+- For many sessions (50+), import in batches to track progress
+- Use `--sync` flag to see real-time progress for smaller batches
+- Check `~/.aline/.logs/watcher.log` for detailed import logs
+
+## When to Use This Skill
+
+Use this skill when:
+- User is setting up Aline for the first time
+- User wants to import historical Claude Code sessions
+- User asks "how do I import my history?" or similar
+- User wants to selectively import specific project sessions
+- User needs to re-import or update existing sessions
+"""
+
 # Registry of all skills to install
 SKILLS_REGISTRY: dict[str, str] = {
     "aline": ALINE_SKILL_MD,
     "aline-share": ALINE_SHARE_SKILL_MD,
+    "aline-import-history-sessions": ALINE_IMPORT_HISTORY_SESSIONS_SKILL_MD,
 }
 
 
@@ -365,3 +588,83 @@ def add_skills_command(force: bool = False) -> int:
 
     return 1 if failed_skills else 0
 
+
+def add_skills_dev_command(force: bool = False) -> int:
+    """Install developer skills from skill-dev/ directory.
+
+    Scans the skill-dev/ folder in the project root for SKILL.md files
+    and installs them to ~/.claude/skills/
+
+    This is for developer use only - skills in development that are not
+    yet bundled into the package.
+
+    Args:
+        force: Overwrite existing skills if they exist
+
+    Returns:
+        Exit code (0 for success, 1 for failure)
+    """
+    # Find skill-dev directory relative to this file's package location
+    # Go up from src/realign/commands/add.py to project root
+    package_root = Path(__file__).parent.parent.parent.parent
+    skill_dev_dir = package_root / "skill-dev"
+
+    if not skill_dev_dir.exists():
+        console.print(f"[red]skill-dev/ directory not found at:[/red] {skill_dev_dir}")
+        console.print("[dim]This command is for developer use only.[/dim]")
+        return 1
+
+    claude_skill_root = Path.home() / ".claude" / "skills"
+    installed_skills: list[str] = []
+    skipped_skills: list[str] = []
+    failed_skills: list[tuple[str, str]] = []
+
+    # Scan skill-dev for directories containing SKILL.md
+    for skill_dir in skill_dev_dir.iterdir():
+        if not skill_dir.is_dir():
+            continue
+
+        skill_file = skill_dir / "SKILL.md"
+        if not skill_file.exists():
+            continue
+
+        skill_name = skill_dir.name
+        dest_path = claude_skill_root / skill_name / "SKILL.md"
+
+        # Check if skill already exists
+        if dest_path.exists() and not force:
+            skipped_skills.append(skill_name)
+            continue
+
+        try:
+            skill_content = skill_file.read_text(encoding="utf-8")
+            _install_skill_to_path(claude_skill_root, skill_name, skill_content)
+            installed_skills.append(skill_name)
+        except Exception as e:
+            failed_skills.append((skill_name, str(e)))
+
+    if not installed_skills and not skipped_skills and not failed_skills:
+        console.print("[yellow]No skills found in skill-dev/[/yellow]")
+        console.print("[dim]Each skill should be in its own directory with a SKILL.md file.[/dim]")
+        return 0
+
+    # Report results
+    for skill_name in installed_skills:
+        skill_path = claude_skill_root / skill_name / "SKILL.md"
+        console.print(f"[green]✓[/green] Installed: [cyan]{skill_path}[/cyan]")
+
+    for skill_name in skipped_skills:
+        skill_path = claude_skill_root / skill_name / "SKILL.md"
+        console.print(f"[yellow]⊘[/yellow] Already exists: [dim]{skill_path}[/dim]")
+
+    for skill_name, error in failed_skills:
+        console.print(f"[red]✗[/red] Failed to install {skill_name}: {error}")
+
+    if skipped_skills and not installed_skills:
+        console.print("[dim]Use --force to overwrite existing skills[/dim]")
+    elif installed_skills:
+        skill_names = ", ".join(f"/{s}" for s in installed_skills)
+        console.print(f"[dim]Restart Claude Code to activate: {skill_names}[/dim]")
+
+    return 1 if failed_skills else 0
+

realign/dashboard/tmux_manager.py

@@ -14,6 +14,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import time
 import uuid
 from dataclasses import dataclass
 from pathlib import Path
@@ -39,6 +40,7 @@ OPT_SESSION_ID = "@aline_session_id"
 OPT_TRANSCRIPT_PATH = "@aline_transcript_path"
 OPT_CONTEXT_ID = "@aline_context_id"
 OPT_ATTENTION = "@aline_attention"
+OPT_CREATED_AT = "@aline_created_at"
 
 
 @dataclass(frozen=True)
@@ -53,6 +55,7 @@ class InnerWindow:
     transcript_path: str | None = None
     context_id: str | None = None
     attention: str | None = None  # "permission_request", "stop", or None
+    created_at: float | None = None  # Unix timestamp when window was created
 
 
 def tmux_available() -> bool:
@@ -484,6 +487,8 @@ def list_inner_windows() -> list[InnerWindow]:
                 + OPT_CONTEXT_ID
                 + "}\t#{"
                 + OPT_ATTENTION
+                + "}\t#{"
+                + OPT_CREATED_AT
                 + "}",
             ],
             capture=True,
@@ -505,6 +510,13 @@ def list_inner_windows() -> list[InnerWindow]:
         transcript_path = parts[7] if len(parts) > 7 and parts[7] else None
         context_id = parts[8] if len(parts) > 8 and parts[8] else None
         attention = parts[9] if len(parts) > 9 and parts[9] else None
+        created_at_str = parts[10] if len(parts) > 10 and parts[10] else None
+        created_at: float | None = None
+        if created_at_str:
+            try:
+                created_at = float(created_at_str)
+            except ValueError:
+                pass
 
         if terminal_id:
             persisted = state.get(terminal_id) or {}
@@ -535,8 +547,11 @@ def list_inner_windows() -> list[InnerWindow]:
                 transcript_path=transcript_path,
                 context_id=context_id,
                 attention=attention,
+                created_at=created_at,
             )
         )
+    # Sort by creation time (newest first). Windows without created_at go to the bottom.
+    windows.sort(key=lambda w: w.created_at if w.created_at is not None else 0, reverse=True)
     return windows
 
 
@@ -551,11 +566,6 @@ def set_inner_window_options(window_id: str, options: dict[str, str]) -> bool:
     return ok
 
 
-def clear_attention(window_id: str) -> bool:
-    """Clear attention state on a window."""
-    return set_inner_window_options(window_id, {OPT_ATTENTION: ""})
-
-
 def kill_inner_window(window_id: str) -> bool:
     if not ensure_inner_session():
         return False
@@ -576,6 +586,9 @@ def create_inner_window(
     existing = list_inner_windows()
     name = _unique_name((w.window_name for w in existing), base_name)
 
+    # Record creation time before creating the window
+    created_at = time.time()
+
     proc = _run_inner_tmux(
         [
             "new-window",
@@ -598,18 +611,18 @@ def create_inner_window(
         return None
     window_id, window_name = (created[0].split("\t", 1) + [""])[:2]
 
-    if terminal_id or provider or context_id:
-        opts: dict[str, str] = {}
-        if terminal_id:
-            opts[OPT_TERMINAL_ID] = terminal_id
-        if provider:
-            opts[OPT_PROVIDER] = provider
-        if context_id:
-            opts[OPT_CONTEXT_ID] = context_id
-        opts.setdefault(OPT_SESSION_TYPE, "")
-        opts.setdefault(OPT_SESSION_ID, "")
-        opts.setdefault(OPT_TRANSCRIPT_PATH, "")
-        set_inner_window_options(window_id, opts)
+    # Always set options including the creation timestamp
+    opts: dict[str, str] = {OPT_CREATED_AT: str(created_at)}
+    if terminal_id:
+        opts[OPT_TERMINAL_ID] = terminal_id
+    if provider:
+        opts[OPT_PROVIDER] = provider
+    if context_id:
+        opts[OPT_CONTEXT_ID] = context_id
+    opts.setdefault(OPT_SESSION_TYPE, "")
+    opts.setdefault(OPT_SESSION_ID, "")
+    opts.setdefault(OPT_TRANSCRIPT_PATH, "")
+    set_inner_window_options(window_id, opts)
 
     _run_inner_tmux(["select-window", "-t", window_id])
 
@@ -620,6 +633,7 @@ def create_inner_window(
         terminal_id=terminal_id,
         provider=provider,
         context_id=context_id,
+        created_at=created_at,
     )
 
 
@@ -629,6 +643,16 @@ def select_inner_window(window_id: str) -> bool:
     return _run_inner_tmux(["select-window", "-t", window_id]).returncode == 0
 
 
+def clear_attention(window_id: str) -> bool:
+    """Clear the attention state for a window (e.g., after user acknowledges permission request)."""
+    if not ensure_inner_session():
+        return False
+    return (
+        _run_inner_tmux(["set-option", "-w", "-t", window_id, OPT_ATTENTION, ""]).returncode
+        == 0
+    )
+
+
 def get_active_claude_context_id() -> str | None:
     """Return the active inner tmux window's Claude ALINE_CONTEXT_ID (if any)."""
     try:

realign/dashboard/widgets/terminal_panel.py

@@ -13,16 +13,127 @@ import re
 import shlex
 import subprocess
 from pathlib import Path
+from typing import Callable
 
 from textual.app import ComposeResult
 from textual.containers import Container, Horizontal, Vertical, VerticalScroll
+from textual.message import Message
 from textual.widgets import Button, Static
 from rich.text import Text
 
 from .. import tmux_manager
 
 
+# Signal directory for permission request notifications
+PERMISSION_SIGNAL_DIR = Path.home() / ".aline" / ".signals" / "permission_request"
+
+
+class _SignalFileWatcher:
+    """Watches for new signal files in the permission_request directory.
+
+    Uses OS-native file watching via asyncio when available,
+    otherwise falls back to checking directory mtime.
+    """
+
+    def __init__(self, callback: Callable[[], None]) -> None:
+        self._callback = callback
+        self._running = False
+        self._task: asyncio.Task | None = None
+        self._last_mtime: float = 0
+        self._seen_files: set[str] = set()
+
+    def start(self) -> None:
+        if self._running:
+            return
+        self._running = True
+        # Initialize seen files
+        self._scan_existing_files()
+        self._task = asyncio.create_task(self._watch_loop())
+
+    def stop(self) -> None:
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            self._task = None
+
+    def _scan_existing_files(self) -> None:
+        """Record existing signal files so we only react to new ones."""
+        try:
+            if PERMISSION_SIGNAL_DIR.exists():
+                self._seen_files = {
+                    f.name for f in PERMISSION_SIGNAL_DIR.iterdir()
+                    if f.suffix == ".signal"
+                }
+        except Exception:
+            self._seen_files = set()
+
+    async def _watch_loop(self) -> None:
+        """Watch for new signal files using directory mtime checks."""
+        try:
+            while self._running:
+                # Wait a bit before checking (reduces CPU usage)
+                await asyncio.sleep(0.5)
+
+                if not self._running:
+                    break
+
+                try:
+                    if not PERMISSION_SIGNAL_DIR.exists():
+                        continue
+
+                    # Check if directory was modified
+                    current_mtime = PERMISSION_SIGNAL_DIR.stat().st_mtime
+                    if current_mtime <= self._last_mtime:
+                        continue
+                    self._last_mtime = current_mtime
+
+                    # Check for new signal files
+                    current_files = {
+                        f.name for f in PERMISSION_SIGNAL_DIR.iterdir()
+                        if f.suffix == ".signal"
+                    }
+                    new_files = current_files - self._seen_files
+
+                    if new_files:
+                        self._seen_files = current_files
+                        # New signal file detected - trigger callback
+                        self._callback()
+                        # Clean up old signal files (keep last 10)
+                        self._cleanup_old_signals()
+
+                except Exception:
+                    pass  # Ignore errors, keep watching
+
+        except asyncio.CancelledError:
+            pass
+
+    def _cleanup_old_signals(self) -> None:
+        """Remove old signal files to prevent directory from growing."""
+        try:
+            if not PERMISSION_SIGNAL_DIR.exists():
+                return
+            files = sorted(
+                PERMISSION_SIGNAL_DIR.glob("*.signal"),
+                key=lambda f: f.stat().st_mtime,
+                reverse=True
+            )
+            # Keep only the 10 most recent
+            for f in files[10:]:
+                try:
+                    f.unlink()
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+
 class TerminalPanel(Container, can_focus=True):
+    """Terminal controls panel with permission request notifications."""
+
+    class PermissionRequestDetected(Message):
+        """Posted when a new permission request signal file is detected."""
+        pass
+
     DEFAULT_CSS = """
     TerminalPanel {
         height: 100%;
@@ -179,6 +290,7 @@ class TerminalPanel(Container, can_focus=True):
         super().__init__()
         self._refresh_lock = asyncio.Lock()
         self._expanded_window_id: str | None = None
+        self._signal_watcher: _SignalFileWatcher | None = None
 
     def compose(self) -> ComposeResult:
         controls_enabled = self.supported()
@@ -205,6 +317,40 @@ class TerminalPanel(Container, can_focus=True):
                 exclusive=True,
             )
         )
+        # Start watching for permission request signals
+        self._start_signal_watcher()
+
+    def on_hide(self) -> None:
+        # Stop watching when panel is hidden
+        self._stop_signal_watcher()
+
+    def _start_signal_watcher(self) -> None:
+        """Start watching for permission request signal files."""
+        if self._signal_watcher is not None:
+            return
+        self._signal_watcher = _SignalFileWatcher(self._on_permission_signal)
+        self._signal_watcher.start()
+
+    def _stop_signal_watcher(self) -> None:
+        """Stop watching for permission request signal files."""
+        if self._signal_watcher is not None:
+            self._signal_watcher.stop()
+            self._signal_watcher = None
+
+    def _on_permission_signal(self) -> None:
+        """Called when a new permission request signal is detected."""
+        # Post message to trigger refresh on the main thread
+        self.post_message(self.PermissionRequestDetected())
+
+    def on_terminal_panel_permission_request_detected(
+        self, event: PermissionRequestDetected
+    ) -> None:
+        """Handle permission request detection - refresh the terminal list."""
+        self.run_worker(
+            self.refresh_data(),
+            group="terminal-panel-refresh",
+            exclusive=True,
+        )
 
     async def refresh_data(self) -> None:
         async with self._refresh_lock: