taskmux 0.2.4__tar.gz → 0.2.6__tar.gz

{taskmux-0.2.4 → taskmux-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskmux
-Version: 0.2.4
+Version: 0.2.6
 Summary: Modern tmux-based task manager for LLM development tools
 Project-URL: Homepage, https://github.com/nc9/taskmux
 Project-URL: Repository, https://github.com/nc9/taskmux
@@ -104,6 +104,67 @@ command = "docker compose up postgres"
 auto_start = false
 ```
 
+## Full Example
+
+A full-stack app with a database, API server, and frontend — using health checks to ensure each service is ready before starting its dependents:
+
+```toml
+name = "fullstack-app"
+
+[tasks.db]
+command = "docker compose up postgres redis"
+health_check = "pg_isready -h localhost -p 5432"
+health_interval = 3
+
+[tasks.migrate]
+command = "python manage.py migrate && echo 'done' && sleep infinity"
+cwd = "apps/api"
+depends_on = ["db"]
+health_check = "test -f .migrate-complete"
+
+[tasks.api]
+command = "python manage.py runserver 0.0.0.0:8000"
+cwd = "apps/api"
+depends_on = ["migrate"]
+health_check = "curl -sf http://localhost:8000/health"
+
+[tasks.worker]
+command = "celery -A myapp worker -l info"
+cwd = "apps/api"
+depends_on = ["db"]
+
+[tasks.web]
+command = "bun dev"
+cwd = "apps/web"
+depends_on = ["api"]
+health_check = "curl -sf http://localhost:3000"
+
+[tasks.storybook]
+command = "bun storybook"
+cwd = "apps/web"
+auto_start = false
+```
+
+What happens on `taskmux start`:
+
+1. **db** starts first (no dependencies)
+2. **migrate** and **worker** wait for db's health check (`pg_isready`) to pass
+3. **api** waits for migrate's health check
+4. **web** waits for api's health check (`curl localhost:8000/health`)
+5. **storybook** is skipped (`auto_start = false`) — start it manually with `taskmux start storybook`
+
+```bash
+taskmux start                    # Starts everything in dependency order
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs -g "ERROR"          # Grep all tasks for errors
+taskmux logs api                 # Logs from just the API
+taskmux logs -f api              # Follow API logs live
+taskmux health                   # Health check table
+taskmux inspect api              # JSON state for a single task
+taskmux restart worker           # Restart just the worker
+taskmux start storybook          # Start a manual task
+```
+
 ## Commands
 
 ```bash
@@ -124,10 +185,13 @@ taskmux remove <task>            # Remove task from config
 taskmux inspect <task>           # JSON task state (pid, command, health)
 
 # Logs
-taskmux logs <task>              # Show recent logs
-taskmux logs -f <task>           # Follow logs live
-taskmux logs -n 100 <task>       # Last N lines
-taskmux logs <task> -g "error"   # Search logs with grep
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs <task>              # Show recent logs for a task
+taskmux logs -f                  # Attach to session (switch windows with tmux keybinds)
+taskmux logs -f <task>           # Follow a task's logs live
+taskmux logs -n 200 <task>       # Last N lines
+taskmux logs -g "error"          # Search all tasks
+taskmux logs <task> -g "error"   # Search one task
 taskmux logs <task> -g "error" -C 5  # Grep with context lines
 
 # Init
@@ -161,12 +225,20 @@ after_stop = "echo done"
 
 [tasks.server]
 command = "python manage.py runserver"
+cwd = "apps/api"
+health_check = "curl -sf http://localhost:8000/health"
+depends_on = ["db"]
 
 [tasks.server.hooks]
 before_start = "python manage.py migrate"
 
+[tasks.db]
+command = "docker compose up postgres"
+health_check = "pg_isready -h localhost"
+
 [tasks.worker]
 command = "celery worker -A myapp"
+depends_on = ["db"]
 
 [tasks.tailwind]
 command = "npx tailwindcss -w"
@@ -185,8 +257,31 @@ auto_start = false
 | `hooks.after_stop` | — | Run after stopping tasks |
 | `tasks.<name>.command` | — | Shell command to run |
 | `tasks.<name>.auto_start` | `true` | Start with `taskmux start` |
+| `tasks.<name>.cwd` | — | Working directory for the task |
+| `tasks.<name>.health_check` | — | Shell command to check health (exit 0 = healthy) |
+| `tasks.<name>.health_interval` | `10` | Seconds between health checks |
+| `tasks.<name>.health_timeout` | `5` | Seconds before health check times out |
+| `tasks.<name>.health_retries` | `3` | Consecutive failures before "unhealthy" |
+| `tasks.<name>.depends_on` | `[]` | Task names that must be healthy before this task starts |
 | `tasks.<name>.hooks.*` | — | Per-task lifecycle hooks (same fields as global) |
 
+### Dependency Ordering
+
+Tasks with `depends_on` are started in topological order. Before starting a task, taskmux waits for each dependency's health check to pass (up to `health_retries * health_interval` seconds). If a dependency never becomes healthy, the dependent task is skipped with a warning.
+
+Circular dependencies and references to nonexistent tasks are rejected at config load time.
+
+When starting a single task with `taskmux start <task>`, dependencies are not auto-started — you get a warning if they aren't running.
+
+### Health Checks
+
+If `health_check` is set, taskmux runs it as a shell command. Exit code 0 means healthy. If not set, taskmux falls back to checking if the tmux pane has a running process (not just a shell prompt).
+
+Health checks are used by:
+- `taskmux health` — shows a table of all task health
+- `taskmux start` — waits for dependencies to be healthy before starting dependents
+- `taskmux daemon` — continuously monitors and auto-restarts unhealthy tasks
+
 ### Hook Cascade
 
 Hooks fire in this order:
@@ -212,14 +307,17 @@ Use `--defaults` to skip prompts (CI/automation).
 
 ```json
 {
-  "name": "server",
-  "command": "npm run dev",
+  "name": "api",
+  "command": "python manage.py runserver 0.0.0.0:8000",
   "auto_start": true,
+  "cwd": "apps/api",
+  "health_check": "curl -sf http://localhost:8000/health",
+  "depends_on": ["db"],
   "running": true,
   "healthy": true,
   "pid": "12345",
-  "pane_current_command": "node",
-  "pane_current_path": "/home/user/project",
+  "pane_current_command": "python",
+  "pane_current_path": "/home/user/project/apps/api",
   "window_id": "@1",
   "pane_id": "%1"
 }

{taskmux-0.2.4 → taskmux-0.2.6}/README.md

@@ -69,6 +69,67 @@ command = "docker compose up postgres"
 auto_start = false
 ```
 
+## Full Example
+
+A full-stack app with a database, API server, and frontend — using health checks to ensure each service is ready before starting its dependents:
+
+```toml
+name = "fullstack-app"
+
+[tasks.db]
+command = "docker compose up postgres redis"
+health_check = "pg_isready -h localhost -p 5432"
+health_interval = 3
+
+[tasks.migrate]
+command = "python manage.py migrate && echo 'done' && sleep infinity"
+cwd = "apps/api"
+depends_on = ["db"]
+health_check = "test -f .migrate-complete"
+
+[tasks.api]
+command = "python manage.py runserver 0.0.0.0:8000"
+cwd = "apps/api"
+depends_on = ["migrate"]
+health_check = "curl -sf http://localhost:8000/health"
+
+[tasks.worker]
+command = "celery -A myapp worker -l info"
+cwd = "apps/api"
+depends_on = ["db"]
+
+[tasks.web]
+command = "bun dev"
+cwd = "apps/web"
+depends_on = ["api"]
+health_check = "curl -sf http://localhost:3000"
+
+[tasks.storybook]
+command = "bun storybook"
+cwd = "apps/web"
+auto_start = false
+```
+
+What happens on `taskmux start`:
+
+1. **db** starts first (no dependencies)
+2. **migrate** and **worker** wait for db's health check (`pg_isready`) to pass
+3. **api** waits for migrate's health check
+4. **web** waits for api's health check (`curl localhost:8000/health`)
+5. **storybook** is skipped (`auto_start = false`) — start it manually with `taskmux start storybook`
+
+```bash
+taskmux start                    # Starts everything in dependency order
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs -g "ERROR"          # Grep all tasks for errors
+taskmux logs api                 # Logs from just the API
+taskmux logs -f api              # Follow API logs live
+taskmux health                   # Health check table
+taskmux inspect api              # JSON state for a single task
+taskmux restart worker           # Restart just the worker
+taskmux start storybook          # Start a manual task
+```
+
 ## Commands
 
 ```bash
@@ -89,10 +150,13 @@ taskmux remove <task>            # Remove task from config
 taskmux inspect <task>           # JSON task state (pid, command, health)
 
 # Logs
-taskmux logs <task>              # Show recent logs
-taskmux logs -f <task>           # Follow logs live
-taskmux logs -n 100 <task>       # Last N lines
-taskmux logs <task> -g "error"   # Search logs with grep
+taskmux logs                     # Interleaved logs from all tasks
+taskmux logs <task>              # Show recent logs for a task
+taskmux logs -f                  # Attach to session (switch windows with tmux keybinds)
+taskmux logs -f <task>           # Follow a task's logs live
+taskmux logs -n 200 <task>       # Last N lines
+taskmux logs -g "error"          # Search all tasks
+taskmux logs <task> -g "error"   # Search one task
 taskmux logs <task> -g "error" -C 5  # Grep with context lines
 
 # Init
@@ -126,12 +190,20 @@ after_stop = "echo done"
 
 [tasks.server]
 command = "python manage.py runserver"
+cwd = "apps/api"
+health_check = "curl -sf http://localhost:8000/health"
+depends_on = ["db"]
 
 [tasks.server.hooks]
 before_start = "python manage.py migrate"
 
+[tasks.db]
+command = "docker compose up postgres"
+health_check = "pg_isready -h localhost"
+
 [tasks.worker]
 command = "celery worker -A myapp"
+depends_on = ["db"]
 
 [tasks.tailwind]
 command = "npx tailwindcss -w"
@@ -150,8 +222,31 @@ auto_start = false
 | `hooks.after_stop` | — | Run after stopping tasks |
 | `tasks.<name>.command` | — | Shell command to run |
 | `tasks.<name>.auto_start` | `true` | Start with `taskmux start` |
+| `tasks.<name>.cwd` | — | Working directory for the task |
+| `tasks.<name>.health_check` | — | Shell command to check health (exit 0 = healthy) |
+| `tasks.<name>.health_interval` | `10` | Seconds between health checks |
+| `tasks.<name>.health_timeout` | `5` | Seconds before health check times out |
+| `tasks.<name>.health_retries` | `3` | Consecutive failures before "unhealthy" |
+| `tasks.<name>.depends_on` | `[]` | Task names that must be healthy before this task starts |
 | `tasks.<name>.hooks.*` | — | Per-task lifecycle hooks (same fields as global) |
 
+### Dependency Ordering
+
+Tasks with `depends_on` are started in topological order. Before starting a task, taskmux waits for each dependency's health check to pass (up to `health_retries * health_interval` seconds). If a dependency never becomes healthy, the dependent task is skipped with a warning.
+
+Circular dependencies and references to nonexistent tasks are rejected at config load time.
+
+When starting a single task with `taskmux start <task>`, dependencies are not auto-started — you get a warning if they aren't running.
+
+### Health Checks
+
+If `health_check` is set, taskmux runs it as a shell command. Exit code 0 means healthy. If not set, taskmux falls back to checking if the tmux pane has a running process (not just a shell prompt).
+
+Health checks are used by:
+- `taskmux health` — shows a table of all task health
+- `taskmux start` — waits for dependencies to be healthy before starting dependents
+- `taskmux daemon` — continuously monitors and auto-restarts unhealthy tasks
+
 ### Hook Cascade
 
 Hooks fire in this order:
@@ -177,14 +272,17 @@ Use `--defaults` to skip prompts (CI/automation).
 
 ```json
 {
-  "name": "server",
-  "command": "npm run dev",
+  "name": "api",
+  "command": "python manage.py runserver 0.0.0.0:8000",
   "auto_start": true,
+  "cwd": "apps/api",
+  "health_check": "curl -sf http://localhost:8000/health",
+  "depends_on": ["db"],
   "running": true,
   "healthy": true,
   "pid": "12345",
-  "pane_current_command": "node",
-  "pane_current_path": "/home/user/project",
+  "pane_current_command": "python",
+  "pane_current_path": "/home/user/project/apps/api",
   "window_id": "@1",
   "pane_id": "%1"
 }

{taskmux-0.2.4 → taskmux-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "taskmux"
-version = "0.2.4"
+version = "0.2.6"
 description = "Modern tmux-based task manager for LLM development tools"
 readme = "README.md"
 license-file = "LICENSE"

{taskmux-0.2.4 → taskmux-0.2.6}/taskmux/config.py

@@ -106,6 +106,8 @@ def writeConfig(path: Path | None, config: TaskmuxConfig) -> Path:
             inner.add("auto_start", False)
         if task_cfg.cwd is not None:
             inner.add("cwd", task_cfg.cwd)
+        if task_cfg.port is not None:
+            inner.add("port", task_cfg.port)
         if task_cfg.health_check is not None:
             inner.add("health_check", task_cfg.health_check)
         if task_cfg.health_interval != 10:
@@ -114,6 +116,12 @@ def writeConfig(path: Path | None, config: TaskmuxConfig) -> Path:
             inner.add("health_timeout", task_cfg.health_timeout)
         if task_cfg.health_retries != 3:
             inner.add("health_retries", task_cfg.health_retries)
+        if task_cfg.stop_grace_period != 5:
+            inner.add("stop_grace_period", task_cfg.stop_grace_period)
+        if task_cfg.max_restarts != 5:
+            inner.add("max_restarts", task_cfg.max_restarts)
+        if task_cfg.restart_backoff != 2.0:
+            inner.add("restart_backoff", task_cfg.restart_backoff)
         if task_cfg.depends_on:
             inner.add("depends_on", task_cfg.depends_on)
         # Task-level hooks

{taskmux-0.2.4 → taskmux-0.2.6}/taskmux/daemon.py

@@ -39,6 +39,26 @@ class ConfigWatcher(FileSystemEventHandler):
                 self.taskmux_cli.handle_config_reload()
 
 
+class RestartTracker:
+    """Tracks per-task restart counts and timestamps for backoff."""
+
+    def __init__(self) -> None:
+        self._data: dict[str, dict[str, float]] = {}
+
+    def get(self, task_name: str) -> dict[str, float]:
+        return self._data.get(task_name, {"count": 0, "last": 0.0})
+
+    def record(self, task_name: str) -> None:
+        info = self.get(task_name)
+        self._data[task_name] = {
+            "count": info["count"] + 1,
+            "last": time.time(),
+        }
+
+    def reset(self, task_name: str) -> None:
+        self._data.pop(task_name, None)
+
+
 class TaskmuxDaemon:
     """Daemon mode for Taskmux with enhanced monitoring and API"""
 
@@ -51,6 +71,7 @@ class TaskmuxDaemon:
         self.health_check_interval = 30
         self.health_check_task: asyncio.Task | None = None
         self.websocket_clients: set = set()
+        self.restart_tracker = RestartTracker()
         self.logger = self._setup_logging()
 
         signal.signal(signal.SIGINT, self._signal_handler)
@@ -124,11 +145,11 @@ class TaskmuxDaemon:
         self.logger.info("Taskmux daemon stopped")
 
     async def _health_check_loop(self) -> None:
-        """Continuous health checking loop"""
+        """Continuous health checking loop with restart backoff."""
         while self.running:
             try:
                 if self.cli and self.cli.tmux.session_exists():
-                    self.cli.tmux.auto_restart_unhealthy_tasks()
+                    self._auto_restart_with_backoff()
 
                     if self.websocket_clients:
                         status = await self._get_full_status()
@@ -139,6 +160,42 @@ class TaskmuxDaemon:
                 self.logger.error(f"Health check error: {e}")
                 await asyncio.sleep(5)
 
+    def _auto_restart_with_backoff(self) -> None:
+        """Auto-restart unhealthy tasks with exponential backoff."""
+        assert self.cli is not None
+        now = time.time()
+
+        for task_name, task_cfg in self.cli.config.tasks.items():
+            healthy = self.cli.tmux.check_task_health(task_name)
+
+            if healthy:
+                # Reset tracker if healthy for >60s
+                info = self.restart_tracker.get(task_name)
+                if info["count"] > 0 and now - info["last"] > 60:
+                    self.restart_tracker.reset(task_name)
+                continue
+
+            # Skip if not previously healthy (avoid restart loop on first check)
+            prev_health = self.cli.tmux.task_health.get(task_name, {}).get("healthy", True)
+            if not prev_health:
+                info = self.restart_tracker.get(task_name)
+
+                # Check max_restarts
+                if task_cfg.max_restarts and info["count"] >= task_cfg.max_restarts:
+                    self.logger.warning(
+                        f"Task '{task_name}' exceeded max restarts ({task_cfg.max_restarts})"
+                    )
+                    continue
+
+                # Check backoff delay
+                delay = min(task_cfg.restart_backoff ** info["count"], 60)
+                if info["last"] and now - info["last"] < delay:
+                    continue
+
+            self.logger.info(f"Auto-restarting unhealthy task: {task_name}")
+            self.cli.tmux.restart_task(task_name)
+            self.restart_tracker.record(task_name)
+
     async def _start_api_server(self) -> None:
         """Start WebSocket API server"""
 

{taskmux-0.2.4 → taskmux-0.2.6}/taskmux/models.py

@@ -37,10 +37,14 @@ class TaskConfig(_StrictConfig):
     command: str
     auto_start: bool = True
     cwd: str | None = None
+    port: int | None = None
     health_check: str | None = None
     health_interval: int = 10
     health_timeout: int = 5
     health_retries: int = 3
+    stop_grace_period: int = 5
+    max_restarts: int = 5
+    restart_backoff: float = 2.0
     depends_on: list[str] = []
     hooks: HookConfig = HookConfig()
 

{taskmux-0.2.4 → taskmux-0.2.6}/taskmux/tmux_manager.py

@@ -2,16 +2,38 @@
 
 from __future__ import annotations
 
+import contextlib
+import os
+import signal as sig
 import subprocess
 import time
 from collections import deque
 from datetime import datetime
 
 import libtmux
+from rich.console import Console
+from rich.markup import escape
 
 from .hooks import runHook
 from .models import TaskmuxConfig
 
+SHELL_NAMES = frozenset(("bash", "zsh", "sh", "fish"))
+
+TASK_COLORS = ["cyan", "green", "yellow", "magenta", "blue", "red"]
+
+
+def _find_new_lines(current: list[str], prev_tail: list[str]) -> list[str]:
+    """Return lines in current that are new since prev_tail."""
+    if not prev_tail:
+        return current
+    target = prev_tail[-1]
+    for i in range(len(current) - 1, -1, -1):
+        if current[i] == target:
+            ctx = min(len(prev_tail), i + 1)
+            if current[i - ctx + 1 : i + 1] == prev_tail[-ctx:]:
+                return current[i + 1 :]
+    return current  # no match, prev scrolled away — return all
+
 
 class TmuxManager:
     """Manages tmux sessions and tasks using libtmux API."""
@@ -57,11 +79,61 @@ class TmuxManager:
             window = self._get_session().windows.get(window_name=task_name, default=None)
             if window and window.active_pane:
                 cmd = getattr(window.active_pane, "pane_current_command", "")
-                return cmd != "" and cmd != "bash"
+                return cmd != "" and cmd not in SHELL_NAMES
         except Exception:
             pass
         return False
 
+    def _wait_for_exit(self, pane: libtmux.Pane, timeout: float) -> bool:
+        """Poll pane_current_command until it returns to a shell or timeout."""
+        elapsed = 0.0
+        while elapsed < timeout:
+            time.sleep(0.5)
+            elapsed += 0.5
+            cmd = getattr(pane, "pane_current_command", "")
+            if cmd == "" or cmd in SHELL_NAMES:
+                return True
+        return False
+
+    def _get_pane_child_pid(self, pane: libtmux.Pane) -> int | None:
+        """Get the child process PID running inside the pane's shell."""
+        shell_pid = getattr(pane, "pane_pid", None)
+        if not shell_pid:
+            return None
+        try:
+            result = subprocess.run(
+                ["pgrep", "-P", str(shell_pid)],
+                capture_output=True,
+                text=True,
+            )
+            pids = result.stdout.strip().split("\n")
+            return int(pids[0]) if pids and pids[0] else None
+        except (ValueError, OSError):
+            return None
+
+    def _kill_process_tree(self, pid: int, signal_num: int = sig.SIGKILL) -> None:
+        """Kill process and all children via process group."""
+        try:
+            pgid = os.getpgid(pid)
+            os.killpg(pgid, signal_num)
+        except (ProcessLookupError, PermissionError, OSError):
+            pass
+
+    def _cleanup_port(self, port: int) -> None:
+        """Kill any process listening on port."""
+        try:
+            result = subprocess.run(
+                ["lsof", "-ti", f":{port}"],
+                capture_output=True,
+                text=True,
+            )
+            for pid_str in result.stdout.strip().split("\n"):
+                if pid_str.strip():
+                    with contextlib.suppress(ProcessLookupError, PermissionError, OSError):
+                        os.kill(int(pid_str.strip()), sig.SIGKILL)
+        except OSError:
+            pass
+
     def is_task_healthy(self, task_name: str) -> bool:
         """Check task health. Uses health_check command if configured, falls back to pane-alive."""
         task_cfg = self.config.tasks.get(task_name)
@@ -171,6 +243,10 @@ class TmuxManager:
         sess = self._get_session()
         task_cfg = self.config.tasks[task_name]
 
+        # Kill anything occupying the port before starting
+        if task_cfg.port:
+            self._cleanup_port(task_cfg.port)
+
         # Check if already running
         existing = sess.windows.get(window_name=task_name, default=None)
         if existing:
@@ -209,7 +285,7 @@ class TmuxManager:
         print(f"Started task '{task_name}'")
 
     def stop_task(self, task_name: str) -> None:
-        """Graceful stop (C-c) a single task. Window stays alive."""
+        """Graceful stop with signal escalation: C-c → SIGTERM → SIGKILL."""
         if not self.session_exists():
             print(f"Session '{self.config.name}' doesn't exist")
             return
@@ -232,8 +308,22 @@ class TmuxManager:
 
         pane = window.active_pane
         if pane:
+            # Phase 1: SIGINT (Ctrl+C)
             pane.send_keys("C-c")
 
+            if not self._wait_for_exit(pane, timeout=task_cfg.stop_grace_period):
+                # Phase 2: SIGTERM via process group
+                pid = self._get_pane_child_pid(pane)
+                if pid:
+                    self._kill_process_tree(pid, sig.SIGTERM)
+
+                if not self._wait_for_exit(pane, timeout=3):
+                    # Phase 3: SIGKILL entire process group
+                    if pid:
+                        self._kill_process_tree(pid, sig.SIGKILL)
+                    # Final wait for cleanup
+                    self._wait_for_exit(pane, timeout=1)
+
         # Hooks: task after_stop, then global after_stop
         runHook(task_cfg.hooks.after_stop, task_name)
         runHook(self.config.hooks.after_stop, task_name)
@@ -305,7 +395,7 @@ class TmuxManager:
         print(f"Started session '{self.config.name}' with {len(auto_tasks)} tasks")
 
     def stop_all(self) -> None:
-        """Stop all tasks then kill session."""
+        """Stop all tasks with signal escalation then kill session."""
         if not self.session_exists():
             print("No session running")
             return
@@ -313,8 +403,9 @@ class TmuxManager:
         # Global before_stop
         runHook(self.config.hooks.before_stop)
 
-        # Stop each task with hooks
+        # Phase 1: send C-c to all tasks
         sess = self._get_session()
+        pane_map: dict[str, tuple[libtmux.Pane, int | None]] = {}
         for task_name, task_cfg in self.config.tasks.items():
             window = sess.windows.get(window_name=task_name, default=None)
             if window:
@@ -322,7 +413,30 @@ class TmuxManager:
                 pane = window.active_pane
                 if pane:
                     pane.send_keys("C-c")
-                runHook(task_cfg.hooks.after_stop, task_name)
+                    pid = self._get_pane_child_pid(pane)
+                    pane_map[task_name] = (pane, pid)
+
+        # Wait for graceful exit (use max grace period across tasks)
+        max_grace = max((cfg.stop_grace_period for cfg in self.config.tasks.values()), default=5)
+        time.sleep(max_grace)
+
+        # Phase 2: SIGTERM then SIGKILL any survivors
+        for _name, (pane, pid) in pane_map.items():
+            cmd = getattr(pane, "pane_current_command", "")
+            if cmd and cmd not in SHELL_NAMES and pid:
+                self._kill_process_tree(pid, sig.SIGTERM)
+
+        time.sleep(1)
+
+        for _name, (pane, pid) in pane_map.items():
+            cmd = getattr(pane, "pane_current_command", "")
+            if cmd and cmd not in SHELL_NAMES and pid:
+                self._kill_process_tree(pid, sig.SIGKILL)
+
+        # Run after_stop hooks
+        for task_name in pane_map:
+            task_cfg = self.config.tasks[task_name]
+            runHook(task_cfg.hooks.after_stop, task_name)
 
         sess.kill()
 
@@ -341,7 +455,7 @@ class TmuxManager:
         self.start_all()
 
     def restart_task(self, task_name: str) -> None:
-        """Restart a specific task (works regardless of auto_start)"""
+        """Restart a specific task with full stop escalation."""
         if not self.session_exists():
             print(f"Session '{self.config.name}' doesn't exist. Run 'taskmux start' first.")
             return
@@ -356,13 +470,25 @@ class TmuxManager:
 
         window = sess.windows.get(window_name=task_name, default=None)
         if window:
+            # Full stop with signal escalation
             runHook(task_cfg.hooks.before_stop, task_name)
             pane = window.active_pane
             if pane:
                 pane.send_keys("C-c")
-                time.sleep(0.5)
+                if not self._wait_for_exit(pane, timeout=task_cfg.stop_grace_period):
+                    pid = self._get_pane_child_pid(pane)
+                    if pid:
+                        self._kill_process_tree(pid, sig.SIGTERM)
+                    if not self._wait_for_exit(pane, timeout=3):
+                        if pid:
+                            self._kill_process_tree(pid, sig.SIGKILL)
+                        self._wait_for_exit(pane, timeout=1)
             runHook(task_cfg.hooks.after_stop, task_name)
 
+            # Port cleanup before restart
+            if task_cfg.port:
+                self._cleanup_port(task_cfg.port)
+
             runHook(task_cfg.hooks.before_start, task_name)
             pane = window.active_pane
             if pane:
@@ -371,6 +497,9 @@ class TmuxManager:
                 pane.send_keys(command, enter=True)
             runHook(task_cfg.hooks.after_start, task_name)
         else:
+            # Port cleanup before start
+            if task_cfg.port:
+                self._cleanup_port(task_cfg.port)
             runHook(task_cfg.hooks.before_start, task_name)
             self._send_command_to_window(sess, task_name, command, task_cfg.cwd)
             runHook(task_cfg.hooks.after_start, task_name)
@@ -378,13 +507,18 @@ class TmuxManager:
         print(f"Restarted task '{task_name}'")
 
     def kill_task(self, task_name: str) -> None:
-        """Kill a specific task"""
+        """Kill a specific task (process group + window)."""
         if not self.session_exists():
             print(f"Session '{self.config.name}' doesn't exist")
             return
 
         window = self._get_session().windows.get(window_name=task_name, default=None)
         if window:
+            pane = window.active_pane
+            if pane:
+                pid = self._get_pane_child_pid(pane)
+                if pid:
+                    self._kill_process_tree(pid)
             window.kill()
             print(f"Killed task '{task_name}'")
         else:
@@ -433,6 +567,54 @@ class TmuxManager:
         info["healthy"] = self.is_task_healthy(task_name)
         return info
 
+    def _tail_panes(
+        self,
+        panes: list[tuple[str, libtmux.Pane, str]],
+        lines: int = 100,
+        grep: str | None = None,
+    ) -> None:
+        """Poll capture-pane and print new lines with colored task prefixes."""
+        console = Console()
+        state: dict[str, list[str]] = {}
+
+        try:
+            while True:
+                for task_name, pane, color in panes:
+                    output = pane.cmd("capture-pane", "-p", "-S", f"-{lines}").stdout
+                    while output and not output[-1].strip():
+                        output.pop()
+
+                    prev = state.get(task_name, [])
+                    new = _find_new_lines(output, prev)
+
+                    if grep:
+                        new = [ln for ln in new if grep.lower() in ln.lower()]
+
+                    for line in new:
+                        prefix = escape(f"[{task_name}]")
+                        console.print(f"[{color}]{prefix}[/{color}] {escape(line)}")
+
+                    if output:
+                        state[task_name] = output[-50:]
+
+                time.sleep(0.5)
+        except KeyboardInterrupt:
+            console.print("\n[dim]Stopped following logs[/dim]")
+
+    def _collect_panes(self, task_names: list[str]) -> list[tuple[str, libtmux.Pane, str]]:
+        """Collect (name, pane, color) tuples for running tasks."""
+        sess = self._get_session()
+        result: list[tuple[str, libtmux.Pane, str]] = []
+        for i, name in enumerate(task_names):
+            window = sess.windows.get(window_name=name, default=None)
+            if not window:
+                continue
+            pane = window.active_pane
+            if pane:
+                color = TASK_COLORS[i % len(TASK_COLORS)]
+                result.append((name, pane, color))
+        return result
+
     def show_logs(
         self,
         task_name: str | None,
@@ -461,8 +643,9 @@ class TmuxManager:
             return
 
         if follow:
-            window.select_window()
-            sess.attach()
+            panes = self._collect_panes([task_name])
+            if panes:
+                self._tail_panes(panes, lines=lines, grep=grep)
         else:
             pane = window.active_pane
             if pane:
@@ -482,26 +665,33 @@ class TmuxManager:
     ) -> None:
         """Show logs from all running tasks."""
         sess = self._get_session()
+        console = Console()
+        task_names = list(self.config.tasks.keys())
 
         if follow:
-            sess.attach()
+            panes = self._collect_panes(task_names)
+            if panes:
+                self._tail_panes(panes, lines=lines, grep=grep)
             return
 
-        for task_name in self.config.tasks:
+        for i, task_name in enumerate(task_names):
             window = sess.windows.get(window_name=task_name, default=None)
             if not window:
                 continue
             pane = window.active_pane
             if not pane:
                 continue
+            color = TASK_COLORS[i % len(TASK_COLORS)]
             output = pane.cmd("capture-pane", "-p", "-S", f"-{lines}").stdout
             if grep:
                 matching = [line for line in output if grep.lower() in line.lower()]
                 for line in matching:
-                    print(f"[{task_name}] {line}")
+                    prefix = escape(f"[{task_name}]")
+                    console.print(f"[{color}]{prefix}[/{color}] {escape(line)}")
             else:
                 for line in output:
-                    print(f"[{task_name}] {line}")
+                    prefix = escape(f"[{task_name}]")
+                    console.print(f"[{color}]{prefix}[/{color}] {escape(line)}")
 
     def list_tasks(self) -> None:
         """List all tasks and their status"""