taskmux 0.2.5__tar.gz → 0.2.7__tar.gz

{taskmux-0.2.5 → taskmux-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: taskmux
-Version: 0.2.5
+Version: 0.2.7
 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
@@ -125,17 +125,22 @@ health_check = "test -f .migrate-complete"
 [tasks.api]
 command = "python manage.py runserver 0.0.0.0:8000"
 cwd = "apps/api"
+port = 8000
 depends_on = ["migrate"]
 health_check = "curl -sf http://localhost:8000/health"
+stop_grace_period = 10
 
 [tasks.worker]
 command = "celery -A myapp worker -l info"
 cwd = "apps/api"
 depends_on = ["db"]
+max_restarts = 3
+restart_backoff = 3.0
 
 [tasks.web]
 command = "bun dev"
 cwd = "apps/web"
+port = 3000
 depends_on = ["api"]
 health_check = "curl -sf http://localhost:3000"
 
@@ -171,8 +176,8 @@ taskmux start storybook          # Start a manual task
 # Session
 taskmux start                    # Start all auto_start tasks
 taskmux start <task>             # Start a single task
-taskmux stop                     # Stop all tasks (graceful C-c)
-taskmux stop <task>              # Stop a single task (graceful C-c)
+taskmux stop                     # Stop all tasks (C-c → SIGTERM → SIGKILL)
+taskmux stop <task>              # Stop a single task (signal escalation)
 taskmux restart                  # Restart all tasks
 taskmux restart <task>           # Restart a single task
 taskmux status                   # Show session status
@@ -206,8 +211,8 @@ taskmux daemon --port 8765       # Run with WebSocket API + auto-restart
 
 ### stop vs kill
 
-- **`stop`** sends C-c (graceful). Window stays alive so you can see exit output.
-- **`kill`** destroys the window immediately.
+- **`stop`** sends C-c, then escalates to SIGTERM → SIGKILL if the process doesn't exit within the grace period. Window stays alive so you can see exit output.
+- **`kill`** kills the process group and destroys the window immediately.
 
 ## Configuration
 
@@ -226,7 +231,9 @@ after_stop = "echo done"
 [tasks.server]
 command = "python manage.py runserver"
 cwd = "apps/api"
+port = 8000
 health_check = "curl -sf http://localhost:8000/health"
+stop_grace_period = 10
 depends_on = ["db"]
 
 [tasks.server.hooks]
@@ -239,6 +246,7 @@ health_check = "pg_isready -h localhost"
 [tasks.worker]
 command = "celery worker -A myapp"
 depends_on = ["db"]
+max_restarts = 3
 
 [tasks.tailwind]
 command = "npx tailwindcss -w"
@@ -258,10 +266,14 @@ auto_start = false
 | `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>.port` | — | Port to clean up before starting (kills orphaned listeners) |
 | `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>.stop_grace_period` | `5` | Seconds to wait after C-c before escalating to SIGTERM |
+| `tasks.<name>.max_restarts` | `5` | Max auto-restarts in daemon mode before giving up (0 = unlimited) |
+| `tasks.<name>.restart_backoff` | `2.0` | Multiplier for restart delay (1s, 2s, 4s, 8s… capped at 60s) |
 | `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) |
 
@@ -290,6 +302,20 @@ Hooks fire in this order:
 
 If a `before_*` hook fails (non-zero exit), the action is aborted.
 
+### Process Lifecycle
+
+Taskmux ensures processes are fully stopped before restarting and that orphaned port listeners don't block new starts.
+
+**Stop escalation** (`stop`, `restart`):
+
+1. **C-c** (SIGINT) — waits `stop_grace_period` seconds (default 5)
+2. **SIGTERM** to process group — waits 3 seconds
+3. **SIGKILL** to process group — force kill
+
+**Port cleanup** (`start`, `restart`): If `port` is configured, taskmux kills any process listening on that port before starting. This handles orphaned processes from crashed sessions.
+
+**Auto-restart backoff** (daemon mode): When a task keeps crashing, restart delays increase exponentially (`restart_backoff` multiplier, capped at 60s). After `max_restarts` failures, the task is left stopped. The counter resets after 60 seconds of healthy uptime.
+
 ### Init & Agent Context
 
 `taskmux init` bootstraps your project:
@@ -325,13 +351,15 @@ Use `--defaults` to skip prompts (CI/automation).
 
 ## Daemon Mode
 
-Run as a background daemon with WebSocket API and auto-restart:
+Run as a background daemon with WebSocket API and auto-restart with exponential backoff:
 
 ```bash
 taskmux daemon              # Default port 8765
 taskmux daemon --port 9000  # Custom port
 ```
 
+The daemon monitors task health every 30 seconds. Unhealthy tasks are restarted with exponential backoff (controlled by `restart_backoff` and `max_restarts`). Tasks that stay healthy for 60+ seconds have their restart counter reset.
+
 WebSocket API:
 
 ```javascript

{taskmux-0.2.5 → taskmux-0.2.7}/README.md

@@ -90,17 +90,22 @@ health_check = "test -f .migrate-complete"
 [tasks.api]
 command = "python manage.py runserver 0.0.0.0:8000"
 cwd = "apps/api"
+port = 8000
 depends_on = ["migrate"]
 health_check = "curl -sf http://localhost:8000/health"
+stop_grace_period = 10
 
 [tasks.worker]
 command = "celery -A myapp worker -l info"
 cwd = "apps/api"
 depends_on = ["db"]
+max_restarts = 3
+restart_backoff = 3.0
 
 [tasks.web]
 command = "bun dev"
 cwd = "apps/web"
+port = 3000
 depends_on = ["api"]
 health_check = "curl -sf http://localhost:3000"
 
@@ -136,8 +141,8 @@ taskmux start storybook          # Start a manual task
 # Session
 taskmux start                    # Start all auto_start tasks
 taskmux start <task>             # Start a single task
-taskmux stop                     # Stop all tasks (graceful C-c)
-taskmux stop <task>              # Stop a single task (graceful C-c)
+taskmux stop                     # Stop all tasks (C-c → SIGTERM → SIGKILL)
+taskmux stop <task>              # Stop a single task (signal escalation)
 taskmux restart                  # Restart all tasks
 taskmux restart <task>           # Restart a single task
 taskmux status                   # Show session status
@@ -171,8 +176,8 @@ taskmux daemon --port 8765       # Run with WebSocket API + auto-restart
 
 ### stop vs kill
 
-- **`stop`** sends C-c (graceful). Window stays alive so you can see exit output.
-- **`kill`** destroys the window immediately.
+- **`stop`** sends C-c, then escalates to SIGTERM → SIGKILL if the process doesn't exit within the grace period. Window stays alive so you can see exit output.
+- **`kill`** kills the process group and destroys the window immediately.
 
 ## Configuration
 
@@ -191,7 +196,9 @@ after_stop = "echo done"
 [tasks.server]
 command = "python manage.py runserver"
 cwd = "apps/api"
+port = 8000
 health_check = "curl -sf http://localhost:8000/health"
+stop_grace_period = 10
 depends_on = ["db"]
 
 [tasks.server.hooks]
@@ -204,6 +211,7 @@ health_check = "pg_isready -h localhost"
 [tasks.worker]
 command = "celery worker -A myapp"
 depends_on = ["db"]
+max_restarts = 3
 
 [tasks.tailwind]
 command = "npx tailwindcss -w"
@@ -223,10 +231,14 @@ auto_start = false
 | `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>.port` | — | Port to clean up before starting (kills orphaned listeners) |
 | `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>.stop_grace_period` | `5` | Seconds to wait after C-c before escalating to SIGTERM |
+| `tasks.<name>.max_restarts` | `5` | Max auto-restarts in daemon mode before giving up (0 = unlimited) |
+| `tasks.<name>.restart_backoff` | `2.0` | Multiplier for restart delay (1s, 2s, 4s, 8s… capped at 60s) |
 | `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) |
 
@@ -255,6 +267,20 @@ Hooks fire in this order:
 
 If a `before_*` hook fails (non-zero exit), the action is aborted.
 
+### Process Lifecycle
+
+Taskmux ensures processes are fully stopped before restarting and that orphaned port listeners don't block new starts.
+
+**Stop escalation** (`stop`, `restart`):
+
+1. **C-c** (SIGINT) — waits `stop_grace_period` seconds (default 5)
+2. **SIGTERM** to process group — waits 3 seconds
+3. **SIGKILL** to process group — force kill
+
+**Port cleanup** (`start`, `restart`): If `port` is configured, taskmux kills any process listening on that port before starting. This handles orphaned processes from crashed sessions.
+
+**Auto-restart backoff** (daemon mode): When a task keeps crashing, restart delays increase exponentially (`restart_backoff` multiplier, capped at 60s). After `max_restarts` failures, the task is left stopped. The counter resets after 60 seconds of healthy uptime.
+
 ### Init & Agent Context
 
 `taskmux init` bootstraps your project:
@@ -290,13 +316,15 @@ Use `--defaults` to skip prompts (CI/automation).
 
 ## Daemon Mode
 
-Run as a background daemon with WebSocket API and auto-restart:
+Run as a background daemon with WebSocket API and auto-restart with exponential backoff:
 
 ```bash
 taskmux daemon              # Default port 8765
 taskmux daemon --port 9000  # Custom port
 ```
 
+The daemon monitors task health every 30 seconds. Unhealthy tasks are restarted with exponential backoff (controlled by `restart_backoff` and `max_restarts`). Tasks that stay healthy for 60+ seconds have their restart counter reset.
+
 WebSocket API:
 
 ```javascript

{taskmux-0.2.5 → taskmux-0.2.7}/pyproject.toml

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

{taskmux-0.2.5 → taskmux-0.2.7}/taskmux/agent.py

@@ -40,9 +40,12 @@ def buildContextBlock(config: TaskmuxConfig) -> str:
     ]
 
     if config.tasks:
