feat(launcher): per-MPR daemon pool with 5-minute idle timeout

Replace the single shared daemon with a pool of per-MPR daemon processes:

- Commands with -p <mpr>: routed to a dedicated per-MPR daemon
  (socket: ~/.mxcli/daemon/mpr-{mprHash}-{binHash}.sock)
- Commands without -p: shared daemon at ~/.mxcli/daemon/mxcli.sock
- All daemons exit after 5 minutes idle (--idle-timeout flag)

Resource lifecycle:
- Socket path embeds both MPR path hash and binary mtime hash; recompiling
  the binary changes the hash, causing stale daemons to self-invalidate.
- cleanupStaleMPRSockets() removes old-binary sockets for the same MPR
  and dead orphan sockets from other MPRs before each daemon spawn.
- runDaemonServer defer removes the socket file on exit, preventing orphans.
- go cmd.Wait() in all spawn paths prevents zombie processes.
- idleWatcher closes the net.Listener (triggers Accept error → clean exit).

Concurrent safety: two launchers racing to start the same MPR daemon both
call net.Listen; one wins (socket bound), the other fails and exits; both
poll isDaemonRunning and eventually succeed — no explicit lock needed.

Tests added:
- TestExtractMPRFromArgs_{Short,Long,Equal,None,Dangling}
- TestMPRDaemonSocketPath_{Deterministic,DifferentMPR,HasMprPrefix,InDaemonDir}
- TestMPRSocketPrefix_{SameForSameMPR,DifferentForDifferentMPR}
- TestCleanupStaleMPRSockets_{RemovesSameMPROldSocket,RemovesDeadOrphan,KeepsNonSocketFiles}
- TestDaemonServer_IdleTimeout — daemon exits and socket file removed
- TestDaemonServer_IdleResetOnRequest — idle timer resets on connection

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Author: engalar

cmd/mxcli-launcher/daemon.go

@@ -51,7 +51,9 @@ func readVersionFile(path string) string {
 	return strings.TrimSpace(string(b))
 }
 
