Allow per-session GABS servers

Author: pardeike

AGENTS.md

@@ -755,6 +755,18 @@ GABS creates configuration in the user's home directory:
 
 - **All platforms**: `~/.gabs/{gameId}/bridge.json`
 
+### Local Redeploy Preference
+
+When redeploying GABS locally for this workspace:
+
+- Keep the binary name as `gabs`
+- Overwrite the existing installed binary in place
+- Do not create backup copies like `gabs.bak-*`
+- Do not switch the MCP config to alternate binary filenames
+
+This repository expects a stable binary path for local MCP clients, especially
+Codex sessions that launch `gabs server` directly.
+
 ### Environment Variables
 
 - `GABS_LAUNCH_ID`: Unique session identifier

README.md

@@ -133,6 +133,10 @@ command = "/absolute/path/to/gabs"
 args = ["server"]
 ```
 
+Each Codex or Claude session starts its own stdio GABS process. That process is
+session-local; GABS only coordinates ownership at the game level so two live AI
+sessions do not both launch or attach to the same game by accident.
+
 **Generic MCP client:**
 
 Point your client at the `gabs` binary with the `server` subcommand:

cmd/gabs/main.go

@@ -9,7 +9,6 @@ package main
 import (
 	"bufio"
 	"context"
-	"errors"
 	"flag"
 	"fmt"
 	"os"
@@ -226,43 +225,14 @@ Once the server is running, use MCP tools to manage games:
 // === Server Command ===
 
 func runServer(ctx context.Context, log util.Logger, opts options) int {
-	// Enforce a single global GABS server process per user.
-	lockPaths, err := config.NewConfigPaths("")
-	if err != nil {
-		log.Errorw("failed to resolve server lock path", "error", err)
-		return 1
-	}
-	if err := lockPaths.EnsureBaseDir(); err != nil {
-		log.Errorw("failed to create server lock directory", "path", lockPaths.GetBaseDir(), "error", err)
-		return 1
-	}
-
-	serverLock, err := config.AcquireServerLock(lockPaths.GetServerLockPath())
-	if err != nil {
-		var runningErr *config.ServerAlreadyRunningError
-		if errors.As(err, &runningErr) {
-			log.Errorw("another GABS server is already running",
-				"pid", runningErr.Info.PID,
-				"startedAt", runningErr.Info.StartedAt,
-				"lockPath", runningErr.Path)
-		} else {
-			log.Errorw("failed to acquire server singleton lock", "lockPath", lockPaths.GetServerLockPath(), "error", err)
-		}
-		return 1
-	}
-	defer func() {
-		if err := serverLock.Release(); err != nil {
-			log.Warnw("failed to release server lock", "lockPath", lockPaths.GetServerLockPath(), "error", err)
-		}
-	}()
-
 	// Load games configuration
 	gamesConfig, err := config.LoadGamesConfigFromDir(opts.configDir)
 	if err != nil {
 		log.Errorw("failed to load games config", "error", err)
 		return 1
 	}
 
+	log.Debugw("starting per-session GABS server", "transport", opts.transport, "configDir", opts.configDir)
 	log.Infow("loaded games configuration", "gameCount", len(gamesConfig.Games))
 
 	// Create MCP server with game management tools

docs/AI_CLIENT_SETUP.md

@@ -109,6 +109,10 @@ args = ["server"]
 
 On Windows, use the full path to `gabs.exe`.
 
+Each live Codex session will start its own stdio GABS process. That is
+intentional. GABS coordinates shared ownership per game, not with a machine-wide
+`gabs server` singleton.
+
 ### Generic MCP Clients
 
 If your MCP client supports stdio servers, the essential configuration is:

docs/INTEGRATION.md

@@ -98,6 +98,10 @@ command = "/path/to/gabs"
 args = ["server"]
 ```
 
+Each live Codex session runs its own stdio GABS process. Cross-session
+coordination happens only when those sessions interact with the same configured
+game.
+
 ### Custom AI Tools
 
 Here's a Python example using an MCP client:

internal/config/paths.go

@@ -39,11 +39,6 @@ func (cp *ConfigPaths) GetMainConfigPath() string {
 	return filepath.Join(cp.baseDir, "config.json")
 }
 
-// GetServerLockPath returns the path to the global server lock file.
-func (cp *ConfigPaths) GetServerLockPath() string {
-	return filepath.Join(cp.baseDir, "server.lock")
-}
-
 // GetGameDir returns the directory path for a specific game's configuration files
 func (cp *ConfigPaths) GetGameDir(gameID string) string {
 	return filepath.Join(cp.baseDir, gameID)