+        lines.append("| Task | Port | Auto-start | Command |")
+        lines.append("|------|------|------------|---------|")
         for name, task in config.tasks.items():
-            auto = "" if task.auto_start else " (manual)"
-            lines.append(f"- **{name}**: `{task.command}`{auto}")
+            port = str(task.port) if task.port else "—"
+            auto = "yes" if task.auto_start else "no"
+            lines.append(f"| {name} | {port} | {auto} | `{task.command}` |")
     else:
         lines.append('_No tasks configured yet. Use `taskmux add <name> "<command>"` to add._')
 

{taskmux-0.2.5 → taskmux-0.2.7}/taskmux/cli.py

@@ -53,45 +53,41 @@ def init(
     initProject(defaults=defaults)
 
 
-@app.command()
-def list():
-    """List all tasks and their status."""
-    cli = TaskmuxCLI()
-    cli.tmux.list_tasks()
-
-
 @app.command()
 def start(
-    task: str | None = typer.Argument(None, help="Task name (omit for all)"),
+    tasks: list[str] = typer.Argument(None, help="Task names (omit for all)"),  # noqa: B008
 ):
-    """Start all tasks or a specific task."""
+    """Start tasks (all if none specified)."""
     cli = TaskmuxCLI()
-    if task:
-        cli.tmux.start_task(task)
+    if tasks:
+        for task in tasks:
+            cli.tmux.start_task(task)
     else:
         cli.tmux.start_all()
 
 
 @app.command()
 def stop(
-    task: str | None = typer.Argument(None, help="Task name (omit for all)"),
+    tasks: list[str] = typer.Argument(None, help="Task names (omit for all)"),  # noqa: B008
 ):
-    """Stop all tasks or a specific task (graceful C-c)."""
+    """Stop tasks (all if none specified)."""
     cli = TaskmuxCLI()
-    if task:
-        cli.tmux.stop_task(task)
+    if tasks:
+        for task in tasks:
+            cli.tmux.stop_task(task)
     else:
         cli.tmux.stop_all()
 
 
 @app.command()
 def restart(
-    task: str | None = typer.Argument(None, help="Task name (omit for all)"),
+    tasks: list[str] = typer.Argument(None, help="Task names (omit for all)"),  # noqa: B008
 ):
-    """Restart all tasks or a specific task."""
+    """Restart tasks (all if none specified)."""
     cli = TaskmuxCLI()
-    if task:
-        cli.tmux.restart_task(task)
+    if tasks:
+        for task in tasks:
+            cli.tmux.restart_task(task)
     else:
         cli.tmux.restart_all()
 
@@ -160,11 +156,15 @@ def remove(
         console.print(f"Task '{task}' not found in config", style="red")
 
 
-@app.command()
-def status():
-    """Show session status."""
+def _status():
+    """Show session and task status."""
     cli = TaskmuxCLI()
-    cli.tmux.show_status()
+    cli.tmux.list_tasks()
+
+
+app.command(name="status")(_status)
+app.command(name="list", hidden=True)(_status)
+app.command(name="ls", hidden=True)(_status)
 
 
 @app.command()

{taskmux-0.2.5 → taskmux-0.2.7}/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.5 → taskmux-0.2.7}/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.5 → taskmux-0.2.7}/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.5 → taskmux-0.2.7}/taskmux/tmux_manager.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+import contextlib
+import os
+import signal as sig
 import subprocess
 import time
 from collections import deque
