diff --git a/DevProxy/Commands/DevProxyConfigOptions.cs b/DevProxy/Commands/DevProxyConfigOptions.cs
index 89015fa6..0abaf3ea 100644
--- a/DevProxy/Commands/DevProxyConfigOptions.cs
+++ b/DevProxy/Commands/DevProxyConfigOptions.cs
@@ -19,6 +19,7 @@ public string? ConfigFile
     }
 
     public int? ApiPort => _parseResult?.GetValueOrDefault<int?>(DevProxyCommand.ApiPortOptionName);
+    public bool? AsSystemProxy => _parseResult?.GetValueOrDefault<bool?>(DevProxyCommand.AsSystemProxyOptionName);
     public int? Port => _parseResult?.GetValueOrDefault<int?>(DevProxyCommand.PortOptionName);
     public bool Discover => _parseResult?.GetValueOrDefault<bool?>(DevProxyCommand.DiscoverOptionName) ?? false;
     public string? IPAddress => _parseResult?.GetValueOrDefault<string?>(DevProxyCommand.IpAddressOptionName);
@@ -138,6 +139,7 @@ public DevProxyConfigOptions()
         };
 
         var apiPortOption = new Option<int?>(DevProxyCommand.ApiPortOptionName);
+        var asSystemProxyOption = new Option<bool?>(DevProxyCommand.AsSystemProxyOptionName);
         var portOption = new Option<int?>(DevProxyCommand.PortOptionName, "-p");
 
         var discoverOption = new Option<bool>(DevProxyCommand.DiscoverOptionName, "--discover")
@@ -153,6 +155,7 @@ public DevProxyConfigOptions()
         var options = new List<Option>
         {
             apiPortOption,
+            asSystemProxyOption,
             ipAddressOption,
             configFileOption,
             portOption,
diff --git a/DevProxy/Commands/LogsCommand.cs b/DevProxy/Commands/LogsCommand.cs
index 56ada018..652ce783 100644
--- a/DevProxy/Commands/LogsCommand.cs
+++ b/DevProxy/Commands/LogsCommand.cs
@@ -28,11 +28,17 @@ internal sealed class LogsCommand : Command
         HelpName = "time"
     };
 
+    private readonly Option<int?> _pidOption = new("--pid")
+    {
+        Description = "Show logs from a specific Dev Proxy instance by PID"
+    };
+
     public LogsCommand() : base("logs", "Show logs from running Dev Proxy instance")
     {
         Add(_followOption);
         Add(_linesOption);
         Add(_sinceOption);
+        Add(_pidOption);
 
         SetAction(RunAsync);
     }
@@ -42,13 +48,26 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
         var follow = parseResult.GetValue(_followOption);
         var lines = parseResult.GetValue(_linesOption);
         var since = parseResult.GetValue(_sinceOption);
+        var pid = parseResult.GetValue(_pidOption);
 
-        var state = await StateManager.LoadStateAsync(cancellationToken);
-
-        if (state == null)
+        ProxyInstanceState? state;
+        if (pid is not null)
         {
-            Console.WriteLine("Dev Proxy is not running.");
-            return 1;
+            state = await StateManager.LoadStateByPidAsync(pid.Value, cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine($"No running Dev Proxy instance with PID {pid.Value}.");
+                return 1;
+            }
+        }
+        else
+        {
+            state = await StateManager.LoadStateAsync(cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine("Dev Proxy is not running.");
+                return 1;
+            }
         }
 
         var logFile = state.LogFile;
