@relaycast/engine 12.0.0 → 12.2.0

package/dist/engine/node.js

@@ -1,10 +1,13 @@
+import { nodeMayOwn, providerLive, filterAsync, nodeLivenessAuthority, inspectNodeLiveness, snapshotOnline } from './nodeLiveness.js';
 import { z } from 'zod';
 import { invalidateChannelCache } from './cache.js';
 import { and, asc, eq, exists, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notExists, or, sql } from 'drizzle-orm';
 import { FLEET_ACTION_CALLER_METADATA_KEY, FLEET_ACTION_CALLER_METADATA_VERSION, FLEET_DELIVERY_CURSOR_CAPABILITY, NODE_REGISTRATION_CONTRACT_V1, parseFleetBrokerToRelaycastMessage, } from '@relaycast/types';
-import { actionInvocations, agents, agentNodeBindings, channelMembers, channels, nodeProviders, nodes } from '../db/schema.js';
+import { actionInvocations, agents, agentNodeBindings, channelMembers, channels, nodeProviders, nodes, workspaces } from '../db/schema.js';
+import { isWorkspaceExpired, WORKSPACE_EXPIRED_CODE, WORKSPACE_EXPIRED_MESSAGE } from '../auth/workspaceExpiry.js';
 import { randomHex, sha256Hex } from '../lib/crypto.js';
 import { codedError } from '../lib/httpError.js';
+import { AdmissionDeniedError } from '../lib/admissionError.js';
 import { acceptTaskInvocation, completeTaskInvocation } from './taskInvocation.js';
 import { databaseConstraintKind, runAtomic, runAtomicWrites } from '../ports/database.js';
 import { retryD1Write } from '../lib/d1Retry.js';
@@ -23,8 +26,10 @@ function resolveProviderIdentity(message, connectionId) {
         return message.provider;
     return { name: DEFAULT_PROVIDER_NAME, instance_id: connectionId ?? generateId() };
 }