@@ -14,6 +17,8 @@ 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"]
 
 
@@ -74,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)
@@ -188,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:
@@ -226,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
@@ -249,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)
@@ -322,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
@@ -330,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:
@@ -339,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()
 
@@ -358,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
@@ -373,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:
@@ -388,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)
@@ -395,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:
@@ -577,8 +694,12 @@ class TmuxManager:
                     console.print(f"[{color}]{prefix}[/{color}] {escape(line)}")
 
     def list_tasks(self) -> None:
-        """List all tasks and their status"""
-        print(f"Session: {self.config.name}")
+        """List all tasks and their status."""
+        exists = self.session_exists()
+        print(f"Session '{self.config.name}': {'Running' if exists else 'Stopped'}")
+        if exists:
+            windows = self.list_windows()
+            print(f"Active tasks: {len(windows)}")
         print("-" * 70)
 
         if not self.config.tasks:
@@ -592,22 +713,14 @@ class TmuxManager:
                 "Healthy" if status["healthy"] else "Running" if status["running"] else "Stopped"
             )
             auto = "" if task_cfg.auto_start else " [manual]"
+            port = f" :{task_cfg.port}" if task_cfg.port else ""
             extras = ""
             if task_cfg.cwd:
                 extras += f" cwd={task_cfg.cwd}"
             if task_cfg.depends_on:
                 extras += f" deps=[{','.join(task_cfg.depends_on)}]"
-            print(f"{health_icon} {status_text:8} {task_name:15} {task_cfg.command}{auto}{extras}")
-
-    def show_status(self) -> None:
-        """Show overall session status"""
-        exists = self.session_exists()
-        print(f"Session '{self.config.name}': {'Running' if exists else 'Stopped'} (libtmux)")
-
-        if exists:
-            windows = self.list_windows()
-            print(f"Active tasks: {len(windows)}")
-            self.list_tasks()
+            line = f"{health_icon} {status_text:8} {task_name:15}{port:7} {task_cfg.command}"
+            print(f"{line}{auto}{extras}")
 
     def check_task_health(self, task_name: str) -> bool:
         """Check if a task is healthy"""