diff --git a/DevProxy/Commands/StatusCommand.cs b/DevProxy/Commands/StatusCommand.cs
index 9bea26c1..1d76570d 100644
--- a/DevProxy/Commands/StatusCommand.cs
+++ b/DevProxy/Commands/StatusCommand.cs
@@ -10,21 +10,56 @@ namespace DevProxy.Commands;
 
 internal sealed class StatusCommand : Command
 {
-    public StatusCommand() : base("status", "Show status of running Dev Proxy instance")
+    private readonly Option<int?> _pidOption = new("--pid")
     {
+        Description = "Show status of a specific Dev Proxy instance by PID"
+    };
+
+    public StatusCommand() : base("status", "Show status of running Dev Proxy instances")
+    {
+        Add(_pidOption);
         SetAction(RunAsync);
     }
 
     private async Task<int> RunAsync(ParseResult parseResult, CancellationToken cancellationToken)
     {
-        var state = await StateManager.LoadStateAsync(cancellationToken);
+        var pid = parseResult.GetValue(_pidOption);
 
-        if (state == null)
+        if (pid is not null)
+        {
+            var state = await StateManager.LoadStateByPidAsync(pid.Value, cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine($"No running Dev Proxy instance with PID {pid.Value}.");
+                return 1;
+            }
+
+            await PrintInstanceStatusAsync(state, cancellationToken);
+            return 0;
+        }
+
+        var states = await StateManager.LoadAllStatesAsync(cancellationToken);
+        if (states.Count == 0)
         {
             Console.WriteLine("Dev Proxy is not running.");
             return 1;
         }
 
+        for (var i = 0; i < states.Count; i++)
+        {
+            if (i > 0)
+            {
+                Console.WriteLine();
+            }
+
+            await PrintInstanceStatusAsync(states[i], cancellationToken);
+        }
+
+        return 0;
+    }
+
+    private static async Task PrintInstanceStatusAsync(ProxyInstanceState state, CancellationToken cancellationToken)
+    {
         // Try to get live status from the API
         try
         {
@@ -37,18 +72,19 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
                 Console.WriteLine("Dev Proxy is running.");
                 Console.WriteLine();
-                Console.WriteLine($"  PID:        {state.Pid}");
-                Console.WriteLine($"  API URL:    {state.ApiUrl}");
-                Console.WriteLine($"  Port:       {state.Port}");
-                Console.WriteLine($"  Recording:  {(proxyInfo?.Recording == true ? "Yes" : "No")}");
+                Console.WriteLine($"  PID:              {state.Pid}");
+                Console.WriteLine($"  API URL:          {state.ApiUrl}");
+                Console.WriteLine($"  Port:             {state.Port}");
+                Console.WriteLine($"  System proxy:     {(state.AsSystemProxy ? "Yes" : "No")}");
+                Console.WriteLine($"  Recording:        {(proxyInfo?.Recording == true ? "Yes" : "No")}");
                 if (!string.IsNullOrEmpty(state.ConfigFile))
                 {
-                    Console.WriteLine($"  Config:     {state.ConfigFile}");
+                    Console.WriteLine($"  Config:           {state.ConfigFile}");
                 }
-                Console.WriteLine($"  Log file:   {state.LogFile}");
-                Console.WriteLine($"  Started:    {state.StartedAt.LocalDateTime:g}");
+                Console.WriteLine($"  Log file:         {state.LogFile}");
+                Console.WriteLine($"  Started:          {state.StartedAt.LocalDateTime:g}");
 
-                return 0;
+                return;
             }
         }
         catch (HttpRequestException)
@@ -63,12 +99,11 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
         // Fall back to state file info
         Console.WriteLine("Dev Proxy appears to be running (API not responding).");
         Console.WriteLine();
-        Console.WriteLine($"  PID:        {state.Pid}");
-        Console.WriteLine($"  API URL:    {state.ApiUrl}");
-        Console.WriteLine($"  Log file:   {state.LogFile}");
-        Console.WriteLine($"  Started:    {state.StartedAt.LocalDateTime:g}");
-
-        return 0;
+        Console.WriteLine($"  PID:              {state.Pid}");
+        Console.WriteLine($"  API URL:          {state.ApiUrl}");
+        Console.WriteLine($"  System proxy:     {(state.AsSystemProxy ? "Yes" : "No")}");
+        Console.WriteLine($"  Log file:         {state.LogFile}");
+        Console.WriteLine($"  Started:          {state.StartedAt.LocalDateTime:g}");
     }
 
     private sealed class ProxyStatusInfo
diff --git a/DevProxy/Commands/StopCommand.cs b/DevProxy/Commands/StopCommand.cs
index 48d92117..5767f34d 100644
--- a/DevProxy/Commands/StopCommand.cs
+++ b/DevProxy/Commands/StopCommand.cs
@@ -15,23 +15,57 @@ internal sealed class StopCommand : Command
         Description = "Force stop the proxy by killing the process"
     };
 
