@pasko70/pibo 2.5.2 → 3.0.1

package/dist/mcp/daemon-client.js

@@ -1,26 +1,40 @@
 /**
- * MCP-CLI Daemon Client - IPC client for communicating with daemon workers
- *
- * Handles spawning daemons, detecting stale connections, and forwarding requests.
+ * MCP daemon client and cross-process lifecycle coordination.
  */
-import { spawn } from 'node:child_process';
+import { spawn, } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { createConnection } from 'node:net';
-import { dirname, extname, join } from 'node:path';
+import { basename, dirname, extname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { debug, getConfigHash, getDaemonRequestTimeoutMs, getSocketDir, getSocketPath, } from './config.js';
-import { isProcessRunning, killProcess, readPidFile, removePidFile, removeSocketFile, } from './daemon.js';
-/**
- * Generate a unique request ID
- */
+import { debug, getConfigHash, getDaemonClaimPath, getDaemonLeasePrefix, getDaemonRequestTimeoutMs, getPidPath, getSocketDir, getSocketPath, usesFilesystemSocket, } from './config.js';
+import { daemonProcessIdentityMatches, daemonIdentityMatches, getOwnershipFileAgeMs, isProcessRunning, pidFileIdentityMatches, processIdentityMatches, readOwnershipFilePath, readPidFile, readPidFilePath, readProcessIdentity, refreshOwnershipFile, removeDaemonState, removeMalformedOwnershipFile, removeOwnershipFile, removePidFilePath, removeUntrackedEndpoint, terminateDaemonProcess, writeOwnershipFileExclusive, } from './daemon.js';
+const OWNERSHIP_POLL_MS = 25;
+const DEAD_OWNER_GRACE_MS = 100;
+const OWNERSHIP_HEARTBEAT_MS = 25;
+const MAX_DAEMON_MESSAGE_BYTES = 1024 * 1024;
 function generateRequestId() {
-    return `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+    return `${Date.now()}-${randomUUID()}`;
 }
-/**
- * Send a request to the daemon and wait for response
- */
-async function sendRequest(socketPath, request) {
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isDaemonIdentity(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (Number.isInteger(candidate.pid) &&
+        (candidate.pid ?? 0) > 0 &&
+        typeof candidate.configHash === 'string' &&
+        typeof candidate.generation === 'string' &&
+        candidate.generation.length > 0 &&
+        typeof candidate.startedAt === 'string');
+}
+function isCompletePidInfo(value) {
+    return isDaemonIdentity(value);
+}
+async function sendRequest(socketPath, request, timeoutMs = getDaemonRequestTimeoutMs()) {
     return new Promise((resolve, reject) => {
         let settled = false;
         let responseText = '';
@@ -32,23 +46,30 @@ async function sendRequest(socketPath, request) {
             fn();
         };
         const socket = createConnection(socketPath, () => {
-            socket.write(JSON.stringify(request));
+            socket.write(`${JSON.stringify(request)}\n`);
         });
         socket.on('data', (data) => {
             responseText += data.toString();
-            if (responseText.includes('\n')) {
-                settle(() => {
-                    try {
-                        resolve(JSON.parse(responseText.trim()));
-                    }
-                    catch {
-                        reject(new Error('Invalid response from daemon'));
-                    }
-                    finally {
-                        socket.end();
-                    }
-                });
+            if (responseText.length > MAX_DAEMON_MESSAGE_BYTES) {
+                socket.destroy();
+                settle(() => reject(new Error('Daemon response exceeds 1 MiB')));
+                return;
             }
+            const newlineIndex = responseText.indexOf('\n');
+            if (newlineIndex === -1)
+                return;
+            const responseLine = responseText.slice(0, newlineIndex);
+            settle(() => {
+                try {
+                    resolve(JSON.parse(responseLine));
+                }
+                catch {
+                    reject(new Error('Invalid response from daemon'));
+                }
+                finally {
+                    socket.end();
+                }
+            });
         });
         socket.on('end', () => {
             if (settled)
@@ -68,141 +89,367 @@ async function sendRequest(socketPath, request) {
         const timeoutId = setTimeout(() => {
             socket.destroy();
             settle(() => reject(new Error('Daemon request timeout')));
-        }, getDaemonRequestTimeoutMs());
+        }, timeoutMs);
     });
 }
-/**
- * Check if daemon is running and has matching config
- */
-function isDaemonValid(serverName, config) {
+async function pingDaemon(serverName, timeoutMs) {
     const socketPath = getSocketPath(serverName);
-    const pidInfo = readPidFile(serverName);
-    // No PID file = no daemon
-    if (!pidInfo) {
-        debug(`[daemon-client] No PID file for ${serverName}`);
-        return false;
+    if (usesFilesystemSocket() && !existsSync(socketPath))
+        return null;
+    try {
+        const response = await sendRequest(socketPath, { id: generateRequestId(), type: 'ping' }, timeoutMs);
+        return response.success && isDaemonIdentity(response.data)
+            ? response.data
+            : null;
     }
-    // Check if process is actually running
-    if (!isProcessRunning(pidInfo.pid)) {
-        debug(`[daemon-client] Process ${pidInfo.pid} not running, cleaning up`);
-        removePidFile(serverName);
-        removeSocketFile(serverName);
-        return false;
+    catch {
+        return null;
     }
-    // Check if config matches
-    const currentHash = getConfigHash(config);
-    if (pidInfo.configHash !== currentHash) {
-        debug(`[daemon-client] Config hash mismatch for ${serverName}, killing old daemon`);
-        killProcess(pidInfo.pid);
-        removePidFile(serverName);
-        removeSocketFile(serverName);
-        return false;
+}
+async function waitForDaemonReady(serverName, expected, timeoutMs, isAlive) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && isAlive()) {
+        const remainingMs = deadline - Date.now();
+        const identity = await pingDaemon(serverName, Math.max(1, Math.min(500, remainingMs)));
+        if (daemonIdentityMatches(identity, expected))
+            return identity;
+        await sleep(OWNERSHIP_POLL_MS);
+    }
+    return null;
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline && isProcessRunning(pid)) {
+        await sleep(50);
+    }
+    return !isProcessRunning(pid);
+}
+async function waitForDaemonExit(expected, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    const isExpectedProcessRunning = () => expected.processIdentity
+        ? daemonProcessIdentityMatches(expected)
+        : isProcessRunning(expected.pid);
+    while (Date.now() < deadline && isExpectedProcessRunning()) {
+        await sleep(50);
     }
-    // Check if socket exists
-    if (!existsSync(socketPath)) {
-        debug(`[daemon-client] Socket missing for ${serverName}, cleaning up`);
-        killProcess(pidInfo.pid);
-        removePidFile(serverName);
+    return !isExpectedProcessRunning();
+}
+async function stopDaemon(serverName, expected, ownership) {
+    try {
+        await sendRequest(getSocketPath(serverName), {
+            id: generateRequestId(),
+            type: 'close',
+            generation: expected.generation,
+        }, 1000);
+    }
+    catch {
+        // The daemon may still be starting or may already have crashed.
+    }
+    let exited = await waitForDaemonExit(expected, 2000);
+    if (!exited) {
+        const current = readPidFile(serverName);
+        if (!pidFileIdentityMatches(current, expected))
+            return false;
+        if (!terminateDaemonProcess(expected))
+            return false;
+        exited = await waitForDaemonExit(expected, 1000);
+    }
+    return exited && removeDaemonState(serverName, expected, ownership);
+}
+async function stopLegacyDaemon(serverName, pidInfo, ownership) {
+    try {
+        await sendRequest(getSocketPath(serverName), { id: generateRequestId(), type: 'close' }, 1000);
+    }
+    catch {
+        // Continue to the bounded process check.
+    }
+    const exited = await waitForProcessExit(pidInfo.pid, 2000);
+    return exited && removeDaemonState(serverName, pidInfo, ownership);
+}
+async function stopUntrackedEndpoint(serverName, ownership) {
+    const identity = await pingDaemon(serverName, 500);
+    if (!identity) {
+        return removeUntrackedEndpoint(serverName, ownership);
+    }
+    try {
+        await sendRequest(getSocketPath(serverName), {
+            id: generateRequestId(),
+            type: 'close',
+            generation: identity.generation,
+        }, 1000);
+    }
+    catch {
         return false;
     }
-    return true;
+    const exited = await waitForDaemonExit(identity, 2000);
+    return exited && removeUntrackedEndpoint(serverName, ownership);
 }
-/**
- * Spawn a new daemon process for a server
- */
-async function spawnDaemon(serverName, config) {
-    debug(`[daemon-client] Spawning daemon for ${serverName}`);
-    // Find the daemon script next to this module. This is .ts under tsx and .js after build.
-    const modulePath = fileURLToPath(import.meta.url);
-    const daemonScript = join(dirname(modulePath), `daemon${extname(modulePath)}`);
-    const configJson = JSON.stringify(config);
-    // Spawn detached process
-    const proc = spawn(process.execPath, [
-        ...process.execArgv,
+export function getDaemonSpawnOptions() {
+    return {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+        env: { ...process.env },
+    };
+}
+export function getDaemonSpawnArguments(daemonScript, serverName, config, generation, execArgv = process.execArgv) {
+    return [
+        ...filterDaemonExecArgv(execArgv),
         daemonScript,
         '--daemon',
         serverName,
-        configJson,
-    ], {
-        detached: true,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env },
-    });
-    // Wait for daemon to signal readiness or fail
-    return new Promise((resolve) => {
-        let resolved = false;
-        proc.stdout?.on('data', (data) => {
-            const text = data.toString();
-            if (text.includes('DAEMON_READY') && !resolved) {
-                resolved = true;
-                // Don't await the process, let it run in the background.
-                proc.stdout?.unref?.();
-                proc.stderr?.unref?.();
-                proc.unref();
-                resolve(true);
-            }
-        });
-        // Timeout after 5 seconds (fast fallback to direct connection)
-        setTimeout(() => {
-            if (!resolved) {
-                resolved = true;
-                debug(`[daemon-client] Daemon spawn timeout for ${serverName}`);
-                resolve(false);
-            }
-        }, 5000);
-        // Check for early exit
-        proc.on('exit', (code) => {
-            if (!resolved && code !== 0) {
-                resolved = true;
-                debug(`[daemon-client] Daemon exited with code ${code}`);
-                resolve(false);
-            }
-        });
-    });
+        JSON.stringify(config),
+        generation,
+    ];
 }
-/**
- * Get or create a daemon connection for a server
- * Returns null if daemon mode fails (caller should fallback to direct connection)
- */
-export async function getDaemonConnection(serverName, config) {
-    const socketPath = getSocketPath(serverName);
-    // Check if valid daemon exists
-    if (!isDaemonValid(serverName, config)) {
-        // Spawn new daemon
-        const spawned = await spawnDaemon(serverName, config);
-        if (!spawned) {
-            debug(`[daemon-client] Failed to spawn daemon for ${serverName}`);
-            return null;
+const EXECUTION_FLAGS_WITH_VALUE = new Set([
+    '-e',
+    '--eval',
+    '-p',
+    '--print',
+    '--run',
+    '--input-type',
+    '--entry-url',
+    '--test-name-pattern',
+    '--test-skip-pattern',
+    '--test-reporter',
+    '--test-reporter-destination',
+    '--test-shard',
+    '--watch-path',
+]);
+const EXECUTION_FLAGS = new Set([
+    '-c',
+    '--check',
+    '-i',
+    '--interactive',
+    '--test',
+    '--watch',
+]);
+/** Preserve runtime flags while removing selectors that execute something
+ * other than the daemon script or turn the detached child into a test/watch
+ * runner. */
+export function filterDaemonExecArgv(execArgv) {
+    const filtered = [];
+    for (let index = 0; index < execArgv.length; index += 1) {
+        const argument = execArgv[index];
+        if (EXECUTION_FLAGS_WITH_VALUE.has(argument)) {
+            index += 1;
+            continue;
+        }
+        if (EXECUTION_FLAGS.has(argument) ||
+            argument.startsWith('--eval=') ||
+            argument.startsWith('--print=') ||
+            argument.startsWith('--run=') ||
+            argument.startsWith('--input-type=') ||
+            argument.startsWith('--entry-url=') ||
+            argument.startsWith('--test-') ||
+            argument.startsWith('--watch-') ||
+            /^-[ep](?:=|.)/.test(argument)) {
+            continue;
         }
-        // Wait a bit for socket to be ready
-        await new Promise((r) => setTimeout(r, 100));
+        filtered.push(argument);
     }
-    // Verify socket exists
-    if (!existsSync(socketPath)) {
-        debug(`[daemon-client] Socket not found after spawn for ${serverName}`);
+    return filtered;
+}
+async function spawnDaemon(serverName, config, configHash, generation, timeoutMs, ownership) {
+    debug(`[daemon-client] Spawning daemon for ${serverName}`);
+    const modulePath = fileURLToPath(import.meta.url);
+    const daemonScript = join(dirname(modulePath), `daemon${extname(modulePath)}`);
+    const proc = spawn(process.execPath, getDaemonSpawnArguments(daemonScript, serverName, config, generation), getDaemonSpawnOptions());
+    let spawnError;
+    let exited = false;
+    proc.once('error', (error) => {
+        spawnError = error;
+    });
+    proc.once('exit', () => {
+        exited = true;
+    });
+    proc.unref();
+    if (proc.pid === undefined)
         return null;
+    const expected = {
+        pid: proc.pid,
+        configHash,
+        generation,
+        startedAt: '',
+        processIdentity: readProcessIdentity(proc.pid) ?? undefined,
+    };
+    const ready = await waitForDaemonReady(serverName, expected, timeoutMs, () => !spawnError && !exited);
+    if (ready)
+        return ready;
+    if (spawnError) {
+        debug(`[daemon-client] Spawn failed for ${serverName}: ${spawnError.message}`);
+    }
+    else if (exited) {
+        debug(`[daemon-client] Daemon exited before readiness for ${serverName}`);
+    }
+    else {
+        debug(`[daemon-client] Daemon startup timed out for ${serverName}`);
+    }
+    const pidInfo = readPidFile(serverName);
+    if (pidInfo && daemonIdentityMatches(pidInfo, expected)) {
+        await stopDaemon(serverName, pidInfo, ownership);
     }
-    // Test connection with ping
+    else if (!exited && isProcessRunning(proc.pid)) {
+        terminateDaemonProcess(expected);
+        await waitForDaemonExit(expected, 1000);
+    }
+    return null;
+}
+function acquireClaim(serverName, configHash) {
+    const claim = {
+        ownerPid: process.pid,
+        ownerProcessIdentity: readProcessIdentity(process.pid) ?? undefined,
+        ownerNonce: randomUUID(),
+        generation: randomUUID(),
+        configHash,
+        startedAt: new Date().toISOString(),
+        serverName,
+    };
+    return writeOwnershipFileExclusive(getDaemonClaimPath(serverName), claim)
+        ? claim
+        : null;
+}
+function ownershipIsLive(path, ownership) {
+    if (processIdentityMatches(readProcessIdentity(ownership.ownerPid), ownership.ownerProcessIdentity)) {
+        return true;
+    }
+    const ageMs = getOwnershipFileAgeMs(path);
+    return Boolean(ownership.ownerNonce &&
+        ageMs !== null &&
+        ageMs < DEAD_OWNER_GRACE_MS);
+}
+function startOwnershipHeartbeat(path, ownership) {
+    if (ownership.ownerProcessIdentity)
+        return () => { };
+    const timer = setInterval(() => {
+        refreshOwnershipFile(path, ownership.generation, ownership.ownerNonce);
+    }, OWNERSHIP_HEARTBEAT_MS);
+    timer.unref();
+    return () => clearInterval(timer);
+}
+function removeStaleOwnershipFile(path) {
+    const ownership = readOwnershipFilePath(path);
+    const ageMs = getOwnershipFileAgeMs(path);
+    if (ageMs === null)
+        return false;
+    if (!ownership) {
+        return removeMalformedOwnershipFile(path, DEAD_OWNER_GRACE_MS);
+    }
+    if (ownershipIsLive(path, ownership) || ageMs < DEAD_OWNER_GRACE_MS) {
+        return false;
+    }
+    return removeOwnershipFile(path, ownership.generation);
+}
+function claimIsOwned(path, claim) {
+    return readOwnershipFilePath(path)?.generation === claim.generation;
+}
+async function listActiveLeases(serverName) {
+    const prefix = getDaemonLeasePrefix(serverName);
+    const directory = dirname(prefix);
+    const filePrefix = basename(prefix);
+    let files;
     try {
-        const pingResponse = await sendRequest(socketPath, {
-            id: generateRequestId(),
-            type: 'ping',
-        });
-        if (!pingResponse.success) {
-            debug(`[daemon-client] Ping failed for ${serverName}`);
+        files = (await readdir(directory)).filter((file) => file.startsWith(filePrefix));
+    }
+    catch {
+        return [];
+    }
+    const active = [];
+    for (const file of files) {
+        const path = join(directory, file);
+        const ownership = readOwnershipFilePath(path);
+        if (!ownership || !('daemonGeneration' in ownership)) {
+            removeStaleOwnershipFile(path);
+            continue;
+        }
+        if (!ownershipIsLive(path, ownership)) {
+            const removed = removeStaleOwnershipFile(path);
+            if (!removed && existsSync(path))
+                active.push(ownership);
+            continue;
+        }
+        active.push(ownership);
+    }
+    return active;
+}
+function createLease(serverName, identity) {
+    for (;;) {
+        const lease = {
+            ownerPid: process.pid,
+            ownerProcessIdentity: readProcessIdentity(process.pid) ?? undefined,
+            ownerNonce: randomUUID(),
+            generation: randomUUID(),
+            daemonGeneration: identity.generation,
+            configHash: identity.configHash,
+            startedAt: new Date().toISOString(),
+            serverName,
+        };
+        const path = `${getDaemonLeasePrefix(serverName)}${lease.generation}`;
+        if (writeOwnershipFileExclusive(path, lease))
+            return { path, lease };
+    }
+}
+async function ensureDaemonAsOwner(serverName, config, configHash, claim, deadline) {
+    const remaining = () => Math.max(0, deadline - Date.now());
+    const claimPath = getDaemonClaimPath(serverName);
+    const ownership = {
+        path: claimPath,
+        generation: claim.generation,
+    };
+    if (!claimIsOwned(claimPath, claim))
+        return null;
+    let pidInfo = readPidFile(serverName);
+    if (pidInfo &&
+        (!isProcessRunning(pidInfo.pid) ||
+            (pidInfo.processIdentity && !daemonProcessIdentityMatches(pidInfo)))) {
+        const removed = removeDaemonState(serverName, pidInfo, ownership);
+        if (!removed)
             return null;
+        pidInfo = null;
+    }
+    if (pidInfo && isProcessRunning(pidInfo.pid)) {
+        if (isCompletePidInfo(pidInfo) && pidInfo.configHash === configHash) {
+            const ready = await waitForDaemonReady(serverName, pidInfo, remaining(), () => isProcessRunning(pidInfo?.pid ?? 0));
+            if (ready)
+                return ready;
+        }
+        while ((await listActiveLeases(serverName)).length > 0) {
+            if (remaining() <= 0 || !claimIsOwned(claimPath, claim))
+                return null;
+            await sleep(OWNERSHIP_POLL_MS);
         }
+        if (!claimIsOwned(claimPath, claim))
+            return null;
+        const stopped = isCompletePidInfo(pidInfo)
+            ? await stopDaemon(serverName, pidInfo, ownership)
+            : await stopLegacyDaemon(serverName, pidInfo, ownership);
+        if (!stopped)
+            return null;
     }
-    catch (error) {
-        debug(`[daemon-client] Connection test failed for ${serverName}: ${error.message}`);
+    else if (!(await stopUntrackedEndpoint(serverName, ownership))) {
         return null;
     }
-    debug(`[daemon-client] Connected to daemon for ${serverName}`);
-    // Return connection interface
+    if (remaining() <= 0 || !claimIsOwned(claimPath, claim))
+        return null;
+    const generation = randomUUID();
+    return spawnDaemon(serverName, config, configHash, generation, remaining(), ownership);
+}
+function createDaemonConnection(serverName, identity, leasePath, lease, stopLeaseHeartbeat) {
+    const socketPath = getSocketPath(serverName);
+    let closed = false;
+    const request = async (requestValue) => {
+        if (closed)
+            throw new Error('Daemon connection is closed');
+        return sendRequest(socketPath, {
+            ...requestValue,
+            generation: identity.generation,
+        });
+    };
     return {
         serverName,
         async listTools() {
-            const response = await sendRequest(socketPath, {
+            const response = await request({
                 id: generateRequestId(),
                 type: 'listTools',
             });
@@ -212,7 +459,7 @@ export async function getDaemonConnection(serverName, config) {
             return response.data;
         },
         async callTool(toolName, args) {
-            const response = await sendRequest(socketPath, {
+            const response = await request({
                 id: generateRequestId(),
                 type: 'callTool',
                 toolName,
@@ -224,7 +471,7 @@ export async function getDaemonConnection(serverName, config) {
             return response.data;
         },
         async getInstructions() {
-            const response = await sendRequest(socketPath, {
+            const response = await request({
                 id: generateRequestId(),
                 type: 'getInstructions',
             });
@@ -234,33 +481,106 @@ export async function getDaemonConnection(serverName, config) {
             return response.data;
         },
         async close() {
-            // Just disconnect, don't tell daemon to close (let it idle timeout)
-            debug(`[daemon-client] Disconnecting from ${serverName} daemon`);
+            if (closed)
+                return;
+            closed = true;
+            stopLeaseHeartbeat();
+            removeOwnershipFile(leasePath, lease.generation);
+            debug(`[daemon-client] Released ${serverName} daemon lease`);
         },
     };
 }
 /**
- * Clean up any orphaned daemon processes and sockets
- * Call this on CLI startup
+ * Converge independent callers on one matching daemon, or return null so the
+ * caller can use its existing direct-connection fallback.
  */
+export async function getDaemonConnection(serverName, config) {
+    const configHash = getConfigHash(config);
+    const deadline = Date.now() + getDaemonRequestTimeoutMs();
+    const claimPath = getDaemonClaimPath(serverName);
+    while (Date.now() < deadline) {
+        const claim = acquireClaim(serverName, configHash);
+        if (!claim) {
+            removeStaleOwnershipFile(claimPath);
+            await sleep(OWNERSHIP_POLL_MS);
+            continue;
+        }
+        const stopClaimHeartbeat = startOwnershipHeartbeat(claimPath, claim);
+        try {
+            const identity = await ensureDaemonAsOwner(serverName, config, configHash, claim, deadline);
+            if (!identity) {
+                if (Date.now() < deadline)
+                    continue;
+                return null;
+            }
+            if (!claimIsOwned(claimPath, claim))
+                continue;
+            const { path, lease } = createLease(serverName, identity);
+            const stopLeaseHeartbeat = startOwnershipHeartbeat(path, lease);
+            debug(`[daemon-client] Connected to ${serverName} generation ${identity.generation}`);
+            return createDaemonConnection(serverName, identity, path, lease, stopLeaseHeartbeat);
+        }
+        finally {
+            stopClaimHeartbeat();
+            removeOwnershipFile(claimPath, claim.generation);
+        }
+    }
+    debug(`[daemon-client] Timed out waiting for daemon ownership: ${serverName}`);
+    return null;
+}
+/** Clean dead daemon metadata and abandoned ownership files on CLI startup. */
 export async function cleanupOrphanedDaemons() {
     const socketDir = getSocketDir();
-    if (!existsSync(socketDir)) {
+    if (!existsSync(socketDir))
         return;
-    }
     try {
-        const files = (await readdir(socketDir)).filter((file) => file.endsWith('.pid'));
+        const files = await readdir(socketDir);
         for (const file of files) {
-            const serverName = file.replace('.pid', '');
-            const pidInfo = readPidFile(serverName);
-            if (pidInfo && !isProcessRunning(pidInfo.pid)) {
-                debug(`[daemon-client] Cleaning up orphaned daemon: ${serverName}`);
-                removePidFile(serverName);
-                removeSocketFile(serverName);
+            const path = join(socketDir, file);
+            if (file.endsWith('.lock') ||
+                file.includes('.lease-') ||
+                file.includes('.delete-') ||
+                file.includes('.publish-')) {
+                removeStaleOwnershipFile(path);
+                continue;
+            }
+            if (!file.endsWith('.pid'))
+                continue;
+            const pidInfo = readPidFilePath(path);
+            if (!pidInfo ||
+                (isProcessRunning(pidInfo.pid) &&
+                    (!pidInfo.processIdentity || daemonProcessIdentityMatches(pidInfo)))) {
+                continue;
+            }
+            const serverName = pidInfo.serverName;
+            if (serverName) {
+                const claim = acquireClaim(serverName, pidInfo.configHash);
+                if (!claim)
+                    continue;
+                const ownership = {
+                    path: getDaemonClaimPath(serverName),
+                    generation: claim.generation,
+                };
+                try {
+                    const current = readPidFilePath(path);
+                    if (!pidFileIdentityMatches(current, pidInfo))
+                        continue;
+                    if (path === getPidPath(serverName)) {
+                        removeDaemonState(serverName, pidInfo, ownership);
+                    }
+                    else {
+                        // Legacy endpoint names cannot be bound to a modern generation.
+                        // Remove only their atomically acquired dead PID metadata.
+                        removePidFilePath(path, pidInfo);
+                    }
+                }
+                finally {
+                    removeOwnershipFile(ownership.path, ownership.generation);
+                }
             }
         }
     }
     catch {
-        // Ignore errors during cleanup scan
+        // Cleanup is opportunistic; connection setup performs exact recovery.
     }
 }