+/** Id prefix of the implicit direct node minted for every agent; reserved. */
+export const IMPLICIT_DIRECT_NODE_ID_PREFIX = 'node_direct_';
 export function directNodeIdForAgent(agentId) {
-    return `node_direct_${agentId}`;
+    return `${IMPLICIT_DIRECT_NODE_ID_PREFIX}${agentId}`;
 }
 function directNodeNameForAgent(agentId) {
     return `direct-${agentId}`;
@@ -215,8 +220,8 @@ async function connectionNegotiatedDeliveryCursor(db, registry, workspaceId, nod
 function requestId(message) {
     return message.id ?? generateId();
 }
-function publicNode(row, now) {
-    const live = isNodeLive(row, now);
+function publicNode(row, now, authoritativeLive, authorityStatus) {
+    const live = authoritativeLive ?? isNodeLive(row, now);
     return {
         id: row.id,
         name: row.name,
@@ -229,6 +234,7 @@ function publicNode(row, now) {
         tags: row.tags,
         version: row.version,
         status: live ? 'online' : 'offline',
+        ...(authorityStatus ? { liveness_status: authorityStatus } : {}),
         live,
         handlers_live: live && row.handlersLive,
         load: row.loadReported ? row.load : null,
@@ -314,6 +320,14 @@ export async function createNodeToken(db, workspaceId, data, authorization = {})
     if (!name || name.startsWith('#')) {
         throw codedError('Node name must be non-empty and cannot begin with "#"', 'invalid_node_name', 400);
     }
+    // `node_direct_<agent id>` is the engine-minted implicit direct node, which
+    // the device count excludes. The namespace is reserved so a host cannot
+    // enroll a node that is miscounted as implicit.
+    if (data.node_id !== undefined
+        && authorization.directAgentId === undefined
+        && data.node_id.startsWith(IMPLICIT_DIRECT_NODE_ID_PREFIX)) {
+        throw codedError(`Node ids beginning with "${IMPLICIT_DIRECT_NODE_ID_PREFIX}" are reserved for implicit direct nodes`, 'reserved_node_id', 400);
+    }
     // Enrollment keys on node_id (the stable identity) when supplied; the name
     // lookup is only a fallback for callers without a stable id. A name held by
     // a *different* node id is a conflict — mirroring node.register — never a
@@ -345,6 +359,13 @@ export async function createNodeToken(db, workspaceId, data, authorization = {})
     if (role === 'direct' && maxAgents !== 1) {
         throw codedError('Direct nodes can bind at most one agent', 'direct_node_capacity_exceeded', 400);
     }
+    // Only a NEW device is admitted. Rotating or re-enrolling an established
+    // row never is (its role may change, but it was admitted when it was
+    // enrolled), and an agent's implicit direct node — minted on its behalf,
+    // never enrolled by a host — is its own WebSocket, not a device.
+    if (!existing && authorization.directAgentId === undefined && authorization.admitRegistration) {
+        await authorization.admitRegistration('register_device');
+    }
     if (existing) {
         const hasPresentedTokenProof = authorization.expectedTokenHash !== undefined;
         const authorizedDirectNode = authorization.directAgentId !== undefined
@@ -404,7 +425,9 @@ export async function createNodeToken(db, workspaceId, data, authorization = {})
             // Token proof is a generation fence, not just a read-time check. If a
             // concurrent rotation changes the credential after `existing` was read,
             // this request must not overwrite the winner with stale authority.
-            .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, existing.id), ...(hasPresentedTokenProof && !authorizedDirectNode
+            .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, existing.id), 
+        // Accepted reconnect/register advances this revision before its lease.
+        ...(nodeLivenessAuthority(db) ? [eq(nodes.livenessRevision, existing.livenessRevision)] : []), ...(hasPresentedTokenProof && !authorizedDirectNode
             ? [eq(nodes.tokenHash, authorization.expectedTokenHash)]
             : [])))
             .returning();
@@ -521,7 +544,7 @@ export async function getBrokerNodeByMachineId(db, workspaceId, machineId, expec
             .from(nodes)
             .where(and(reusableWhere, eq(nodes.tokenHash, expectedTokenHash)))
             .limit(1);
-        if (provenCandidate && isReusableForMachineMatch(provenCandidate)) {
+        if (provenCandidate && await reusableMachineNode(db, provenCandidate)) {
             return provenCandidate;
         }
     }
@@ -535,7 +558,7 @@ export async function getBrokerNodeByMachineId(db, workspaceId, machineId, expec
     // single definition of reusability and mirrors it exactly — including
     // treating an `online` row with a future heartbeat as live. Re-checking here
     // keeps that definition authoritative rather than trusting the query alone.
-    return candidates.find((node) => isReusableForMachineMatch(node)) ?? null;
+    return (await filterAsync(candidates, node => reusableMachineNode(db, node)))[0] ?? null;
 }
 /**
  * The role an enroll is asking for, derived from the request alone.
@@ -1053,8 +1076,14 @@ export async function deregisterProvider(db, registry, workspaceId, nodeId, prov
     }
 }
 export async function sweepOfflineNodes(db, registry, deps) {
+    // Only the external socket owner can fence this transition with reconnect.
+    if (nodeLivenessAuthority(db))
+        return 0;
     const rows = await db.select().from(nodes).where(eq(nodes.status, 'online'));
-    const stale = rows.filter((node) => !isNodeLive(node));
+    const stale = await filterAsync(rows, async (node) => {
+        const authority = await inspectNodeLiveness(db, node.workspaceId, node.id);
+        return authority ? authority.status === 'offline' : !isNodeLive(node);
+    });
     let swept = 0;
     for (const node of stale) {
         const offlined = await serializeNodeOp(node.workspaceId, node.id, async () => {
@@ -1064,7 +1093,14 @@ export async function sweepOfflineNodes(db, registry, deps) {
                 .select()
                 .from(nodes)
                 .where(and(eq(nodes.workspaceId, node.workspaceId), eq(nodes.id, node.id)));
-            if (!current || current.status !== 'online' || isNodeLive(current))
+            if (!current || current.status !== 'online')
+                return false;
+            const authority = await inspectNodeLiveness(db, current.workspaceId, current.id);
+            if (authority ? authority.status !== 'offline' : isNodeLive(current))
+                return false;
+            // External owners serialize offline transitions with reconnect; this
+            // generic sweep cannot hold that fence across markNodeOffline.
+            if (authority)
                 return false;
             await markNodeOffline(db, registry, node.workspaceId, node.id, { deps, reason: 'liveness_timeout' });
             return true;
@@ -1445,6 +1481,7 @@ export async function bindAgentToNode(db, workspaceId, nodeName, agentName, opts
         // stranded on its implicit `direct-*` pseudo-node and never woken — the
         // exact shape of the broker's create-only register falling back to this
         // endpoint. `unbindAgentFromNode` already assumes this move happened.
+        let incumbentNode;
         if (agent.status === 'active'
             && agent.locationNodeId
             && agent.locationNodeId !== node.id
@@ -1455,16 +1492,17 @@ export async function bindAgentToNode(db, workspaceId, nodeName, agentName, opts
                 .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, agent.locationNodeId)));
             // A dead or missing prior location is not a conflict — it is exactly what
             // a bind is for. Only a live one still owns the identity.
-            if (locatedNode && isNodeLive(locatedNode)) {
+            if (locatedNode && await nodeMayOwn(db, locatedNode)) {
                 throw codedError(`Agent "${agentName}" is already active on another live location`, 'agent_location_conflict', 409);
             }
+            incumbentNode = locatedNode;
         }
         // Provider rows persist after a disconnect so the node keeps its capability
         // manifest; they are history, not sockets. Adopt only among providers that
         // can actually receive a push right now — keeping or choosing an offline
         // row while a live sibling serves the node would point the agent at a
         // provider connection that does not exist.
-        const liveProviderNames = (await tx
+        const providerCandidates = await tx
             .select({
             name: nodeProviders.name,
             status: nodeProviders.status,
@@ -1472,9 +1510,8 @@ export async function bindAgentToNode(db, workspaceId, nodeName, agentName, opts
             lastHeartbeatAt: nodeProviders.lastHeartbeatAt,
         })
             .from(nodeProviders)
-            .where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, node.id))))
-            .filter((provider) => isProviderLive(provider))
-            .map((row) => row.name);
+            .where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, node.id)));
+        const liveProviderNames = (await filterAsync(providerCandidates, provider => providerLive(db, workspaceId, node.id, provider))).map(row => row.name);
         const adoptedProviderName = adoptNodeProviderName(agent.providerName, liveProviderNames);
         const activeNodeIds = await activeBindingNodeIdsForAgent(tx, workspaceId, agent.id);
         const targetWasActive = activeNodeIds.includes(node.id);
@@ -1492,6 +1529,9 @@ export async function bindAgentToNode(db, workspaceId, nodeName, agentName, opts
             // charges the old node forever, because the retry that would fix either
             // reads the half-applied state as already done.
             const buildMoveWrites = (writeDb) => [
+                ...(incumbentNode && nodeLivenessAuthority(db) ? [writeDb.update(nodes).set({
+                        activeAgents: sql `CASE WHEN ${nodes.livenessRevision} = ${incumbentNode.livenessRevision} THEN ${nodes.activeAgents} ELSE NULL END`,
+                    }).where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, incumbentNode.id)))] : []),
                 ...agentNodeBindingWrites(writeDb, workspaceId, agent, node.id, {
                     sessionRef: opts.session_ref ?? null,
                     priority: opts.priority ?? 0,
@@ -1610,6 +1650,16 @@ export async function listNodeAgents(db, workspaceId, nodeName) {
 export async function registerAgentViaNode(db, workspaceId, nodeId, providerName, message, options = {}) {
     assertRegistrableAgentName(message.name);
     const wantsAutoJoin = message.auto_join_general !== false;
+    if (options.admitRegistration) {
+        // Only a NEW identity is admitted: an established name is answered by the
+        // conflict below, never by a denial.
+        const [established] = await db
+            .select({ id: agents.id })
+            .from(agents)
+            .where(and(eq(agents.workspaceId, workspaceId), eq(agents.name, message.name)));
+        if (!established)
+            await options.admitRegistration('register_agent');
+    }
     const registered = await runAtomic(db, async (tx) => {
         // Every awaited statement is a separate D1 round-trip — and this path runs
         // under the node-control liveness deadline whose misses surface as
@@ -2032,7 +2082,9 @@ export async function reconcileInventory(db, registry, workspaceId, nodeId, prov
     const acceptedInventoryAgents = [];
     const rejectedInventoryErrors = [];
     const legacyDefaultAdoptions = new Set();
+    const incumbentRevisions = new Map();
     let canAdoptLegacyDefault;
+    let authorityAdoption;
     let acceptedExistingAgentCount = 0;
     for (const item of inventoryAgents) {
         const [existing] = await db
@@ -2063,8 +2115,23 @@ export async function reconcileInventory(db, registry, workspaceId, nodeId, prov
                     .where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), inArray(nodeProviders.name, [DEFAULT_PROVIDER_NAME, 'broker'])));
                 const defaultProvider = providerRows.find((row) => row.name === DEFAULT_PROVIDER_NAME);
                 const brokerProvider = providerRows.find((row) => row.name === 'broker');
-                canAdoptLegacyDefault = !!brokerProvider && isProviderLive(brokerProvider)
-                    && (!defaultProvider || !isProviderLive(defaultProvider));
+                const authority = await inspectNodeLiveness(db, workspaceId, nodeId);
+                if (authority) {
+                    const now = Date.now();
+                    const brokerLease = authority.providers.find(p => p.name === 'broker' && p.live && p.handlers_live && p.expires_at > now && p.last_received_at <= now);
+                    const defaultLive = authority.providers.some(p => p.name === DEFAULT_PROVIDER_NAME && p.live && p.handlers_live && p.expires_at > now && p.last_received_at <= now);
+                    canAdoptLegacyDefault = authority.status === 'online' && !!brokerProvider && !!brokerLease && !defaultLive;
+                    if (canAdoptLegacyDefault && brokerProvider && brokerLease)
+                        authorityAdoption = {
+                            brokerId: brokerProvider.id, brokerRevision: brokerProvider.livenessRevision,
+                            defaultId: defaultProvider?.id, defaultRevision: defaultProvider?.livenessRevision,
+                            expiresAt: brokerLease.expires_at,
+                        };
+                }
+                else {
+                    canAdoptLegacyDefault = !!brokerProvider && isProviderLive(brokerProvider)
+                        && (!defaultProvider || !isProviderLive(defaultProvider));
+                }
             }
             if (legacyDefaultClaim && canAdoptLegacyDefault) {
                 legacyDefaultAdoptions.add(item.name);
@@ -2078,7 +2145,9 @@ export async function reconcileInventory(db, registry, workspaceId, nodeId, prov
                 .select()
                 .from(nodes)
                 .where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, existing.locationNodeId ?? '')));
-            const boundNodeLive = !!boundNode && isNodeLive(boundNode);
+            const boundNodeLive = !!boundNode && await nodeMayOwn(db, boundNode);
+            if (boundNode && boundNode.id !== nodeId && !boundNodeLive && nodeLivenessAuthority(db))
+                incumbentRevisions.set(item.name, { id: boundNode.id, revision: boundNode.livenessRevision });
             const conflict = existing.locationType !== 'via_node'
                 || !existing.locationNodeId
                 || (existing.locationNodeId !== nodeId && boundNodeLive && !isImplicitDirectLocation(existing));
@@ -2146,6 +2215,7 @@ export async function reconcileInventory(db, registry, workspaceId, nodeId, prov
         spawnReservedAt: actionInvocations.spawnReservedAt,
         attemptedNodeIds: actionInvocations.attemptedNodeIds,
         dispatchAttempts: actionInvocations.dispatchAttempts,
+        retryAfterAt: actionInvocations.retryAfterAt,
     })
         .from(actionInvocations)
         .where(and(eq(actionInvocations.workspaceId, workspaceId), eq(actionInvocations.dispatchedNodeId, nodeId), eq(actionInvocations.dispatchedProvider, providerName), inArray(actionInvocations.status, ['pending', 'dispatched'])));
@@ -2178,14 +2248,24 @@ export async function reconcileInventory(db, registry, workspaceId, nodeId, prov
                 // compare-and-set fences broker liveness loss, a default provider
                 // reconnecting, and concurrent ownership changes during the apply pass.
                 const adoptionNow = Date.now();
-                const noLiveDefaultProvider = notExists(db
+                let noLiveDefaultProvider = notExists(db
                     .select({ id: nodeProviders.id })
                     .from(nodeProviders)
                     .where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), eq(nodeProviders.name, DEFAULT_PROVIDER_NAME), eq(nodeProviders.status, 'online'), eq(nodeProviders.handlersLive, true), gte(nodeProviders.lastHeartbeatAt, new Date(adoptionNow - NODE_LIVENESS_TTL_MS)), lte(nodeProviders.lastHeartbeatAt, new Date(adoptionNow)))));
-                const liveBrokerProvider = exists(db
+                let liveBrokerProvider = exists(db
                     .select({ id: nodeProviders.id })
                     .from(nodeProviders)
                     .where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), eq(nodeProviders.name, 'broker'), eq(nodeProviders.status, 'online'), eq(nodeProviders.handlersLive, true), gte(nodeProviders.lastHeartbeatAt, new Date(adoptionNow - NODE_LIVENESS_TTL_MS)), lte(nodeProviders.lastHeartbeatAt, new Date(adoptionNow)))));
+                if (authorityAdoption) {
+                    // Every accepted register/reconnect advances the provider revision
+                    // before renewing its owner lease. Fence those generations in the
+                    // same SQL update, and reject if the observed broker lease expires.
+                    const proof = authorityAdoption;
+                    noLiveDefaultProvider = proof.defaultId
+                        ? exists(db.select({ id: nodeProviders.id }).from(nodeProviders).where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), eq(nodeProviders.name, DEFAULT_PROVIDER_NAME), eq(nodeProviders.id, proof.defaultId), eq(nodeProviders.livenessRevision, proof.defaultRevision))))
+                        : notExists(db.select({ id: nodeProviders.id }).from(nodeProviders).where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), eq(nodeProviders.name, DEFAULT_PROVIDER_NAME))));
+                    liveBrokerProvider = exists(db.select({ id: nodeProviders.id }).from(nodeProviders).where(and(eq(nodeProviders.workspaceId, workspaceId), eq(nodeProviders.nodeId, nodeId), eq(nodeProviders.name, 'broker'), eq(nodeProviders.id, proof.brokerId), eq(nodeProviders.livenessRevision, proof.brokerRevision), sql `unixepoch() * 1000 < ${proof.expiresAt}`)));
+                }
                 const [updated] = await db
                     .update(agents)
                     .set({
@@ -2197,7 +2277,7 @@ export async function reconcileInventory(db, registry, workspaceId, nodeId, prov
                     originNodeId: existing.originNodeId ?? nodeId,
                     sessionRef: item.session_ref ?? existing.sessionRef,
                 })
-                    .where(and(eq(agents.workspaceId, workspaceId), eq(agents.id, existing.id), ...(adoptingLegacyDefault ? [
+                    .where(and(eq(agents.workspaceId, workspaceId), eq(agents.id, existing.id), ...(incumbentRevisions.has(item.name) ? [notExists(db.select({ id: nodes.id }).from(nodes).where(and(eq(nodes.workspaceId, workspaceId), eq(nodes.id, incumbentRevisions.get(item.name).id), ne(nodes.livenessRevision, incumbentRevisions.get(item.name).revision))))] : []), ...(adoptingLegacyDefault ? [
                     eq(agents.providerName, DEFAULT_PROVIDER_NAME),
                     eq(agents.locationType, 'via_node'),
                     eq(agents.locationNodeId, nodeId),
@@ -2404,7 +2484,7 @@ export async function listNodes(db, workspaceId, filters = {}) {
         conditions.push(eq(nodes.name, filters.name));
     if (filters.capability)
         conditions.push(capabilityMatchCondition(filters.capability));
-    if (filters.status)
+    if (filters.status && !nodeLivenessAuthority(db))
         conditions.push(livenessCondition(filters.status, now));
     // Observer authorization is a WHERE condition, evaluated in the same query
     // as every other filter and therefore before pagination/cursor computation
@@ -2418,7 +2498,7 @@ export async function listNodes(db, workspaceId, filters = {}) {
         // that predates the history/status selector. `name`/`capability`/`status`
         // are still evaluated in SQL instead of after a full-table fetch.
         const rows = await db.select().from(nodes).where(and(...conditions));
-        const page = rows.map((row) => publicNode(row, now.getTime()));
+        const page = await publicNodes(db, rows, now.getTime(), filters.status);
         if (!filters.observerAgentIds)
             return { nodes: page, nextCursor: null };
         const counts = await visibleActiveAgentCounts(db, workspaceId, rows.map((row) => row.id), filters.observerAgentIds);
@@ -2438,7 +2518,7 @@ export async function listNodes(db, workspaceId, filters = {}) {
         .limit(limit + 1);
     const page = rows.slice(0, limit);
     const nextCursor = rows.length > limit ? page[page.length - 1].id : null;
-    const publicPage = page.map((row) => publicNode(row, now.getTime()));
+    const publicPage = await publicNodes(db, page, now.getTime(), filters.status);
     if (!filters.observerAgentIds)
         return { nodes: publicPage, nextCursor };
     const counts = await visibleActiveAgentCounts(db, workspaceId, page.map((row) => row.id), filters.observerAgentIds);
@@ -2449,7 +2529,7 @@ export async function listNodes(db, workspaceId, filters = {}) {
 }
 export async function getPublicNode(db, workspaceId, name) {
     const node = await getNodeByName(db, workspaceId, name);
-    return node ? publicNode(node) : null;
+    return node ? (await publicNodes(db, [node], Date.now()))[0] : null;
 }
 /** The node's persisted `status` column, or undefined when the node is gone. */
 async function readNodeStatus(db, workspaceId, nodeId) {
@@ -2534,6 +2614,30 @@ function sendControl(socket, payload) {
     }
 }
 /** Validate and serialize an authenticated node frame, replying only after its effects. */
+/**
+ * A node socket authenticates once, at upgrade. A workspace deleted (or past
+ * its deadline) afterwards keeps that socket, and a large workspace is drained
+ * in steps with its nodes last, so frames that create identity must re-check:
+ * otherwise a connected node registers agents into a workspace being deleted.
+ */
+/** Control frames still admitted after the workspace expires (see the gate below). */
+const SETTLING_CONTROL_FRAMES = new Set([
+    'action.accept',
+    'action.result',
+    'delivery.ack',
+    'node.deregister',
+    'agent.deregister',
+]);
+async function assertWorkspaceUnexpired(db, workspaceId) {
+    const [row] = await db
+        .select({ expiresAt: workspaces.expiresAt })
+        .from(workspaces)
+        .where(eq(workspaces.id, workspaceId))
+        .limit(1);
+    if (!row || isWorkspaceExpired(row)) {
+        throw codedError(WORKSPACE_EXPIRED_MESSAGE, WORKSPACE_EXPIRED_CODE, 401);
+    }
+}
 export async function handleNodeControlMessage(args) {
     let message;
     try {
@@ -2573,6 +2677,12 @@ export async function handleNodeControlMessage(args) {
     // check, the provider-row upsert, or the aggregate recompute.
     return serializeNodeOp(args.workspaceId, args.nodeId, async () => {
         try {
+            // A socket outlives its workspace's deletion, and every other frame writes
+            // durable state (a heartbeat can insert provider and action rows). Only
+            // frames that settle work already in flight or tear identity down pass.
+            if (!SETTLING_CONTROL_FRAMES.has(message.type)) {
+                await assertWorkspaceUnexpired(args.db, args.workspaceId);
+            }
             switch (message.type) {
                 case 'node.register': {
                     const provider = resolveProviderIdentity(message, args.connectionId);
@@ -2705,7 +2815,10 @@ export async function handleNodeControlMessage(args) {
                     return;
                 }
                 case 'agent.register': {
-                    const registered = await registerAgentViaNode(args.db, args.workspaceId, args.nodeId, frameProviderName, message, { deliveryCursorSupported: supportsProviderDeliveryReadiness(args.registry) });
+                    const registered = await registerAgentViaNode(args.db, args.workspaceId, args.nodeId, frameProviderName, message, {
+                        deliveryCursorSupported: supportsProviderDeliveryReadiness(args.registry),
+                        admitRegistration: args.admitRegistration,
+                    });
                     // The relay broker's node_control client awaits a `reply` frame keyed by
                     // the request id (it matches `pending_agent_registrations` by `reply.id`
                     // and parses `data` as {agent_id, token, name} with deny_unknown_fields).
@@ -2732,6 +2845,11 @@ export async function handleNodeControlMessage(args) {
                 }
                 case 'agent.recover': {
                     const recovered = await recoverAgentViaNode(args.db, args.workspaceId, args.nodeId, frameProviderName, message, { deliveryCursorSupported: supportsProviderDeliveryReadiness(args.registry) });
+                    // Inventory only clears a hold for an agent it newly routes. A
+                    // presence-only disconnect leaves the binding active, so the next
+                    // sync would keep the hold. Recovery is the node putting that agent
+                    // back, and node liveness should count them without an HTTP heartbeat.
+                    await args.presence?.clearExplicitDisconnect?.(args.workspaceId, recovered.agent_id);
                     const replySent = sendControl(args.socket, {
                         v: 1,
                         id: requestId(message),
@@ -2755,6 +2873,13 @@ export async function handleNodeControlMessage(args) {
                     return;
                 case 'inventory.sync': {
                     const result = await reconcileInventory(args.db, args.registry, args.workspaceId, args.nodeId, frameProviderName, message.agents, args.completionDeps);
+                    // An agent the node had dropped and is routing again is a new hosting
+                    // episode. Clear a presence-only disconnect so node liveness can count
+                    // them without an HTTP heartbeat. An agent the snapshot already
+                    // routed keeps the hold: still being listed is not recovery.
+                    if (args.presence?.clearExplicitDisconnect && result.newlyRoutedAgentIds.length > 0) {
+                        await Promise.all(result.newlyRoutedAgentIds.map((agentId) => args.presence.clearExplicitDisconnect(args.workspaceId, agentId)));
+                    }
                     const replySent = sendControl(args.socket, {
                         v: 1,
                         id: requestId(message),
@@ -2836,7 +2961,8 @@ export async function handleNodeControlMessage(args) {
         }
         catch (err) {
             const error = err;
-            const code = error.code ?? 'node_control_failed';
+            const denial = err instanceof AdmissionDeniedError ? err.denial : null;
+            const code = denial?.code ?? error.code ?? 'node_control_failed';
             // The rejection reaches the client only as the error frame below. Log it so
             // it is not invisible server-side: a rejected node.register/node.heartbeat
             // (e.g. node_name_conflict, a UNIQUE violation) otherwise leaves a node
@@ -2850,7 +2976,10 @@ export async function handleNodeControlMessage(args) {
                 provider: frameProviderName,
                 message: error.message,
             });
+            // An admission denial carries the host's details, as on the HTTP error;
+            // the frame's own fields always win over them.
             sendControl(args.socket, {
+                ...(denial?.details ?? {}),
                 v: 1,
                 id: requestId(message),
                 type: 'error',
@@ -2861,4 +2990,28 @@ export async function handleNodeControlMessage(args) {
         }
     });
 }
+async function publicNodes(db, rows, now, status) {
+    if (!nodeLivenessAuthority(db))
+        return rows.map(row => publicNode(row, now));
+    const result = [];
+    await filterAsync(rows, async (row) => {
+        const snapshot = await inspectNodeLiveness(db, row.workspaceId, row.id);
+        const live = !!snapshot && snapshotOnline(snapshot);
+        const item = publicNode(row, now, live, snapshot?.status ?? 'unknown');
+        // Readiness is owned by the fresh lease, independently of checkpointed
+        // catalog metadata in nodes.handlers_live.
+        const receivedAt = Date.now();
+        item.handlers_live = live && !!snapshot?.providers.some(p => p.live && p.handlers_live && p.expires_at > receivedAt && p.last_received_at <= receivedAt);
+        if (!status || item.status === status)
+            result.push(item);
+        return true;
+    });
+    // Concurrent probes must not scramble stable list ordering.
+    const positions = new Map(rows.map((row, index) => [row.id, index]));
+    return result.sort((a, b) => positions.get(a.id) - positions.get(b.id));
+}
+async function reusableMachineNode(db, node) {
+    const authority = await inspectNodeLiveness(db, node.workspaceId, node.id);
+    return authority ? authority.status === 'offline' : isReusableForMachineMatch(node);
+}
 //# sourceMappingURL=node.js.map