-    public StopCommand() : base("stop", "Stop running Dev Proxy instance")
+    private readonly Option<int?> _pidOption = new("--pid")
+    {
+        Description = "Stop a specific Dev Proxy instance by PID"
+    };
+
+    public StopCommand() : base("stop", "Stop running Dev Proxy instances")
     {
         Add(_forceOption);
+        Add(_pidOption);
         SetAction(RunAsync);
     }
 
     private async Task<int> RunAsync(ParseResult parseResult, CancellationToken cancellationToken)
     {
         var force = parseResult.GetValue(_forceOption);
-        var state = await StateManager.LoadStateAsync(cancellationToken);
+        var pid = parseResult.GetValue(_pidOption);
+
+        if (pid is not null)
+        {
+            var state = await StateManager.LoadStateByPidAsync(pid.Value, cancellationToken);
+            if (state is null)
+            {
+                Console.WriteLine($"No running Dev Proxy instance with PID {pid.Value}.");
+                return 1;
+            }
+
+            return await StopInstanceAsync(state, force, cancellationToken);
+        }
 
-        if (state == null)
+        var states = await StateManager.LoadAllStatesAsync(cancellationToken);
+        if (states.Count == 0)
         {
             Console.WriteLine("Dev Proxy is not running.");
             return 1;
         }
 
+        var exitCode = 0;
+        foreach (var state in states)
+        {
+            var result = await StopInstanceAsync(state, force, cancellationToken);
+            if (result != 0)
+            {
+                exitCode = result;
+            }
+        }
+
+        return exitCode;
+    }
+
+    private static async Task<int> StopInstanceAsync(ProxyInstanceState state, bool force, CancellationToken cancellationToken)
+    {
         if (force)
         {
             return await ForceStopAsync(state, cancellationToken);
@@ -45,7 +79,7 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
             if (response.IsSuccessStatusCode || response.StatusCode == System.Net.HttpStatusCode.Accepted)
             {
-                Console.WriteLine("Stopping Dev Proxy...");
+                Console.WriteLine($"Stopping Dev Proxy (PID: {state.Pid})...");
 
                 // Wait for process to exit
                 var stopwatch = Stopwatch.StartNew();
@@ -82,30 +116,30 @@ private async Task<int> RunAsync(ParseResult parseResult, CancellationToken canc
 
                 if (!exited)
                 {
-                    Console.WriteLine("Dev Proxy did not stop in time.");
-                    Console.WriteLine("Use --force to forcefully terminate the process.");
+                    Console.WriteLine($"Dev Proxy (PID: {state.Pid}) did not stop in time.");
+                    Console.WriteLine($"Use --force --pid {state.Pid} to forcefully terminate the process.");
                     return 1;
                 }
 
-                await StateManager.DeleteStateAsync(cancellationToken);
-                Console.WriteLine("Dev Proxy stopped.");
+                await StateManager.DeleteStateAsync(state.Pid, cancellationToken);
+                Console.WriteLine($"Dev Proxy (PID: {state.Pid}) stopped.");
                 return 0;
             }
 
-            Console.WriteLine($"Failed to stop Dev Proxy: {response.StatusCode}");
-            Console.WriteLine("Use --force to forcefully terminate the process.");
+            Console.WriteLine($"Failed to stop Dev Proxy (PID: {state.Pid}): {response.StatusCode}");
+            Console.WriteLine($"Use --force --pid {state.Pid} to forcefully terminate the process.");
             return 1;
         }
         catch (HttpRequestException ex)
         {
-            Console.WriteLine($"Failed to connect to Dev Proxy API: {ex.Message}");
-            Console.WriteLine("Use --force to forcefully terminate the process.");
+            Console.WriteLine($"Failed to connect to Dev Proxy API (PID: {state.Pid}): {ex.Message}");
+            Console.WriteLine($"Use --force --pid {state.Pid} to forcefully terminate the process.");
             return 1;
         }
         catch (TaskCanceledException)
         {
-            Console.WriteLine("Timeout waiting for Dev Proxy to respond.");
-            Console.WriteLine("Use --force to forcefully terminate the process.");
+            Console.WriteLine($"Timeout waiting for Dev Proxy (PID: {state.Pid}) to respond.");
+            Console.WriteLine($"Use --force --pid {state.Pid} to forcefully terminate the process.");
             return 1;
         }
     }
@@ -135,7 +169,7 @@ private static async Task<int> ForceStopAsync(ProxyInstanceState state, Cancella
             return 1;
         }
 
-        await StateManager.DeleteStateAsync(cancellationToken);
+        await StateManager.DeleteStateAsync(state.Pid, cancellationToken);
         return 0;
     }
 
