@aroman22/codegraph-vba-darwin-arm64 1.15.0 → 1.17.0

package/lib/dist/mcp/daemon-registry.js

@@ -33,12 +33,22 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DAEMON_RELEASE_LEASE_TTL_MS = void 0;
 exports.getRegistryDir = getRegistryDir;
 exports.isProcessAlive = isProcessAlive;
 exports.registerDaemon = registerDaemon;
 exports.deregisterDaemon = deregisterDaemon;
 exports.listDaemons = listDaemons;
+exports.tryAcquireDaemonLifecycleLock = tryAcquireDaemonLifecycleLock;
+exports.releaseDaemonLifecycleLock = releaseDaemonLifecycleLock;
+exports.hasActiveDaemonReleaseLease = hasActiveDaemonReleaseLease;
+exports.tryAcquireDaemonReleaseLease = tryAcquireDaemonReleaseLease;
+exports.refreshDaemonReleaseLease = refreshDaemonReleaseLease;
+exports.canonicalDaemonRoot = canonicalDaemonRoot;
+exports.canonicalDaemonRootKey = canonicalDaemonRootKey;
+exports.releaseDaemonAt = releaseDaemonAt;
 exports.stopDaemonAt = stopDaemonAt;
+exports.requestDaemonRelease = requestDaemonRelease;
 exports.stopAllDaemons = stopAllDaemons;
 /**
  * Global daemon registry + stop/list control — the discovery layer behind
@@ -64,6 +74,7 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const crypto = __importStar(require("crypto"));
+const net = __importStar(require("net"));
 const daemon_paths_1 = require("./daemon-paths");
 /**
  * `~/.codegraph/daemons` — GLOBAL, keyed off the home install dir. (The
@@ -148,24 +159,46 @@ function listDaemons(opts = {}) {
     }
     return live.sort((a, b) => b.startedAt - a.startedAt);
 }
-/** Remove a stopped daemon's leftover lockfile + socket + registry record. */
-function cleanupDaemonArtifacts(root) {
+function sameGeneration(actual, expected) {
+    return Boolean(actual) && actual.pid === expected.pid && actual.startedAt === expected.startedAt &&
+        actual.socketPath === expected.socketPath;
+}
+/** Delete only artifacts that still belong to the stopped daemon generation. */
+function cleanupDaemonArtifacts(root, expected, beforeDelete) {
+    let lock = null;
+    let registry = null;
     try {
-        fs.unlinkSync((0, daemon_paths_1.getDaemonPidPath)(root));
+        lock = (0, daemon_paths_1.decodeLockInfo)(fs.readFileSync((0, daemon_paths_1.getDaemonPidPath)(root), 'utf8'));
     }
     catch { /* gone */ }
-    // POSIX sockets are real files; Windows named pipes vanish with the process.
-    // Sweep every candidate — a daemon that relocated past an unusable in-project
-    // FS (ExFAT/FAT; #997) left its socket at the tmpdir fallback, not candidate 0.
-    if (process.platform !== 'win32') {
-        for (const candidate of (0, daemon_paths_1.getDaemonSocketCandidates)(root)) {
-            try {
-                fs.unlinkSync(candidate);
-            }
-            catch { /* gone */ }
+    try {
+        registry = JSON.parse(fs.readFileSync(recordPath(root), 'utf8'));
+    }
+    catch { /* gone */ }
+    const lockMatches = sameGeneration(lock, expected);
+    const registryMatches = sameGeneration(registry, expected);
+    const successorExists = Boolean(lock && !lockMatches) || Boolean(registry && !registryMatches);
+    beforeDelete?.();
+    if (lockMatches) {
+        try {
+            fs.unlinkSync((0, daemon_paths_1.getDaemonPidPath)(root));
+        }
+        catch { /* raced */ }
+    }
+    if (registryMatches) {
+        try {
+            fs.unlinkSync(recordPath(root));
         }
+        catch { /* raced */ }
+    }
+    // A successor can reuse the stable socket path. Never unlink it when either
+    // authoritative ownership record has already advanced to a new generation.
+    if (!successorExists && process.platform !== 'win32' && expected.socketPath) {
+        try {
+            fs.unlinkSync(expected.socketPath);
+        }
+        catch { /* gone */ }
     }
-    deregisterDaemon(root);
 }
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 async function waitForDeath(pid, timeoutMs) {
@@ -177,50 +210,529 @@ async function waitForDeath(pid, timeoutMs) {
     }
     return !isProcessAlive(pid);
 }
-/**
- * Stop the daemon serving `root`: SIGTERM, wait, then SIGKILL if it won't go,
- * then sweep its artifacts. `root` must be realpath'd (match how the daemon
- * keys its socket/lockfile). Resolves the pid from the authoritative lockfile,
- * falling back to the registry.
- */
-async function stopDaemonAt(root) {
-    let pid = null;
+exports.DAEMON_RELEASE_LEASE_TTL_MS = 30_000;
+const DAEMON_RELEASE_HEARTBEAT_MS = 5_000;
+const DAEMON_LIFECYCLE_TTL_MS = 30_000;
+function lifecycleArtifacts(root) {
+    const fixed = (0, daemon_paths_1.getDaemonLifecyclePath)(root);
+    const dir = path.dirname(fixed);
+    const prefix = path.basename(fixed);
+    try {
+        return fs.readdirSync(dir).filter((name) => name === prefix || name.startsWith(`${prefix}.claim.`)).map((name) => path.join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+function cleanupExpiredLifecycleArtifacts(root, now) {
+    const fixed = (0, daemon_paths_1.getDaemonLifecyclePath)(root);
+    for (const artifact of lifecycleArtifacts(root)) {
+        let expiresAt;
+        try {
+            const value = JSON.parse(fs.readFileSync(artifact, 'utf8'));
+            expiresAt = typeof value.expiresAt === 'number' ? value.expiresAt : fs.statSync(artifact).mtimeMs + DAEMON_LIFECYCLE_TTL_MS;
+        }
+        catch {
+            try {
+                expiresAt = fs.statSync(artifact).mtimeMs + DAEMON_LIFECYCLE_TTL_MS;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (expiresAt > now)
+            continue;
+        if (artifact === fixed) {
+            const claim = `${fixed}.claim.${crypto.randomUUID()}`;
+            try {
+                fs.renameSync(fixed, claim);
+            }
+            catch {
+                continue;
+            }
+            try {
+                fs.unlinkSync(claim);
+            }
+            catch { /* gone */ }
+        }
+        else {
+            try {
+                fs.unlinkSync(artifact);
+            }
+            catch { /* gone */ }
+        }
+    }
+}
+/** Atomically acquire the shared startup/release publication arbiter. */
+function tryAcquireDaemonLifecycleLock(root, options = {}) {
+    const now = options.now ?? Date.now();
+    cleanupExpiredLifecycleArtifacts(root, now);
+    if (lifecycleArtifacts(root).length !== 0)
+        return null;
+    const fixed = (0, daemon_paths_1.getDaemonLifecyclePath)(root);
+    const lock = { token: crypto.randomUUID(), ownerPid: process.pid, createdAt: now, expiresAt: now + DAEMON_LIFECYCLE_TTL_MS };
+    const tmp = `${fixed}.${lock.token}.tmp`;
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(lock), { mode: 0o600 });
+        try {
+            (options.linkSync ?? fs.linkSync)(tmp, fixed);
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'EEXIST')
+                return null;
+            if (code !== 'EPERM' && code !== 'ENOTSUP' && code !== 'EXDEV')
+                throw err;
+            let fd;
+            try {
+                fd = fs.openSync(fixed, 'wx', 0o600);
+            }
+            catch (openErr) {
+                if (openErr.code === 'EEXIST')
+                    return null;
+                throw openErr;
+            }
+            try {
+                fs.writeSync(fd, JSON.stringify(lock));
+                fs.fsyncSync(fd);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* gone */ }
+    }
+    return lock;
+}
+function releaseDaemonLifecycleLock(root, lock) {
+    const fixed = (0, daemon_paths_1.getDaemonLifecyclePath)(root);
+    try {
+        const current = JSON.parse(fs.readFileSync(fixed, 'utf8'));
+        if (current.token === lock.token)
+            fs.unlinkSync(fixed);
+    }
+    catch { /* gone */ }
+}
+function decodeReleaseLease(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (typeof value.token !== 'string' || typeof value.ownerPid !== 'number' ||
+            typeof value.createdAt !== 'number' || typeof value.heartbeatAt !== 'number' ||
+            typeof value.expiresAt !== 'number' || !value.generation ||
+            typeof value.generation.pid !== 'number' || typeof value.generation.startedAt !== 'number' ||
+            typeof value.generation.socketPath !== 'string')
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function recoveryArtifacts(root) {
+    const markerPath = (0, daemon_paths_1.getDaemonReleaseRecoveryPath)(root);
+    const dir = path.dirname(markerPath);
+    const prefix = path.basename(markerPath);
+    try {
+        return fs.readdirSync(dir).filter((name) => name === prefix || name.startsWith(`${prefix}.claim.`)).map((name) => path.join(dir, name));
+    }
+    catch {
+        return [];
+    }
+}
+/** Recover marker/claim files left by a crashed stale-recovery owner. */
+function cleanupExpiredRecoveryArtifacts(root, now) {
+    const markerPath = (0, daemon_paths_1.getDaemonReleaseRecoveryPath)(root);
+    for (const artifact of recoveryArtifacts(root)) {
+        let expiresAt = 0;
+        try {
+            const raw = JSON.parse(fs.readFileSync(artifact, 'utf8'));
+            expiresAt = typeof raw.expiresAt === 'number' ? raw.expiresAt : fs.statSync(artifact).mtimeMs + exports.DAEMON_RELEASE_LEASE_TTL_MS;
+        }
+        catch {
+            try {
+                expiresAt = fs.statSync(artifact).mtimeMs + exports.DAEMON_RELEASE_LEASE_TTL_MS;
+            }
+            catch {
+                continue;
+            }
+        }
+        if (expiresAt > now)
+            continue;
+        if (artifact === markerPath) {
+            const claim = `${markerPath}.claim.marker-${crypto.randomUUID()}`;
+            try {
+                fs.renameSync(markerPath, claim);
+            }
+            catch {
+                continue;
+            }
+            try {
+                fs.unlinkSync(claim);
+            }
+            catch { /* gone */ }
+        }
+        else {
+            // Claims are immutable token-specific generations; deleting the expired
+            // claim cannot target a newly-created fixed marker or lease.
+            try {
+                fs.unlinkSync(artifact);
+            }
+            catch { /* gone */ }
+        }
+    }
+}
+function acquireRecoveryMarker(root, now) {
+    cleanupExpiredRecoveryArtifacts(root, now);
+    if (recoveryArtifacts(root).length !== 0)
+        return null;
+    const markerPath = (0, daemon_paths_1.getDaemonReleaseRecoveryPath)(root);
+    const marker = { token: crypto.randomUUID(), createdAt: now, expiresAt: now + exports.DAEMON_RELEASE_LEASE_TTL_MS };
     try {
-        const info = (0, daemon_paths_1.decodeLockInfo)(fs.readFileSync((0, daemon_paths_1.getDaemonPidPath)(root), 'utf8'));
-        pid = info?.pid ?? null;
+        fs.writeFileSync(markerPath, JSON.stringify(marker), { flag: 'wx', mode: 0o600 });
     }
     catch {
-        /* no lockfile */
+        return null;
+    }
+    return marker;
+}
+function releaseRecoveryMarker(root, marker) {
+    const markerPath = (0, daemon_paths_1.getDaemonReleaseRecoveryPath)(root);
+    try {
+        const current = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+        if (current.token === marker.token)
+            fs.unlinkSync(markerPath);
+    }
+    catch { /* gone or replaced */ }
+}
+/** Recover one expired immutable lease generation under an exclusive marker. */
+function recoverStaleReleaseLease(root, now, afterRead) {
+    const leasePath = (0, daemon_paths_1.getDaemonReleaseLeasePath)(root);
+    let current = null;
+    let modifiedAt = now;
+    try {
+        current = decodeReleaseLease(fs.readFileSync(leasePath, 'utf8'));
+        modifiedAt = fs.statSync(leasePath).mtimeMs;
+    }
+    catch {
+        return true;
+    }
+    // Fallback exclusive-create can be observed while its complete body is being
+    // written. Fail closed for one full TTL; a crashed partial write then expires.
+    const expired = current ? current.expiresAt <= now : modifiedAt + exports.DAEMON_RELEASE_LEASE_TTL_MS <= now;
+    if (!expired)
+        return false;
+    afterRead?.();
+    const marker = acquireRecoveryMarker(root, now);
+    if (!marker)
+        return false;
+    const claimPath = `${(0, daemon_paths_1.getDaemonReleaseRecoveryPath)(root)}.claim.lease-${current?.token ?? crypto.randomUUID()}`;
+    try {
+        try {
+            fs.renameSync(leasePath, claimPath);
+        }
+        catch {
+            return true;
+        }
+        let claimed = null;
+        let claimExpiry = now + exports.DAEMON_RELEASE_LEASE_TTL_MS;
+        try {
+            claimed = decodeReleaseLease(fs.readFileSync(claimPath, 'utf8'));
+            claimExpiry = claimed?.expiresAt ?? fs.statSync(claimPath).mtimeMs + exports.DAEMON_RELEASE_LEASE_TTL_MS;
+        }
+        catch { /* fail closed below */ }
+        if (claimExpiry > now) {
+            // Heartbeat won after our preliminary expired read. Keep its renewed
+            // generation authoritative; the marker blocks startup during restoration.
+            if (fs.existsSync(leasePath)) {
+                const fixed = decodeReleaseLease(fs.readFileSync(leasePath, 'utf8'));
+                if (fixed && fixed.token === claimed?.token && fixed.expiresAt >= claimExpiry) {
+                    try {
+                        fs.unlinkSync(claimPath);
+                    }
+                    catch { /* gone */ }
+                    return false;
+                }
+                return false;
+            }
+            fs.renameSync(claimPath, leasePath);
+            return false;
+        }
+        try {
+            fs.unlinkSync(claimPath);
+        }
+        catch { /* gone */ }
+        return true;
+    }
+    finally {
+        releaseRecoveryMarker(root, marker);
+    }
+}
+/** True while intentional release exclusively owns this root's lifecycle. */
+function hasActiveDaemonReleaseLease(root, now = Date.now(), hooks = {}) {
+    const leasePath = (0, daemon_paths_1.getDaemonReleaseLeasePath)(root);
+    cleanupExpiredRecoveryArtifacts(root, now);
+    if (recoveryArtifacts(root).length !== 0)
+        return true;
+    if (!fs.existsSync(leasePath))
+        return false;
+    return !recoverStaleReleaseLease(root, now, hooks.afterRecoveryRead);
+}
+/** Atomically claim release/cleanup ownership for one daemon generation. */
+function tryAcquireDaemonReleaseLease(root, expected, options = {}) {
+    const now = options.now ?? Date.now();
+    if (hasActiveDaemonReleaseLease(root, now))
+        return null;
+    const leasePath = (0, daemon_paths_1.getDaemonReleaseLeasePath)(root);
+    const lease = {
+        token: crypto.randomUUID(),
+        ownerPid: process.pid,
+        createdAt: now,
+        heartbeatAt: now,
+        expiresAt: now + exports.DAEMON_RELEASE_LEASE_TTL_MS,
+        generation: { pid: expected.pid, startedAt: expected.startedAt, socketPath: expected.socketPath },
+    };
+    // Publish a fully-written immutable record in one atomic exclusive link, the
+    // same primitive used by daemon.pid. No observer can see an empty lease.
+    const tmpPath = `${leasePath}.${lease.token}.tmp`;
+    try {
+        fs.writeFileSync(tmpPath, JSON.stringify(lease, null, 2) + '\n', { mode: 0o600 });
+        try {
+            (options.linkSync ?? fs.linkSync)(tmpPath, leasePath);
+        }
+        catch (err) {
+            if (err.code === 'EEXIST')
+                return null;
+            // Mirror daemon.pid's portable fallback for filesystems without hard
+            // links. O_EXCL keeps acquisition exclusive; readers fail closed while
+            // the complete body is written through the owning descriptor.
+            let fd;
+            try {
+                fd = fs.openSync(leasePath, 'wx', 0o600);
+            }
+            catch (openErr) {
+                if (openErr.code === 'EEXIST')
+                    return null;
+                throw openErr;
+            }
+            try {
+                fs.writeSync(fd, JSON.stringify(lease, null, 2) + '\n');
+                fs.fsyncSync(fd);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
     }
-    if (pid == null) {
-        const rec = listDaemons({ prune: false }).find((r) => path.resolve(r.root) === path.resolve(root));
-        pid = rec?.pid ?? null;
+    finally {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { /* gone */ }
     }
-    if (pid == null) {
-        cleanupDaemonArtifacts(root);
-        return { root, pid: null, outcome: 'no-daemon' };
+    return lease;
+}
+/** Publish a complete renewed generation atomically under the recovery marker. */
+function refreshDaemonReleaseLease(root, lease, now = Date.now()) {
+    const leasePath = (0, daemon_paths_1.getDaemonReleaseLeasePath)(root);
+    const marker = acquireRecoveryMarker(root, now);
+    if (!marker)
+        return false;
+    const tmpPath = `${leasePath}.${lease.token}.heartbeat.tmp`;
+    try {
+        const current = decodeReleaseLease(fs.readFileSync(leasePath, 'utf8'));
+        if (current?.token !== lease.token)
+            return false;
+        lease.heartbeatAt = now;
+        lease.expiresAt = now + exports.DAEMON_RELEASE_LEASE_TTL_MS;
+        fs.writeFileSync(tmpPath, JSON.stringify(lease, null, 2) + '\n', { mode: 0o600 });
+        fs.renameSync(tmpPath, leasePath);
+        return true;
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { /* published or gone */ }
+        releaseRecoveryMarker(root, marker);
+    }
+}
+function releaseDaemonReleaseLease(root, lease) {
+    const leasePath = (0, daemon_paths_1.getDaemonReleaseLeasePath)(root);
+    let current = null;
+    try {
+        current = decodeReleaseLease(fs.readFileSync(leasePath, 'utf8'));
     }
-    if (!isProcessAlive(pid)) {
-        cleanupDaemonArtifacts(root);
-        return { root, pid, outcome: 'not-running' };
+    catch {
+        return;
     }
-    // POSIX: SIGTERM runs the daemon's graceful shutdown. Windows: TerminateProcess
-    // (no graceful path), so we always sweep artifacts ourselves below.
+    if (current?.token !== lease.token)
+        return;
     try {
-        process.kill(pid, 'SIGTERM');
+        fs.unlinkSync(leasePath);
+    }
+    catch { /* gone */ }
+}
+/** Resolve an explicit project root to the same canonical form daemons use. */
+function canonicalDaemonRoot(root) {
+    return fs.realpathSync(path.resolve(root));
+}
+/** Stable map/set key for aliases of the same canonical root. */
+function canonicalDaemonRootKey(root) {
+    const canonical = canonicalDaemonRoot(root);
+    return process.platform === 'win32' ? canonical.toLowerCase() : canonical;
+}
+/** Project-scoped, idempotent release contract shared by CLI and MCP. */
+async function releaseDaemonAt(root, deps = {}) {
+    return stopDaemonAt(canonicalDaemonRoot(root), deps);
+}
+/**
+ * Release the daemon serving `root` through its authenticated socket handshake,
+ * wait for confirmed process death, then sweep ownership artifacts. Never sends
+ * a signal based only on pidfile/registry liveness. `root` must be realpath'd.
+ */
+async function stopDaemonAt(root, deps = {}) {
+    let lifecycle = null;
+    for (let attempt = 0; attempt < 100 && !lifecycle; attempt++) {
+        lifecycle = tryAcquireDaemonLifecycleLock(root);
+        if (!lifecycle)
+            await sleep(10);
     }
-    catch { /* raced to exit */ }
-    let outcome = 'term';
-    if (!(await waitForDeath(pid, 3000))) {
+    if (!lifecycle) {
+        return { root, pid: null, outcome: 'unreachable', failure: 'Project lifecycle arbitration is busy.' };
+    }
+    let expected = null;
+    let lease = null;
+    try {
+        deps.afterLifecycleAcquired?.();
         try {
-            process.kill(pid, 'SIGKILL');
+            const info = (0, daemon_paths_1.decodeLockInfo)(fs.readFileSync((0, daemon_paths_1.getDaemonPidPath)(root), 'utf8'));
+            if (info)
+                expected = { root, ...info };
+        }
+        catch { /* no lockfile */ }
+        if (!expected) {
+            const rec = listDaemons({ prune: false }).find((r) => path.resolve(r.root) === path.resolve(root));
+            if (rec)
+                expected = { ...rec, root };
         }
-        catch { /* raced to exit */ }
-        await waitForDeath(pid, 2000);
-        outcome = 'kill';
+        if (!expected)
+            return { root, pid: null, outcome: 'no-daemon' };
+        lease = tryAcquireDaemonReleaseLease(root, expected, { linkSync: deps.leaseLinkSync });
+        if (!lease)
+            return { root, pid: expected.pid, outcome: 'unreachable', failure: 'A project release is already in progress.' };
+        deps.afterReleaseLeasePublished?.(expected);
     }
-    cleanupDaemonArtifacts(root);
-    return { root, pid, outcome };
+    finally {
+        releaseDaemonLifecycleLock(root, lifecycle);
+    }
+    const alive = deps.isAlive ?? isProcessAlive;
+    const heartbeat = setInterval(() => refreshDaemonReleaseLease(root, lease), DAEMON_RELEASE_HEARTBEAT_MS);
+    heartbeat.unref?.();
+    try {
+        if (!alive(expected.pid)) {
+            cleanupDaemonArtifacts(root, expected, deps.beforeArtifactDelete);
+            return { root, pid: expected.pid, outcome: 'not-running' };
+        }
+        const control = await (deps.requestControl ?? requestDaemonRelease)(expected);
+        if (control !== 'releasing') {
+            return {
+                root,
+                pid: expected.pid,
+                outcome: control,
+                failure: control === 'identity-mismatch'
+                    ? 'The reachable process did not prove ownership of this canonical root and daemon generation.'
+                    : 'The daemon control socket could not be reached; no process was signalled.',
+            };
+        }
+        const died = await (deps.waitForDeath ?? waitForDeath)(expected.pid, 5000);
+        if (!died) {
+            return {
+                root,
+                pid: expected.pid,
+                outcome: 'termination-failed',
+                failure: 'The daemon accepted release but did not terminate before the timeout; ownership artifacts were preserved.',
+            };
+        }
+        cleanupDaemonArtifacts(root, expected, deps.beforeArtifactDelete);
+        return { root, pid: expected.pid, outcome: 'released' };
+    }
+    finally {
+        clearInterval(heartbeat);
+        releaseDaemonReleaseLease(root, lease);
+    }
+}
+async function requestDaemonRelease(expected) {
+    const candidates = [expected.socketPath, ...(0, daemon_paths_1.getDaemonSocketCandidates)(expected.root)]
+        .filter((value, index, all) => Boolean(value) && all.indexOf(value) === index);
+    for (const socketPath of candidates) {
+        const result = await requestReleaseAtSocket(socketPath, expected);
+        if (result !== 'unreachable')
+            return result;
+    }
+    return 'unreachable';
+}
+function requestReleaseAtSocket(socketPath, expected) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection(socketPath);
+        socket.setEncoding('utf8');
+        let buffer = '';
+        let phase = 'hello';
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish('unreachable'), 1500);
+        timer.unref?.();
+        socket.on('error', () => finish('unreachable'));
+        socket.on('close', () => finish('unreachable'));
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            let newline;
+            while ((newline = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                let value;
+                try {
+                    value = JSON.parse(line);
+                }
+                catch {
+                    finish('identity-mismatch');
+                    return;
+                }
+                if (phase === 'hello') {
+                    const verified = value.protocol === 1 && value.pid === expected.pid &&
+                        value.codegraph === expected.version && value.root === expected.root &&
+                        value.startedAt === expected.startedAt && value.socketPath === expected.socketPath;
+                    if (!verified) {
+                        finish('identity-mismatch');
+                        return;
+                    }
+                    phase = 'response';
+                    socket.write(JSON.stringify({
+                        codegraph_control: 1,
+                        action: 'release',
+                        root: expected.root,
+                        pid: expected.pid,
+                        startedAt: expected.startedAt,
+                    }) + '\n');
+                }
+                else {
+                    finish(value.codegraph_control === 1 && value.outcome === 'releasing' ? 'releasing' : 'identity-mismatch');
+                    return;
+                }
+            }
+        });
+    });
 }
 /** Stop every registered, live daemon. */
 async function stopAllDaemons() {