-func (e *Env) ensureDaemon() error {
+// ensureDaemonBinary ensures the daemon binary is present, downloading it if needed.
+// It also creates the daemon directory. Call this before any daemon operations.
+func (e *Env) ensureDaemonBinary() error {
 	if err := os.MkdirAll(e.daemonDir(), 0755); err != nil {
 		return fmt.Errorf("create daemon dir: %w", err)
 	}
@@ -61,6 +63,14 @@ func (e *Env) ensureDaemon() error {
 			return fmt.Errorf("download daemon: %w", err)
 		}
 	}
+	return nil
+}
+
+// ensureDaemon ensures the shared (non-MPR-specific) daemon is running.
+func (e *Env) ensureDaemon() error {
+	if err := e.ensureDaemonBinary(); err != nil {
+		return err
+	}
 	if !isDaemonRunning(e.daemonSocketPath()) {
 		if err := e.startDaemon(); err != nil {
 			return fmt.Errorf("start daemon: %w", err)
@@ -70,7 +80,10 @@ func (e *Env) ensureDaemon() error {
 }
 
 func (e *Env) startDaemon() error {
-	cmd := exec.Command(e.daemonBinaryPath(), "--serve", e.daemonSocketPath())
+	cmd := exec.Command(e.daemonBinaryPath(),
+		"--serve", e.daemonSocketPath(),
+		"--idle-timeout", sharedDaemonIdleTimeout.String(),
+	)
 	cmd.Stdout = nil
 	cmd.Stderr = nil
 	cmd.Stdin = nil
@@ -79,6 +92,7 @@ func (e *Env) startDaemon() error {
 		return fmt.Errorf("exec daemon: %w", err)
 	}
 	os.WriteFile(e.daemonPIDPath(), []byte(fmt.Sprintf("%d", cmd.Process.Pid)), 0644)
+	go func() { _ = cmd.Wait() }() // prevent zombie
 	deadline := time.Now().Add(daemonTimeout)
 	for time.Now().Before(deadline) {
 		if isDaemonRunning(e.daemonSocketPath()) {

cmd/mxcli-launcher/main.go

@@ -3,11 +3,17 @@
 // mxcli is the launcher — a thin cross-platform client that forwards CLI
 // requests to mxcli-daemon via unix socket. It handles daemon lifecycle,
 // background version checks, and upgrade/rollback.
+//
+// Routing:
+//   - Commands with -p <mpr>: forwarded to a per-MPR daemon (isolated process,
+//     5-minute idle timeout, socket path derived from mpr path + binary mtime hash).
+//   - Commands without -p: forwarded to the shared daemon at ~/.mxcli/daemon/mxcli.sock.
 package main
 
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 )
 
 var (
@@ -31,14 +37,40 @@ func main() {
 		}
 	}
 
-	if err := e.ensureDaemon(); err != nil {
+	// Ensure daemon binary is present (download if needed).
+	if err := e.ensureDaemonBinary(); err != nil {
 		fmt.Fprintf(os.Stderr, "mxcli: %v\n", err)
 		os.Exit(1)
 	}
 
+	// Route to per-MPR daemon when -p is present; otherwise use shared daemon.
+	var sockPath string
+	if rawMPR := extractMPRFromArgs(args); rawMPR != "" {
+		absMPR, err := filepath.Abs(rawMPR)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "mxcli: resolve -p path: %v\n", err)
+			os.Exit(1)
+		}
+		absMPR = filepath.ToSlash(absMPR)
+		sp, err := e.ensureMPRDaemon(absMPR)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "mxcli: %v\n", err)
+			os.Exit(1)
+		}
+		sockPath = sp
+	} else {
+		if !isDaemonRunning(e.daemonSocketPath()) {
+			if err := e.startDaemon(); err != nil {
+				fmt.Fprintf(os.Stderr, "mxcli: %v\n", err)
+				os.Exit(1)
+			}
+		}
+		sockPath = e.daemonSocketPath()
+	}
+
 	go e.backgroundVersionCheck()
 
-	exitCode := forwardRequest(e.daemonSocketPath(), args, os.Stdout, os.Stderr)
+	exitCode := forwardRequest(sockPath, args, os.Stdout, os.Stderr)
 
 	e.printUpdateNotice()
 

cmd/mxcli-launcher/mpr_daemon.go

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+const (
+	mprDaemonIdleTimeout    = 5 * time.Minute
+	sharedDaemonIdleTimeout = 5 * time.Minute
+	mprDaemonStartTimeout   = 30 * time.Second
+)
+
+// extractMPRFromArgs scans argv for -p <path> or --project <path> or --project=<path>.
+func extractMPRFromArgs(args []string) string {
+	for i, a := range args {
+		if (a == "-p" || a == "--project") && i+1 < len(args) {
+			return args[i+1]
+		}
+		if strings.HasPrefix(a, "--project=") {
+			return a[len("--project="):]
+		}
+	}
+	return ""
+}
+
+// ensureMPRDaemon ensures a per-MPR daemon is running for mprAbsPath and returns its socket path.
+//
+// Lifecycle:
+//   - Socket path is derived from (mprPath hash, binary mtime hash): changes on recompile → stale daemons self-invalidate.
+//   - Stale sockets for the same MPR (old binary) are deleted; their idle watchers trigger exit.
+//   - Daemon is spawned with --idle-timeout 5m; exits and removes socket after 5 min idle.
+//   - go cmd.Wait() prevents zombie processes.
+func (e *Env) ensureMPRDaemon(mprAbsPath string) (string, error) {
+	sockPath := e.mprDaemonSocketPath(mprAbsPath)
+
+	if isDaemonRunning(sockPath) {
+		return sockPath, nil
+	}
+
+	// Clean stale sockets before spawning to avoid bind conflicts.
+	e.cleanupStaleMPRSockets(mprAbsPath, sockPath)
+
+	cmd := exec.Command(
+		e.daemonBinaryPath(),
+		"--serve", sockPath,
+		"--idle-timeout", mprDaemonIdleTimeout.String(),
+	)
+	cmd.Stdout = nil
+	cmd.Stderr = nil
+	cmd.Stdin = nil
+	hideDaemonWindow(cmd)
+	if err := cmd.Start(); err != nil {
+		return "", fmt.Errorf("start mpr daemon: %w", err)
+	}
+	go func() { _ = cmd.Wait() }() // prevent zombie
+
+	deadline := time.Now().Add(mprDaemonStartTimeout)
+	for time.Now().Before(deadline) {
+		if isDaemonRunning(sockPath) {
+			return sockPath, nil
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	_ = cmd.Process.Kill()
+	return "", fmt.Errorf("mpr daemon did not start within %v", mprDaemonStartTimeout)
+}
+
+// cleanupStaleMPRSockets removes:
+//  1. Same-MPR old-binary sockets (mpr hash prefix matches, but binary hash differs) — deleted
+//     unconditionally; removing the socket stops the old daemon from accepting new connections,
+//     and its idle watcher triggers exit shortly after.
+//  2. Dead sockets from any other MPR (orphans where no process is listening).
+//
+// currentSock is always preserved.
+func (e *Env) cleanupStaleMPRSockets(mprAbsPath, currentSock string) {
+	entries, err := os.ReadDir(e.daemonDir())
+	if err != nil {
+		return
+	}
+	prefix := e.mprSocketPrefix(mprAbsPath)
+	currentBase := filepath.Base(currentSock)
+
+	for _, entry := range entries {
+		name := entry.Name()
+		if !strings.HasSuffix(name, ".sock") || !strings.HasPrefix(name, "mpr-") {
+			continue
+		}
+		if name == currentBase {
+			continue
+		}
+		sockPath := filepath.Join(e.daemonDir(), name)
+		if strings.HasPrefix(name, prefix) {
+			// Same MPR, old binary: delete to stop it from accepting new connections.
+			_ = os.Remove(sockPath)
+		} else if !isDaemonRunning(sockPath) {
+			// Another MPR's dead socket: clean up the orphan file.
+			_ = os.Remove(sockPath)
+		}
+	}
+}

cmd/mxcli-launcher/mpr_daemon_test.go

@@ -0,0 +1,180 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// --- extractMPRFromArgs ---
+
+func TestExtractMPRFromArgs_ShortFlag(t *testing.T) {
+	got := extractMPRFromArgs([]string{"-p", "app.mpr", "-c", "show entities"})
+	if got != "app.mpr" {
+		t.Errorf("got %q, want app.mpr", got)
+	}
+}
+
+func TestExtractMPRFromArgs_LongFlag(t *testing.T) {
+	got := extractMPRFromArgs([]string{"--project", "app.mpr"})
+	if got != "app.mpr" {
+		t.Errorf("got %q, want app.mpr", got)
+	}
+}
+
+func TestExtractMPRFromArgs_EqualForm(t *testing.T) {
+	got := extractMPRFromArgs([]string{"--project=app.mpr", "-c", "show"})
+	if got != "app.mpr" {
+		t.Errorf("got %q, want app.mpr", got)
+	}
+}
+
+func TestExtractMPRFromArgs_None(t *testing.T) {
+	got := extractMPRFromArgs([]string{"--help"})
+	if got != "" {
+		t.Errorf("got %q, want empty", got)
+	}
+}
+
+func TestExtractMPRFromArgs_DanglingFlag(t *testing.T) {
+	// -p at end of slice (no value follows)
+	got := extractMPRFromArgs([]string{"-p"})
+	if got != "" {
+		t.Errorf("got %q, want empty", got)
+	}
+}
+
+// --- mprDaemonSocketPath ---
+
+func TestMPRDaemonSocketPath_Deterministic(t *testing.T) {
+	e := newTestEnv(t)
+	a := e.mprDaemonSocketPath("/home/user/project.mpr")
+	b := e.mprDaemonSocketPath("/home/user/project.mpr")
+	if a != b {
+		t.Errorf("same input produced different paths: %q vs %q", a, b)
+	}
+}
+
+func TestMPRDaemonSocketPath_DifferentMPR(t *testing.T) {
+	e := newTestEnv(t)
+	a := e.mprDaemonSocketPath("/home/user/project-a.mpr")
+	b := e.mprDaemonSocketPath("/home/user/project-b.mpr")
+	if a == b {
+		t.Errorf("different MPR paths produced same socket: %q", a)
+	}
+}
+
+func TestMPRDaemonSocketPath_HasMprPrefix(t *testing.T) {
+	e := newTestEnv(t)
+	p := e.mprDaemonSocketPath("/some/project.mpr")
+	base := filepath.Base(p)
+	if !strings.HasPrefix(base, "mpr-") {
+		t.Errorf("socket name %q does not start with mpr-", base)
+	}
+	if !strings.HasSuffix(base, ".sock") {
+		t.Errorf("socket name %q does not end with .sock", base)
+	}
+}
+
+func TestMPRDaemonSocketPath_InDaemonDir(t *testing.T) {
+	e := newTestEnv(t)
+	p := e.mprDaemonSocketPath("/some/project.mpr")
+	if !strings.HasPrefix(p, e.daemonDir()) {
+		t.Errorf("socket path %q is not under daemonDir %q", p, e.daemonDir())
+	}
+}
+
+// --- mprSocketPrefix ---
+
+func TestMPRSocketPrefix_SameForSameMPR(t *testing.T) {
+	e := newTestEnv(t)
+	a := e.mprSocketPrefix("/home/user/project.mpr")
+	b := e.mprSocketPrefix("/home/user/project.mpr")
+	if a != b {
+		t.Errorf("same MPR produced different prefix: %q vs %q", a, b)
+	}
+}
+
+func TestMPRSocketPrefix_DifferentForDifferentMPR(t *testing.T) {
+	e := newTestEnv(t)
+	a := e.mprSocketPrefix("/home/user/a.mpr")
+	b := e.mprSocketPrefix("/home/user/b.mpr")
+	if a == b {
+		t.Errorf("different MPR produced same prefix: %q", a)
+	}
+}
+
+// --- cleanupStaleMPRSockets ---
+
+func TestCleanupStaleMPRSockets_RemovesSameMPROldSocket(t *testing.T) {
+	e := newTestEnv(t)
+	if err := os.MkdirAll(e.daemonDir(), 0755); err != nil {
+		t.Fatal(err)
+	}
+	mprPath := "/home/user/project.mpr"
+
+	// Create a fake stale socket with the same MPR prefix but different binary hash suffix.
+	prefix := e.mprSocketPrefix(mprPath)
+	stale := filepath.Join(e.daemonDir(), prefix+"aabbcc.sock")
+	if err := os.WriteFile(stale, []byte{}, 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// current socket should NOT be deleted.
+	current := e.mprDaemonSocketPath(mprPath)
+	if err := os.WriteFile(current, []byte{}, 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	e.cleanupStaleMPRSockets(mprPath, current)
+
+	if _, err := os.Stat(stale); !os.IsNotExist(err) {
+		t.Error("stale same-MPR socket should have been removed")
+	}
+	if _, err := os.Stat(current); os.IsNotExist(err) {
+		t.Error("current socket should NOT have been removed")
+	}
+}
+
+func TestCleanupStaleMPRSockets_RemovesDeadOrphanSocket(t *testing.T) {
+	e := newTestEnv(t)
+	if err := os.MkdirAll(e.daemonDir(), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	// Orphan socket from a different MPR (different prefix) that is NOT alive.
+	orphan := filepath.Join(e.daemonDir(), "mpr-deadbeef-0a0b.sock")
+	if err := os.WriteFile(orphan, []byte{}, 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	current := e.mprDaemonSocketPath("/home/user/project.mpr")
+	e.cleanupStaleMPRSockets("/home/user/project.mpr", current)
+
+	if _, err := os.Stat(orphan); !os.IsNotExist(err) {
+		t.Error("dead orphan socket should have been removed")
+	}
+}
+
+func TestCleanupStaleMPRSockets_KeepsNonSocketFiles(t *testing.T) {
+	e := newTestEnv(t)
+	if err := os.MkdirAll(e.daemonDir(), 0755); err != nil {
+		t.Fatal(err)
+	}
+
+	// Non-.sock file in daemon dir should be untouched.
+	other := filepath.Join(e.daemonDir(), "version")
+	if err := os.WriteFile(other, []byte("v1"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	current := e.mprDaemonSocketPath("/some/project.mpr")
+	e.cleanupStaleMPRSockets("/some/project.mpr", current)
+
+	if _, err := os.Stat(other); os.IsNotExist(err) {
+		t.Error("non-socket file should not have been removed")
+	}
+}