diff --git a/DevProxy/Program.cs b/DevProxy/Program.cs
index 78912573..c280d87f 100644
--- a/DevProxy/Program.cs
+++ b/DevProxy/Program.cs
@@ -46,15 +46,42 @@
 
 static async Task<int> StartDetachedProcessAsync(string[] args)
 {
-    // Check if an instance is already running
-    if (await StateManager.IsInstanceRunningAsync())
+    // Check if an instance is already running as system proxy
+    var systemProxyInstance = await StateManager.FindSystemProxyInstanceAsync();
+    if (systemProxyInstance is not null)
     {
-        var existingState = await StateManager.LoadStateAsync();
-        await Console.Error.WriteLineAsync($"Dev Proxy is already running (PID: {existingState?.Pid}).");
+        await Console.Error.WriteLineAsync($"Dev Proxy is already running as system proxy (PID: {systemProxyInstance.Pid}).");
         await Console.Error.WriteLineAsync("Use 'devproxy stop' to stop it first.");
         return 1;
     }
 
+    // Check for port conflicts with existing instances
+    var existingStates = await StateManager.LoadAllStatesAsync();
+    if (existingStates.Count > 0)
+    {
+        var earlyOptions = new DevProxyConfigOptions();
+        earlyOptions.ParseOptions(args);
+        var requestedPort = earlyOptions.Port ?? 8000;
+        var requestedApiPort = earlyOptions.ApiPort ?? 8897;
+
+        foreach (var existing in existingStates)
+        {
+            if (requestedPort != 0 && existing.Port == requestedPort)
+            {
+                await Console.Error.WriteLineAsync($"Port {requestedPort} is already in use by Dev Proxy instance (PID: {existing.Pid}).");
+                await Console.Error.WriteLineAsync("Use a different --port or stop the existing instance first.");
+                return 1;
+            }
+
+            if (requestedApiPort != 0 && existing.ApiUrl.EndsWith($":{requestedApiPort}", StringComparison.Ordinal))
+            {
+                await Console.Error.WriteLineAsync($"API port {requestedApiPort} is already in use by Dev Proxy instance (PID: {existing.Pid}).");
+                await Console.Error.WriteLineAsync("Use a different --api-port or stop the existing instance first.");
+                return 1;
+            }
+        }
+    }
+
     // Clean up old log files
     StateManager.CleanupOldLogs();
 
@@ -106,7 +133,7 @@ static async Task<int> StartDetachedProcessAsync(string[] args)
         {
             await Task.Delay(200);
 
-            var state = await StateManager.LoadStateAsync();
+            var state = await StateManager.LoadStateByPidAsync(process.Id);
             if (state != null)
             {
                 await Console.Out.WriteLineAsync("Dev Proxy started in background.");
@@ -199,26 +226,6 @@ static async Task<int> RunProxyAsync(string[] args, DevProxyConfigOptions option
     var app = BuildApplication(options);
     try
     {
-        // If running as daemon, save state so other commands can find us
-        if (DevProxyCommand.IsInternalDaemon)
-        {
-            var ipAddress = options.IPAddress ?? app.Configuration.GetValue("ipAddress", "127.0.0.1") ?? "127.0.0.1";
-            var apiPort = options.ApiPort ?? app.Configuration.GetValue("apiPort", 8897);
-            var port = options.Port ?? app.Configuration.GetValue("port", 8000);
-
-            var state = new ProxyInstanceState
-            {
-                Pid = Environment.ProcessId,
-                ApiUrl = $"http://{(ipAddress is "0.0.0.0" or "::" ? "127.0.0.1" : ipAddress)}:{apiPort}",
-                LogFile = DevProxyCommand.DetachedLogFilePath,
-                StartedAt = DateTimeOffset.UtcNow,
-                ConfigFile = options.ConfigFile,
-                Port = port
-            };
-
-            await StateManager.SaveStateAsync(state);
-        }
-
         var devProxyCommand = app.Services.GetRequiredService<DevProxyCommand>();
         return await devProxyCommand.InvokeAsync(args, app);
     }
diff --git a/DevProxy/Proxy/ProxyEngine.cs b/DevProxy/Proxy/ProxyEngine.cs
index 6f353a8f..c4c25751 100755
--- a/DevProxy/Proxy/ProxyEngine.cs
+++ b/DevProxy/Proxy/ProxyEngine.cs
@@ -6,6 +6,9 @@
 using DevProxy.Abstractions.Proxy;
 using DevProxy.Abstractions.Utils;
 using DevProxy.Commands;
+using DevProxy.State;
+using Microsoft.AspNetCore.Hosting.Server;
+using Microsoft.AspNetCore.Hosting.Server.Features;
 using Microsoft.VisualStudio.Threading;
 using System.Collections.Concurrent;
 using System.Diagnostics;
@@ -32,7 +35,8 @@ sealed class ProxyEngine(
     ISet<UrlToWatch> urlsToWatch,
     IProxyStateController proxyController,
     ILogger<ProxyEngine> logger,
-    ILoggerFactory loggerFactory) : BackgroundService, IDisposable
+    ILoggerFactory loggerFactory,
+    IServer server) : BackgroundService, IDisposable
 {
     private readonly IEnumerable<IPlugin> _plugins = plugins;
     private readonly ILogger _logger = logger;
@@ -141,6 +145,12 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         ProxyServer.AddEndPoint(_explicitEndPoint);
         await ProxyServer.StartAsync(cancellationToken: stoppingToken);
 
+        // Save state with actual bound ports so other commands can find us
+        if (DevProxyCommand.IsInternalDaemon)
+        {
+            await SaveInstanceStateAsync();
+        }
+
         // run first-run setup on macOS
         FirstRunSetup();
 
@@ -219,6 +229,31 @@ protected override async Task ExecuteAsync(CancellationToken stoppingToken)
         }
     }
 
+    private async Task SaveInstanceStateAsync()
+    {
+        var proxyPort = _explicitEndPoint?.Port ?? _config.Port;
+        var ipAddress = _config.IPAddress;
+        var loopbackAddress = ipAddress is "0.0.0.0" or "::" ? "127.0.0.1" : ipAddress;
+
+        // Get real API port from Kestrel
+        var serverAddresses = server.Features.Get<IServerAddressesFeature>();
+        var apiAddress = serverAddresses?.Addresses.FirstOrDefault();
+        var apiUrl = apiAddress ?? $"http://{loopbackAddress}:{_config.ApiPort}";
+
+        var state = new ProxyInstanceState
+        {
+            Pid = Environment.ProcessId,
+            ApiUrl = apiUrl,
+            LogFile = DevProxyCommand.DetachedLogFilePath,
+            StartedAt = DateTimeOffset.UtcNow,
+            ConfigFile = _config.ConfigFile,
+            Port = proxyPort,
+            AsSystemProxy = _config.AsSystemProxy
+        };
+
+        await StateManager.SaveStateAsync(state);
+    }
+
     private void FirstRunSetup()
     {
         if (!RunTime.IsMac ||
diff --git a/DevProxy/State/ProxyInstanceState.cs b/DevProxy/State/ProxyInstanceState.cs
index 658992f6..be1f80df 100644
--- a/DevProxy/State/ProxyInstanceState.cs
+++ b/DevProxy/State/ProxyInstanceState.cs
@@ -29,4 +29,7 @@ internal sealed class ProxyInstanceState
 
     [JsonPropertyName("port")]
     public int Port { get; set; }
+
+    [JsonPropertyName("asSystemProxy")]
+    public bool AsSystemProxy { get; set; } = true;
 }
\ No newline at end of file
diff --git a/DevProxy/State/StateManager.cs b/DevProxy/State/StateManager.cs
index 033d324c..c73b3785 100644
--- a/DevProxy/State/StateManager.cs
+++ b/DevProxy/State/StateManager.cs
@@ -9,11 +9,15 @@
 namespace DevProxy.State;
 
 /// <summary>
-/// Manages the state file for detached Dev Proxy instances.
+/// Manages per-instance state files for detached Dev Proxy instances.
+/// Each instance stores its state in a separate file keyed by PID
+/// (e.g. state-1234.json) to avoid cross-instance interference.
 /// </summary>
 internal static class StateManager
 {
-    private const string StateFileName = "state.json";
+    private const string LegacyStateFileName = "state.json";
+    private const string StateFilePrefix = "state-";
+    private const string StateFileExtension = ".json";
     private const string LogsFolderName = "logs";
     private const string ProxyConfigurationFolderName = "dev-proxy";
 
@@ -47,11 +51,19 @@ public static string GetConfigFolder()
     }
 
     /// <summary>
-    /// Gets the path to the state file.
+    /// Gets the per-instance state file path for the given PID.
+    /// </summary>
+    public static string GetInstanceStateFilePath(int pid)
+    {
+        return Path.Combine(GetConfigFolder(), $"{StateFilePrefix}{pid}{StateFileExtension}");
+    }
+
+    /// <summary>
+    /// Gets the path to the legacy single state file (for backward compatibility).
     /// </summary>
     public static string GetStateFilePath()
     {
-        return Path.Combine(GetConfigFolder(), StateFileName);
+        return Path.Combine(GetConfigFolder(), LegacyStateFileName);
     }
 
     /// <summary>
@@ -74,11 +86,11 @@ public static string GenerateLogFilePath()
     }
 
     /// <summary>
-    /// Saves the state of a running detached instance.
+    /// Saves the state of a running detached instance to a per-PID state file.
     /// </summary>
     public static async Task SaveStateAsync(ProxyInstanceState state, CancellationToken cancellationToken = default)
     {
-        var stateFilePath = GetStateFilePath();
+        var stateFilePath = GetInstanceStateFilePath(state.Pid);
         var directory = Path.GetDirectoryName(stateFilePath);
 
         if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
@@ -91,68 +103,116 @@ public static async Task SaveStateAsync(ProxyInstanceState state, CancellationTo
     }
 
     /// <summary>
-    /// Loads the state of a running detached instance.
-    /// Returns null if no state file exists or if the state is stale (process not running).
+    /// Loads the primary running instance's state.
+    /// Prefers the system-proxy instance, then falls back to the most recently
+    /// started instance. Returns null if no live instance is found.
     /// </summary>
     public static async Task<ProxyInstanceState?> LoadStateAsync(CancellationToken cancellationToken = default)
     {
-        var stateFilePath = GetStateFilePath();
+        var states = await LoadAllStatesAsync(cancellationToken);
+        return states
+            .OrderByDescending(s => s.AsSystemProxy ? 1 : 0)
+            .ThenByDescending(s => s.StartedAt)
+            .FirstOrDefault();
+    }
 
-        if (!File.Exists(stateFilePath))
+    /// <summary>
+    /// Loads the state of a specific instance by PID.
+    /// Returns null if no state file exists or the process is no longer running.
+    /// </summary>
+    public static async Task<ProxyInstanceState?> LoadStateByPidAsync(int pid, CancellationToken cancellationToken = default)
+    {
+        return await LoadStateFromFileAsync(GetInstanceStateFilePath(pid), cancellationToken);
+    }
+
+    /// <summary>
+    /// Loads all live detached instance states, cleaning up stale state files.
+    /// Also checks the legacy state.json for backward compatibility.
+    /// </summary>
+    public static async Task<List<ProxyInstanceState>> LoadAllStatesAsync(CancellationToken cancellationToken = default)
+    {
+        var configFolder = GetConfigFolder();
+        if (!Directory.Exists(configFolder))
         {
-            return null;
+            return [];
         }
 
-        try
-        {
-            var json = await File.ReadAllTextAsync(stateFilePath, cancellationToken);
-            var state = JsonSerializer.Deserialize<ProxyInstanceState>(json);
+        var states = new List<ProxyInstanceState>();
+        var seenPids = new HashSet<int>();
 
-            if (state == null)
+        // Check per-instance state files
+        var stateFiles = Directory.GetFiles(configFolder, $"{StateFilePrefix}*{StateFileExtension}");
+        foreach (var filePath in stateFiles)
+        {
+            var state = await LoadStateFromFileAsync(filePath, cancellationToken);
+            if (state is not null && seenPids.Add(state.Pid))
             {
-                return null;
+                states.Add(state);
             }
+        }
 
-            // Verify the process is still running
-            if (!IsProcessRunning(state.Pid))
+        // Also check legacy state file for backward compatibility
+        var legacyPath = GetStateFilePath();
+        if (File.Exists(legacyPath))
+        {
+            var legacyState = await LoadStateFromFileAsync(legacyPath, cancellationToken);
+            if (legacyState is not null && seenPids.Add(legacyState.Pid))
             {
-                // Clean up stale state file
-                await DeleteStateAsync(cancellationToken);
-                return null;
+                states.Add(legacyState);
             }
-
-            return state;
-        }
-        catch (JsonException)
-        {
-            return null;
-        }
-        catch (IOException)
-        {
-            return null;
         }
+
+        return states;
     }
 
     /// <summary>
-    /// Deletes the state file.
+    /// Finds a running detached instance that owns the system proxy.
+    /// Returns null if no system-proxy instance is running.
     /// </summary>
-    public static Task DeleteStateAsync(CancellationToken cancellationToken = default)
+    public static async Task<ProxyInstanceState?> FindSystemProxyInstanceAsync(CancellationToken cancellationToken = default)
     {
-        var stateFilePath = GetStateFilePath();
+        var states = await LoadAllStatesAsync(cancellationToken);
+        return states.Find(s => s.AsSystemProxy);
+    }
+
+    /// <summary>
+    /// Deletes the state file for a specific PID.
+    /// Also cleans up the legacy state file if it belongs to this PID.
+    /// </summary>
+    public static async Task DeleteStateAsync(int pid, CancellationToken cancellationToken = default)
+    {
+        DeleteFile(GetInstanceStateFilePath(pid));
 
+        // Also clean up legacy state file if it belongs to this PID
+        var legacyPath = GetStateFilePath();
         try
         {
-            if (File.Exists(stateFilePath))
+            if (File.Exists(legacyPath))
             {
-                File.Delete(stateFilePath);
+                var json = await File.ReadAllTextAsync(legacyPath, cancellationToken);
+                var state = JsonSerializer.Deserialize<ProxyInstanceState>(json);
+                if (state?.Pid == pid)
+                {
+                    DeleteFile(legacyPath);
+                }
             }
         }
+        catch (JsonException)
+        {
+            // Ignore corrupt legacy file
+        }
         catch (IOException)
         {
-            // Ignore - file might be locked or already deleted
+            // Ignore I/O errors
         }
+    }
 
-        return Task.CompletedTask;
+    /// <summary>
+    /// Deletes the state file for the current process.
+    /// </summary>
+    public static Task DeleteStateAsync(CancellationToken cancellationToken = default)
+    {
+        return DeleteStateAsync(Environment.ProcessId, cancellationToken);
     }
 
     /// <summary>
@@ -161,7 +221,7 @@ public static Task DeleteStateAsync(CancellationToken cancellationToken = defaul
     public static async Task<bool> IsInstanceRunningAsync(CancellationToken cancellationToken = default)
     {
         var state = await LoadStateAsync(cancellationToken);
-        return state != null;
+        return state is not null;
     }
 
     /// <summary>
@@ -186,6 +246,66 @@ private static bool IsProcessRunning(int pid)
         }
     }
 
+    /// <summary>
+    /// Loads a state from a specific file path.
+    /// Returns null if the file doesn't exist, can't be parsed,
+    /// or refers to a process that's no longer running.
+    /// Cleans up the file if the process is stale.
+    /// </summary>
+    private static async Task<ProxyInstanceState?> LoadStateFromFileAsync(
+        string filePath,
+        CancellationToken cancellationToken)
+    {
+        if (!File.Exists(filePath))
+        {
+            return null;
+        }
+
+        try
+        {
+            var json = await File.ReadAllTextAsync(filePath, cancellationToken);
+            var state = JsonSerializer.Deserialize<ProxyInstanceState>(json);
+
+            if (state is null)
+            {
+                return null;
+            }
+
+            // Verify the process is still running
+            if (!IsProcessRunning(state.Pid))
+            {
+                // Clean up stale state file
+                DeleteFile(filePath);
+                return null;
+            }
+
+            return state;
+        }
+        catch (JsonException)
+        {
+            return null;
+        }
+        catch (IOException)
+        {
+            return null;
+        }
+    }
+
+    private static void DeleteFile(string path)
+    {
+        try
+        {
+            if (File.Exists(path))
+            {
+                File.Delete(path);
+            }
+        }
+        catch (IOException)
+        {
+            // Ignore - file might be locked or already deleted
+        }
+    }
+
     /// <summary>
     /// Cleans up old log files, keeping only the most recent ones.
     /// </summary>